//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;
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.23;
contract SimpleStore {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
}pragma solidity ^0.4.18;
//Made to Stackexchange question
contract ERC20 {
function transfer(address _to, uint256 _value)public returns(bool);
function balanceOf(address tokenOwner)public view returns(uint balance);
function transferFrom(address from, address to, uint tokens)public returns(bool success);
}
contract SimpleAirdrop {
ERC20 public token;
function SimpleAirdrop(address _tokenAddr) public {
token = ERC20(_tokenAddr);
}
function getAirdrop() public {
token.transfer(msg.sender, 100000000000000000000); //18 decimals token
}
pragma solidity ^0.5.9;
contract DAppContract {
enum SDCType {"DC", "AC", "DU"};
enum ConsentStatus {"OptIn", "OptOut"};
mapping (string => uint) statusToEventTimer;
enum ConsentModel {"auto_opt_in", "explicit_opt_in"};
ConsentModel consent_model;
event StatusChanged(string status);
address organizerAddr;
mapping (string => address) public vendorToCreator;
struct Organizer {
SDCType type;
string vendorId;
uint joinedAt; //timestamp
uint exitedAt;
}
struct Creator {
SDCType type;
string vendorId;
uint joinedAt; //timestamp
uint exitedAt;
}
Creator[] public creators;
struct Subcriber {
SDCType type; // 'DU'
string vendorId;
}
struct Investor {
string podId;
uint joinedAt; //timestamp
uint exitedAt;
ConsentStatus status;
}
Investor[] private investors;
struct DataSource {
string type; // lopragma solidity ^0.5.9;
contract DAppContract {
enum SDCType {"DC", "AC", "DU"};
enum ConsentStatus {"OptIn", "OptOut"};
mapping (string => uint) statusToEventTimer;
enum ConsentModel {"auto_opt_in", "explicit_opt_in"};
ConsentModel consent_model;
event StatusChanged(string status);
address organizerAddr;
mapping (string => address) public vendorToCreator;
struct Organizer {
SDCType type;
string vendorId;
uint joinedAt; //timestamp
uint exitedAt;
}
struct Creator {
SDCType type;
string vendorId;
uint joinedAt; //timestamp
uint exitedAt;
}
Creator[] public creators;
struct Subcriber {
SDCType type; // 'DU'
string vendorId;
}
struct Investor {
string podId;
uint joinedAt; //timestamp
uint exitedAt;
ConsentStatus status;
}
Investor[] private investors;
struct DataSource {
string type; // lopragma solidity ^0.4.0;
contract first is Bank {
string private name;
uint private age;
function setName(string newName) {
name = newName;
}
function getName() returns (string) {
return name;
}
function setAge(string newAge) {
age = newAge;
}
function getAge() returns (string) {
return age;
}
}
pragma solidity >=0.4.22 <0.6.0;
contract OwnedToken {
// `TokenCreator` is a contract type that is defined below.
// It is fine to reference it as long as it is not used
// to create a new contract.
TokenCreator creator;
address owner;
bytes32 name;
// This is the constructor which registers the
// creator and the assigned name.
constructor(bytes32 _name) public {
// State variables are accessed via their name
// and not via e.g. `this.owner`. Functions can
// be accessed directly or through `this.f`,
// but the latter provides an external view
// to the function. Especially in the constructor,
// you should not access functions externally,
// because the function does not exist yet.
// See the next section for details.
owner = msg.sender;
// We do an explicit type conversion from `address`
// to `TokenCreator` and assume that the type of
// the calling contract is `TokenCreacontract delegable {
uint public number = 7;
function Store(uint n) public {
number = n;
}
function Return() public view returns (uint) {
return number;
}
}
contract frontend {
uint public number;
address delegate;
constructor(address access) {
delegate = access;
}
function returnDelegableNumber() public view returns (uint) {
return delegable(delegate).Return();
}
function storeNumber() public {
delegate.delegatecall(bytes4(sha3("Store(uint256)")), 123);
}
function returnNumber() public view returns (uint) {
delegate.delegatecall(bytes4(sha3("Return()")));
assembly {
// determine size of return data
let size := returndatasize
// load
let ptr := mload(0x40)
returndatacopy(ptr, 0, size)
return(ptr, size)
}
}
pragma solidity ^0.5.1;
contract MainMarket {
enum Position { Short, Long }
struct AuxiliaryMarket {
address addr;
Position position;
}
AuxiliaryMarket auxiliaryMarket;
constructor() public {
}
}
contract MainMarketInterface {
//Withdraw 5% to holders
function withdraw() external;
//Convert the asset tokens to Zap Tokens
function exchangeZap() private;
//Disperse funds to holders 5% fee based on percentage of stake
function disperseFunds() private;
//Self destruct the contract if it goes bankrupt
function selfDestruct() external;
//Deposits Zap Tokens to MainMarket Contract
function deposit() payable external;
//Get current Zap price
function getZapPrice() external;
pragma solidity ^0.5.1;
contract MainMarket {
enum Position { Short, Long }
struct AuxiliaryMarket {
address addr;
Position position;
}
AuxiliaryMarket auxiliaryMarket;
constructor() public {
}
pragma solidity ^0.4.24;
contract Democratos {
// This declares a new complex type which will
// be used for variables later.
// It will represent a single voter.
struct Voter {
uint weight; // weight is accumulated by delegation
bool voted; // if true, that person already voted
uint vote; // index of the voted proposal
}
// This is a type for a single proposal.
struct Proposal {
bytes32 name; // short name (up to 32 bytes)
uint voteCount; // number of accumulated votes
}
address public chairperson;
// This declares a state variable that
// stores a `Voter` struct for each possible address.
mapping(address => Voter) public voters;
// A dynamically-sized array of `Proposal` structs.
Proposal[] public proposals;
bytes32[] public proposalNames;
address[] public votersAddress;
/// Create a new ballot to choose one of `proposalNames`.
function Demoscratos(bytes32[] pNames) public {
chairperson = msg.sender;
voters[chairperson].weight = 1;
pragma solidity >=0.4.21 <0.6.0;
contract Oracle {
Request[] requests; //list of requests made to the contract
uint currentId = 0; //increasing request id
uint minQuorum = 2; //minimum number of responses to receive before declaring final result
uint totalOracleCount = 3; // Hardcoded oracle count
pragma solidity >=0.4.21 <0.6.0;
contract Oracle {
Request[] requests; //list of requests made to the contract
uint currentId = 0; //increasing request id
uint minQuorum = 2; //minimum number of responses to receive before declaring final result
uint totalOracleCount = 3; // Hardcoded oracle count
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract MakerDaoSandbox {
uint constant WAD = 10 ** 18;
uint constant RAY = 10 ** 27;
function add(uint x, uint y) internal pure returns (uint z) {
require((z = x + y) >= x);
}
function sub(uint x, uint y) internal pure returns (uint z) {
require((z = x - y) <= x);
}
function mul(uint x, uint y) internal pure returns (uint z) {
require(y == 0 || (z = x * y) / y == x);
}
function min(uint x, uint y) internal pure returns (uint z) {
return x <= y ? x : y;
}
function max(uint x, uint y) internal pure returns (uint z) {
return x >= y ? x : y;
}
function imin(int x, int y) internal pure returns (int z) {
return x <= y ? x : y;
}
function imax(int x, int y) internal pure returns (int z) {
return x >= y ? x : y;
}
function wmul(uint x, uint y) internal pure returns (uint z) {
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
uint constant WAD = 10 ** 18;
uint constant RAY = 10 ** 27;
function add(uint x, uint y) internal pure returns (uint z) {
require((z = x + y) >= x);
}
function sub(uint x, uint y) internal pure returns (uint z) {
require((z = x - y) <= x);
}
function mul(uint x, uint y) internal pure returns (uint z) {
require(y == 0 || (z = x * y) / y == x);
}
function min(uint x, uint y) internal pure returns (uint z) {
return x <= y ? x : y;
}
function max(uint x, uint y) internal pure returns (uint z) {
return x >= y ? x : y;
}
function imin(int x, int y) internal pure returns (int z) {
return x <= y ? x : y;
}
function imax(int x, int y) internal pure returns (int z) {
return x >= y ? x : y;
}
function wmul(uint x, uint y) internal pure returns (uint z) {
z = //Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.16;
contract SimpleStore {
function set(uint _value) public {
value = _value;
}
function get() public constant returns (uint) {
return value;
}
uint value;
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.5.9;
contract SimpleStore {
function set(uint _value) public {
value = _value;
}
function get() public constant returns (uint) {
return value;
}
uint value;
pragma solidity >=0.4.0 <0.7.0;
contract SimpleStorage {
uint8 storedData;
function set(uint8 x) public {
storedData = x;
}
function get() public view returns (uint8) {
return storedData;
}
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.25;
contract SceneOuverte {
string[12] passagesArtistes;
uint creneauxLibres = 12;
uint tour;
function sInscrire(string nomDArtiste) public {
if (creneauxLibres > 0) {
passagesArtistes[12-creneauxLibres] = nomDArtiste;
creneauxLibres -= 1;
}
}
function passerArtisteSuivant() public {
if (tour < 12){
tour += 1;
}
}
function artisteEnCours () public constant returns (string) {
if (tour <= 12){
return passagesArtistes[tour];
} else {
return "FIN";
}
}
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.25;
contract SceneOuverte {
string[12] passagesArtistes;
uint creneauxLibres = 12;
uint tour;
function sInscrire(string nomDArtiste) public {
if (creneauxLibres > 0) {
passagesArtistes[12-creneauxLibres] = nomDArtiste;
creneauxLibres -= 1;
}
}
function passerArtisteSuivant() public {
if (tour < 12){
tour += 1;
}
}
function artisteEnCours () public constant returns (string) {
if (tour <= 12){
return passagesArtistes[tour];
} else {
return "FIN";
}
}
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.25;
contract SceneOuverte {
string[12] passagesArtistes;
uint creneauxLibres = 12;
uint tour;
function sInscrire(string nomDArtiste) public {
if (creneauxLibres > 0) {
passagesArtistes[12-creneauxLibres] = nomDArtiste;
creneauxLibres -= 1;
}
}
function passerArtisteSuivant() public {
tour += 1;
}
function artisteEnCours () public constant returns (string) {
return passagesArtistes[tour];
}
//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; //not used
result = keccak256(uint256(81768547281677189180385955625970379636532081546421658959342142865864158412140));
}
function get() public constant returns (uint256) {
return uint256(result);
}
bytes32 result;
uint value;
//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; //not used
result = keccak256(uint256(81768547281677189180385955625970379636532081546421658959342142865864158412140));
}
function get() public constant returns (bytes32) {
return result;
}
bytes32 result;
uint value;
//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;
//bytes32 input = "0123456789012345678901234567890123456789";
result = keccak256(uint256(81768547281677189180385955625970379636532081546421658959342142865864158412140));
}
function get() public constant returns (bytes32) {
return result;
}
bytes32 result;
uint value;
//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;
result = keccak256("0123456789012345678901234567890123456789");
}
function get() public constant returns (bytes32) {
return result;
}
bytes32 result;
uint value;
//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;
import './levels/base/Level.sol';
import 'zeppelin-solidity/contracts/ownership/Ownable.sol';
contract Ethernaut is Ownable {
// ----------------------------------
// Owner interaction
// ----------------------------------
mapping(address => bool) registeredLevels;
// Only registered levels will be allowed to generate and validate level instances.
function registerLevel(Level _level) public onlyOwner {
registeredLevels[_level] = true;
}
// ----------------------------------
// Get/submit level instances
// ----------------------------------
struct EmittedInstanceData {
address player;
Level level;
bool completed;
}
mapping(address => EmittedInstanceData) emittedInstances;
event LevelInstanceCreatedLog(address indexed player, address instance);
event LevelCompletedLog(address indexed player, Level level);
function createLevelInstance(Level _level) public payable {
// Ensure level is registered.
require(registeredLevels[pragma solidity ^0.4.13;
contract DSAuthority {
function canCall(address src, address dst, bytes4 sig) public view returns (bool);
}
contract DSAuthEvents {
event LogSetAuthority (address indexed authority);
event LogSetOwner (address indexed owner);
}
contract DSAuth is DSAuthEvents {
DSAuthority public authority;
address public owner;
function DSAuth() public {
owner = msg.sender;
LogSetOwner(msg.sender);
}
function setOwner(address owner_)
public
auth
{
owner = owner_;
LogSetOwner(owner);
}
function setAuthority(DSAuthority authority_)
public
auth
{
authority = authority_;
LogSetAuthority(authority);
}
modifier auth {
require(isAuthorized(msg.sender, msg.sig));
_;
}
function isAuthorized(address src, bytes4 sig) internal view returns (bool) {
if (src == address(this)) {
return true;
} else if (src == opragma solidity ^0.4.13;
contract DSAuthority {
function canCall(
address src, address dst, bytes4 sig
) public view returns (bool);
}
contract DSAuthEvents {
event LogSetAuthority (address indexed authority);
event LogSetOwner (address indexed owner);
}
contract DSAuth is DSAuthEvents {
DSAuthority public authority;
address public owner;
function DSAuth() public {
owner = msg.sender;
LogSetOwner(msg.sender);
}
function setOwner(address owner_)
public
auth
{
owner = owner_;
LogSetOwner(owner);
}
function setAuthority(DSAuthority authority_)
public
auth
{
authority = authority_;
LogSetAuthority(authority);
}
modifier auth {
require(isAuthorized(msg.sender, msg.sig));
_;
}
function isAuthorized(address src, bytes4 sig) internal view returns (bool) {
if (src == address(this)) {
return true;
} els
pragma solidity ^0.4.24;
import "./AddressUtils.sol";
import "./Ownable.sol";
contract Registry is Ownable {
event RegistryCreated(address addressOfRegistryContract,address from );
mapping (address => address) public addresses;
mapping (address => bool) public userPreferences;
address[] public validImplementations;
constructor() public {
emit RegistryCreated(address(this),msg.sender);
}
function setImplementationAddress(address newAddress) public {
require(newAddress != 0, "cant set value to 0");
require(checkValidImplementationAddress(newAddress), "not a valid implementation address");
addresses[msg.sender] = newAddress;
}
function checkValidImplementationAddress(address addr) internal view returns (bool) {
for(uint i = 0; i < validImplementations.length; ++i) {
if (addr == validImplementations[i]) return true;
}
return false;
}
function addImplementation(address toAdd) external only➜ ~ ssh [email protected] -p 2220
[email protected]:~$ ls
readme
[email protected]:~$ cat readme
boJ9jbbUNNfktd78OOpsqOltutMc3MY1
[email protected]:~pragma solidity ^0.4.21;
contract GPMCoin {
// Public variables of the token
// Start pre ICO 28.05.19
// price $0,15
// Start ICO 16.07.19
// price $0,3
address public owner;
string public name = "GPMCoin";
string public symbol = "GPM";
uint8 public decimals = 18;
bool public frozen;
uint256 public totalSupply = 18000000 * 10 ** uint256(decimals);
// 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);
/**
* Constrctor function
*
* Initializes contract with initial supply tokens to the creator of the contract
*/
function GPMCoin() public {
balanceOf[msg.sender] = totalSupply; // Give the creator all initial tokens
owner = msg.sende//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.20;
contract SimpleStore {
function getWinNumbers(string bitcoinBlockHash, uint _numbersCount, uint _numbersCountMax) public pure returns (bytes){
bytes32 random = keccak256(bitcoinBlockHash);
bytes memory allNumbers = new bytes(_numbersCountMax);
bytes memory winNumbers = new bytes(_numbersCount);
for (uint i = 0; i < _numbersCountMax; i++) {
allNumbers[i] = byte(i + 1);
}
for (i = 0; i < _numbersCount; i++) {
uint n = _numbersCountMax - i;
uint r = (uint(random[i * 4]) + (uint(random[i * 4 + 1]) << 8) + (uint(random[i * 4 + 2]) << 16) + (uint(random[i * 4 + 3]) << 24)) % n;
winNumbers[i] = allNumbers[r];
allNumbers[r] = allNumbers[n - 1];
}
return winNumbers;
}
uint value;
// mapping struct to eth-address
pragma solidity ^0.4.18;
contract SimpleStore {
uint[] private a_age;
string[] private a_name;
string[] private a_role;
struct User {
uint age;
string name;
string role;
}
mapping (address => User) userz;
address[] private userlist;
function setUser(address _address, uint _age, string _name, string _role) public {
var user = userz[_address];
user.age = _age;
user.name = _name;
user.role = _role;
userlist.push(_address);
a_age.push(_age);
a_name.push(_name);
a_role.push(_role);
}
function getUserlist() view public returns(address[]) {
return userlist;
}
function get_user_info(uint _n) public view returns(address _address_, uint _age_, string _name_, string _role_) {
_address_ = userlist[_n];
_age_ = a_age[_n];
_name_ = a_name[_n];
_role_ = a_role[_n];
}
function get_info_by_address(address _add_) public view returns(address __address, uint __age, string __name, string __rpragma solidity ^0.4.19;
// Our first contract is a faucet!
contract Faucet {
// Give out ether to anyone who asks
function withdraw(uint withdraw_amount) public {
// Limit withdrawal amount
require(withdraw_amount <= 100000000000000000);
// Send the amount to the address that requested it
msg.sender.transfer(withdraw_amount);
}
// Accept any incoming amount
function () public payable {}
//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.26;
contract Thesis
{
struct HealthRecord {
string ipfsHash;
string prevIpfsHash;
uint timestamp;
}
HealthRecord[] healthrecords;
function exists(string hash) public view returns (bool, bool) {
bool hash1exists = false;
bool hash2exists = false;
for (uint i = 0; i < healthrecords.length - 1; i++) {
string storage a = healthrecords[i].ipfsHash;
string storage b = healthrecords[i].prevIpfsHash;
if (keccak256(abi.encodePacked(a)) == keccak256(abi.encodePacked(hash))) {
hash1exists = true;
}
if (keccak256(abi.encodePacked(b)) == keccak256(abi.encodePacked(hash))) {
hash2exists = true;
}
}
return (hash1exists, hash2exists);
}
function addHealthRecord(string ipfsHash, string prevIpfsHash) public {
bool a;
bool b;
bool c;
bool d;
//require that ipfsHash doesn't exist in the blockchain
(a, b)pragma solidity ^0.4.26;
contract Thesis
{
struct HealthRecord {
string ipfsHash;
string prevIpfsHash;
uint timestamp;
}
HealthRecord[] healthrecords;
function exists(string hash) public view returns (bool, bool) {
bool hash1exists = false;
bool hash2exists = false;
for (uint i = 0; i < healthrecords.length - 1; i++) {
string storage a = healthrecords[i].ipfsHash;
string storage b = healthrecords[i].prevIpfsHash;
if (keccak256(abi.encodePacked(a)) == keccak256(abi.encodePacked(hash))) {
hash1exists = true;
}
if (keccak256(abi.encodePacked(b)) == keccak256(abi.encodePacked(hash))) {
hash2exists = true;
}
}
return (hash1exists, hash2exists);
}
function addHealthRecord(string ipfsHash, string prevIpfsHash) public {
bool a;
bool b;
bool c;
bool d;
(a, b) = exists(ipfsHash);
()
healthrecords.push(HealthRecord(ipfsHashpragma solidity ^0.4.26;
contract Thesis
{
struct HealthRecord {
string ipfsHash;
string prevIpfsHash;
uint timestamp;
}
HealthRecord[] healthrecords;
function exists(string hash) public view {
}
function addHealthRecord(string hash, string prevIpfsHash) public {
healthrecords.push(HealthRecord(hash, prevIpfsHash, now));
}
function getHealthRecords(uint[] indexes)
public
returns (string[], string[], uint[])
{
string[] memory hashes = new string[](indexes.length);
string[] memory prev_hashes = new string[](indexes.length);
uint[] memory timestamps = new uint[](indexes.length);
for (uint i = 0; i < indexes.length; i++) {
HealthRecord storage healthrecord = healthrecords[indexes[i]];
hashes[i] = healthrecord.ipfsHash;
prev_hashes[i] = healthrecord.prevIpfsHash;
timestamps[i] = healthrecord.timestamp;
}
bytes32 private hint; // '0x722074742045753F42742C6575' => "r tt Eu?BT,eu" => "Et tu, Brute?"
bytes private step; // first one
bytes32 private tip; // '0x5368616B65737065617265' => "Shakespeare"
bytes32 private ethcon; // '0x5269676874' => "Right" ascii
uint[] private plain; // "HACK" -> "8, 0, 2, 11pragma solidity ^0.5.0;
contract Hint {
bool public assigned;
bool public set;
bytes32 private hint;
bytes private step; // first one
bytes32 private tip;
bytes32 private ethcon;
uint[] private plain;
HintReward public rewardPool;
constructor(bytes32 _hint, bytes32 _tip, bytes32 _ethcon, uint[] memory _plain, address _rewardPool) public {
set = true;
hint = _hint;
tip = _tip;
ethcon = _ethcon;
plain = _plain;
rewardPool = HintReward(_rewardPool);
}
function assign(bytes32 _hint, bytes memory _step) public returns(bool) {
require(!assigned);
require(_hint == hint);
set = true;
assigned = true;
step = _step;
return true;
}
function claim(uint[] memory _answer) public {
(bool success, bytes memory returnedData) = address(rewardPool).call(abi.encodeWithSelector(rewardPool.check.selector, _answer, plain, step));
require(returnedData.length >= 0);
require(success);
}
function help() public payable {
require(msg.value//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract Company {
address supporter;
address owner;
uint goal;
uint deadline;
mapping (address => uint256) public pledge;
constructor ( uint256 numDays, uint256 _goal) public {
owner = msg.sender;
deadline = now + (numDays * 1 hours);
goal= _goal;
}
function Pledge (uint256 amount) public payable {
require(now < deadline);
require(msg.value == amount);
pledge[msg.sender] += amount;
}
function claimFunds() public {
require(address(this).balance >= goal);
require(now >= deadline);
require(msg.sender == owner);
msg.sender.transfer(address(this).balance);
}
function Fail() public {
require(address(this).balance < goal);
require(now >= deadline);
uint256 amount = pledge[msg.sender];
pledge[msg.sender] = 0;
msg.sender.transfer(amount);
}
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract Compagn {
address public support;
uint256 public deposit = 3000;
constructor() public payable {
support = msg.sender;
deposit = msg.value;
}
function benificiar () public payable returns (bool) {
if (msg.value < deposit) {
support.transfer(msg.value);
support = msg.sender;
deposit = msg.value;
return true;
} else {
return false;
}
}
pragma solidity ^0.5.9;
contract BlockchainTraining {
address public organiser;
mapping(bytes32 => bool) private participants;
constructor() public {
organiser = msg.sender;
}
function addParticipant(string memory name) public {
require(bytes(name).length > 0);
require(msg.sender == organiser);
participants[sha256(abi.encodePacked(name))] = true;
}
function verify(string memory name) public view returns (bool) {
require(bytes(name).length > 0);
return (participants[sha256(abi.encodePacked(name))]);
}
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract String {
string store = "acderere";
address public owner;
event LogMessage (string msg, string value);
function getStore () public view returns (string) {
return store;
}
function setStore (string _value) public {
store =_value;
owner=msg.sender;
}
//Write your own contrasdfsdfdsfsdfcts 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;
//Write your own contrasdfsdfdsfsdfcts 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.24;
contract Applicationa {
function Application() public {}
enum Assets {
MotherBoard, Component, ThirdPartyContractor, SensorManufacturer, TAFB, SPO_SCMW, Distributor, MotherBoardManufacturer, OEM, Sensor, Assembler
}
Assets _MotherBoardQAInput = Assets.MotherBoard;
Assets _ComponentQAOutput = Assets.Component;
Assets _InstallationQAInput = Assets.ThirdPartyContractor;
Assets _Sensor = Assets.SensorManufacturer;
Assets _InstallationQAOutput = Assets.ThirdPartyContractor;
Assets _AssembleComponent = Assets.Component;
Assets _ComponentQAInput = Assets.Component;
Assets _RegisterTAFB = Assets.TAFB;
Assets _TAFB = Assets.SPO_SCMW;
Assets _RegisterDistributor = Assets.Distributor;
Assets _ThirdPartyContractor = Assets.TAFB;
Assets _Component = Assets.Distributor;
Assets _MotherBoardQAOutput = Assets.MotherBoard;
Assets _RegisterMotherBoard = Assets.MotherBoardManufacturer;
Assets _RegisterOEM = Assets.OEM;
Apragma solidity ^0.4.24;
contract Applicationa {
function Application() public {}
enum Assets {
MotherBoard, Component, ThirdPartyContractor, SensorManufacturer, TAFB, SPO_SCMW, Distributor, MotherBoardManufacturer, OEM, Sensor, Assembler
}
Assets _MotherBoardQAInput = Assets.MotherBoard;
Assets _ComponentQAOutput = Assets.Component;
Assets _InstallationQAInput = Assets.ThirdPartyContractor;
Assets _Sensor = Assets.SensorManufacturer;
Assets _InstallationQAOutput = Assets.ThirdPartyContractor;
Assets _AssembleComponent = Assets.Component;
Assets _ComponentQAInput = Assets.Component;
Assets _RegisterTAFB = Assets.TAFB;
Assets _TAFB = Assets.SPO_SCMW;
Assets _RegisterDistributor = Assets.Distributor;
Assets _ThirdPartyContractor = Assets.TAFB;
Assets _Component = Assets.Distributor;
Assets _MotherBoardQAOutput = Assets.MotherBoard;
Assets _RegisterMotherBoard = Assets.MotherBoardManufacturer;
Assets _RegisterOEM = Assets.OEM;
Apragma solidity ^0.4.24;
contract Application {
function Application() public {}
enum Assets {
MotherBoard, Component, ThirdPartyContractor, SensorManufacturer, TAFB, SPO_SCMW, Distributor, MotherBoardManufacturer, OEM, Sensor, Assembler
}
Assets _MotherBoardQAInput = Assets.MotherBoard;
Assets _ComponentQAOutput = Assets.Component;
Assets _InstallationQAInput = Assets.ThirdPartyContractor;
Assets _Sensor = Assets.SensorManufacturer;
Assets _InstallationQAOutput = Assets.ThirdPartyContractor;
Assets _AssembleComponent = Assets.Component;
Assets _ComponentQAInput = Assets.Component;
Assets _RegisterTAFB = Assets.TAFB;
Assets _TAFB = Assets.SPO_SCMW;
Assets _RegisterDistributor = Assets.Distributor;
Assets _ThirdPartyContractor = Assets.TAFB;
Assets _Component = Assets.Distributor;
Assets _MotherBoardQAOutput = Assets.MotherBoard;
Assets _RegisterMotherBoard = Assets.MotherBoardManufacturer;
Assets _RegisterOEM = Assets.OEM;
Aspragma solidity ^0.4.24;
contract Application {
function Application() public {}
enum Assets {
MotherBoard, Component, ThirdPartyContractor, SensorManufacturer, TAFB, SPO_SCMW, Distributor, MotherBoardManufacturer, OEM, Sensor, Assembler
}
Assets _MotherBoardQAInput = Assets.MotherBoard;
Assets _ComponentQAOutput = Assets.Component;
Assets _InstallationQAInput = Assets.ThirdPartyContractor;
Assets _Sensor = Assets.SensorManufacturer;
Assets _InstallationQAOutput = Assets.ThirdPartyContractor;
Assets _AssembleComponent = Assets.Component;
Assets _ComponentQAInput = Assets.Component;
Assets _RegisterTAFB = Assets.TAFB;
Assets _TAFB = Assets.SPO_SCMW;
Assets _RegisterDistributor = Assets.Distributor;
Assets _ThirdPartyContractor = Assets.TAFB;
Assets _Component = Assets.Distributor;
Assets _MotherBoardQAOutput = Assets.MotherBoard;
Assets _RegisterMotherBoard = Assets.MotherBoardManufacturer;
Assets _RegisterOEM = Assets.OEM;
As//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.5.0;
import "./oraclizeAPI_0.5.sol";
import "./Strings.sol";
contract BettingContract is usingOraclize
{
using Strings for string;
address[] public players;
string[] public TemperatureGuess;
uint totalReceived;
uint playerCount = 0;
struct Player {
address addr; //The address of their account
uint betAmount; //The amount they're betting
string guess; //What they've made as prediction
}
Player[] players;
//When called for, Oraclize needs to be called and the Total needs to be updated.
constructor(uint bet) public
{
OAR = OraclizeAddrResolverI(0x6f485C8BF6fc43eA212E93BBF8ce046C7f1cb475);
updateTotalReceived(bet);
}
//The Total needs to be counted, so that it can be sent (in total) to the winner(s)
function updateTotalReceived(uint bet) internal
{
totalReceived = totalReceived + bet;
AddPlayer(/*info*/);
}
function AddPlayer(address player, string memory guess ) in//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;
// File: contracts/ERC721/ERC721Basic.sol
pragma solidity ^0.4.18;
/**
* @title ERC721 Non-Fungible Token Standard basic interface
* @dev see https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md
*/
contract ERC721Basic {
event Transfer(address indexed _from, address indexed _to, uint256 _tokenId);
event Approval(address indexed _owner, address indexed _approved, uint256 _tokenId);
event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved);
function balanceOf(address _owner) public view returns (uint256 _balance);
function ownerOf(uint256 _tokenId) public view returns (address _owner);
function exists(uint256 _tokenId) public view returns (bool _exists);
function approve(address _to, uint256 _tokenId) public;
function getApproved(uint256 _tokenId) public view returns (address _operator);
function setApprovalForAll(address _operator, bool _approved) public;
function isApprovedForAll(address _owner, address _operator) public view returns (bool);
pragma solidity ^0.4.21;
contract SimpleStore {
struct Item {
uint price;
uint units;
}
Item[] public items;
function newItem(uint _price, uint _units)
public
{
Item memory item = Item(_price, _units);
items.push(item);
}
function getUsingStorage(uint _itemIdx)
public
// set to non-view to estimate gas
// view
returns (uint)
{
Item storage item = items[_itemIdx];
return item.units;
}
function getUsingMemory(uint _itemIdx)
public
// set to non-view to estimate gas
// view
returns (uint)
{
Item memory item = items[_itemIdx];
return item.units;
}
function addItemUsingStorage(uint _itemIdx, uint _units)
public
{
Item storage item = items[_itemIdx];
item.units += _units;
}
function addItemUsingMemory(uint _itemIdx, uint _units)
public
// set to non-view to estimate gas
// view
{
Item memory item = items[_itemIdx];
item.units += _units;
}
pragma solidity >=0.4.25 <0.6.0;
contract CupomBrinde {
enum StateType {AdicionarCupom, CupomCriado,CupomUtilizado}
StateType public State;
address public Owner;
string public Visitante;
uint public Qtde;
uint public Retirado;
constructor(string memory visitante, uint qtde,uint retirado) public
{
Owner = msg.sender;
Visitante = visitante;
Qtde = qtde;
Retirado = retirado;
State = StateType.AdicionarCupom;
}
function CriarCupom(uint qtde) public
{
Qtde = qtde;
State = StateType.CupomCriado;
}
function UtilizarCupom(uint retirado) public
{
Retirado = retirado;
State = StateType.CupomUtilizado;
}
}pragma solidity ^0.4.24;
contract BlockHash {
event Logging(bytes32);
event Logging(uint);
function getBlockHash(uint _blockNumber) public view returns (uint blockNumber_, bytes32 blockhash_, uint blockhashToNumber_){
if (_blockNumber == 0){
_blockNumber = block.number-1;
}
bytes32 _blockhash = block.blockhash(_blockNumber);
uint _blockhashToNumber = uint(_blockhash);
emit Logging(_blockNumber);
emit Logging(_blockhash);
return (_blockNumber, _blockhash, _blockhashToNumber);
}
}//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;
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.5.8;
contract SimpleStore {
function set(uint _value) public {
value = _value;
}
function get() public constant returns (uint) {
return value;
}
uint value;
function facebookShare(event) {
event.preventDefault();
var title = encodeURIComponent(document.getElementsByTagName("title")[0].innerHTML);
var url = encodeURIComponent(window.location.href);
window.open('http://www.facebook.com/sharer.php?u=' + url, 'sharer', 'toolbar=1,status=1');
1
function facebookShare(event) {
event.preventDefault();
var title = encodeURIComponent(document.getElementsByTagName("title")[0].innerHTML);
var url = encodeURIComponent(window.location.href);
window.open('http://www.facebook.com/sharer.php?u=' + url, 'sharer', 'toolbar=1,status=1');
function facebookShare(event) {
event.preventDefault();
var title = encodeURIComponent(document.getElementsByTagName("title")[0].innerHTML);
var url = encodeURIComponent(window.location.href);
window.open('http://www.facebook.com/sharer.php?u=' + url, 'sharer', 'toolbar=1,status=1');
pragma solidity ^0.5.0;
contract RandomNumberOracle{
// @notice This function can be used to generate a random number based on the specific future blockhash
// @dev The miner of the defined block number has the possiblity to withhold a mined block in order to manipulate the randomness.
// @param min The lower boundary of the random range (min is part of the range)
// @param max The upper boundary of the random range (max is part of the range)
// @param blockNumber The block number which is used to create the random numbers
// @return A random integer greater or equal to min and smaller or equal to max
function getRandomNumber(uint256 min, uint256 max, uint256 blockNumber) public view returns(uint256){
require(block.number > blockNumber);
return (uint256(blockhash(blockNumber)) % (max - min + 1)) + min;
}
["American",
"adventurous",
"alcoholic",
"award-winning",
"balanced",
"best",
"big",
"bitter",
"bold",
"bottle-conditioned",
"bottled",
"brewed",
"brewery-fresh",
"bright",
"canned",
"cask-conditioned",
"chilled",
"choice",
"classic",
"clean",
"cold",
"complex",
"crackling",
"craft",
"craft-brewed",
"creamy",
"crisp",
"dark",
"deep",
"home-brewed",
"hoppy",
"ice-cold",
"indulgent",
"innovative",
"intense",
"interesting",
"intoxicating",
"killer",
"layered",
"light",
"limited",
"lively",
"lush",
"macro-brewed",
"maltier",
"malty",
"medium-bodied",
"mellow",
"micro-brewed",
"natural",
"naturally",
"neverending",
"non-alcoholic",
"organic",
"organically produced",
"original",
"pale",
"perfectly balanced",
"delicate",
"delicious",
"dense",
"distinctive",
"drinkable",
"drunk",
"dry",
"dry-hopped",
"elastic",
"elegant",
"exceptional",
"exotic",
"family-owned",
"famous",
"favorite",
"fermented",
"fizzy",
"flavorful",
"flawless",
"floral",
"foamy",
"fragrant",
"fresh",
"freshly brewed",
"frothy",
"full",
"full-bodiedAmerican
adventurous
alcoholic
award-winning
balanced
best
big
bitter
bold
bottle-conditioned
bottled
brewed
brewery-fresh
bright
canned
cask-conditioned
chilled
choice
classic
clean
cold
complex
crackling
craft
craft-brewed
creamy
crisp
dark
deep
home-brewed
hoppy
ice-cold
indulgent
innovative
intense
interesting
intoxicating
killer
layered
light
limited
lively
lush
macro-brewed
maltier
malty
medium-bodied
mellow
micro-brewed
natural
naturally
neverending
non-alcoholic
organic
organically produced
original
pale
perfectly balanced
delicate
delicious
dense
distinctive
drinkable
drunk
dry
dry-hopped
elastic
elegant
exceptional
exotic
family-owned
famous
favorite
fermented
fizzy
flavorful
flawless
floral
foamy
fragrant
fresh
freshly brewed
frothy
full
full-bodied
full-flavored
handcrafted
pioneering
premium
pronounced
proprietary
quintessential
refreshing
rich
richly hopped
robust
sharp
signature
skunk-proof
smoky
smooth
stout
strong
sturdy
superior
the original
thick
thirst-quenching
traditional
unfiltered
unfopragma solidity ^0.4.18;
// written for Solidity version 0.4.18 and above that doesnt break functionality
contract Voting {
// an event that is called whenever a Candidate is added so the frontend could
// appropriately display the candidate with the right element id (it is used
// to vote for the candidate, since it is one of arguments for the function "vote")
event AddedCandidate(uint candidateID);
// describes a Voter, which has an id and the ID of the candidate they voted for
struct Voter {
bytes32 uid; // bytes32 type are basically strings
uint candidateIDVote;
}
// describes a Candidate
struct Candidate {
bytes32 name;
bytes32 party;
// "bool doesExist" is to check if this Struct exists
// This is so we can keep track of the candidates
bool doesExist;
}
// These state variables are used keep track of the number of Candidates/Voters
// and used to as a way to index them
uint numCandidatpragma solidity ^0.4.24;
contract Votacion {
modifier onlyOwner() {
require(isOwner(msg.sender));
_;
}
uint public voteStartTime;
uint public voteEndTime;
uint16 private voterCount;
string public votingTitle;
address public owner;
uint16 public accountedVotes;
uint16 public nulledVotes;
uint16 public votesRemaining;
event Voted (bytes24 _token);
event newVoterId (uint _voterId);
event voteAccounted (bytes32 _candidateName, uint _votesReceived, uint16 _totalVotesAccounted);
event voteNulled (uint16 _voterId, uint16 _totalVotesAccounted);
mapping (bytes32 => uint16) private votesReceived;
mapping (bytes32 => bool) public votesCasted;
mapping (uint8 => string) public candidateNames1;
mapping (uint8 => string) public candidateNames2;
mapping (uint16 => string) public voterIndex;
mapping (string => bool) internal voterIds;
bytes32[] private candidateList1;
bytes32[] private candidateList2;
pragma solidity ^0.4.24;
contract Votacion {
modifier onlyOwner() {
require(isOwner(msg.sender));
_;
}
uint public voteStartTime;
uint public voteEndTime;
uint16 private voterCount;
string public votingTitle;
address public owner;
uint16 public accountedVotes;
uint16 public nulledVotes;
uint16 public votesRemaining;
event Voted (bytes24 _token);
event newVoterId (uint _voterId);
event voteAccounted (bytes32 _candidateName, uint _votesReceived, uint16 _totalVotesAccounted);
event voteNulled (uint16 _voterId, uint16 _totalVotesAccounted);
mapping (bytes32 => uint16) private votesReceived;
mapping (bytes32 => bool) public votesCasted;
mapping (uint8 => string) public candidateNames1;
mapping (uint8 => string) public candidateNames2;
mapping (uint16 => string) public voterIndex;
mapping (string => bool) internal voterIds;
bytes32[] private candidateList1;
bytes32[] private candidateList2;
pragma solidity >=0.5.0 <0.7.0;
import "https://github.com/OpenZeppelin/openzeppelin-solidity/contracts/token/ERC20/ERC20.sol";
import "https://github.com/OpenZeppelin/openzeppelin-solidity/contracts/token/ERC20/ERC20Detailed.sol";
contract TokenGenerator is ERC20, ERC20Detailed {
address account = msg.sender;
constructor(
string memory _name, string memory _symbol, uint8 _decimals, uint256 _value
) ERC20Detailed(
_name, _symbol, _decimals
) public {
_mint(account, _value);
}
//Oscar Ibarhuen-Guereca
pragma solidity >=0.4.22 <0.6.0;
contract Duties {
//The address is the variable that acts as the parties involved in the contract, in this case, the roomates on the agreement.
address payable [] roommates;
//The following are the units that are used throughout the contract, including the timer, stake, if the task was done within five or seven days and if the task has been completed.
uint totalRoommates;
uint timeLapse = now - checkTime;
uint taskId;
uint sTime;
uint checkTime;
uint constant stake = 100;
uint constant fiveDays = 5;
uint constant sevenDays = 7;
mapping (uint => bool) taskComplete;
//The following booleans will detect if the following variables apply or not.
bool isPayable_ = false;
bool isLessFiveDay_ = false;
bool isAssignedCompleted_ = false;
bool isGreaterFiveDay_ = false;
//The events are situations that can happen throughout the time this smart contract is active.//Oscar Ibarhuen-Guereca
pragma solidity >=0.4.22 <0.6.0;
contract Duties {
//The address is the variable that acts as the parties involved in the contract, in this case, the roomates on the agreement.
address payable[] roommates;
//The following are the units that are used throughout the contract, including the timer, stake, if the task was done within five or seven days and if the task has been completed.
uint totalRoommates;
uint timeLapse = now - checkTime;
uint taskId;
uint sTime;
uint checkTime;
uint constant stake = 100;
uint constant fiveDays = 5;
uint constant sevenDays = 7;
mapping (uint => bool) taskComplete;
//The following booleans will detect if the following variables apply or not.
bool isPayable_ = false;
bool isLessFiveDay_ = false;
bool isAssignedCompleted_ = false;
bool isGreaterFiveDay_ = false;
//The events are situations that can happen throughout the time this smart contract is active. //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;
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract BonusScheme {
address public buyer /* The employee is the buyer */
address public owner /* The company is the owner */
struct Employee {
address emp_addr
string emp_id
string emp_name
}
struct Partner {
address parner_addr
string partner_id
string partner_name
}
struct Order {
address employee
address partner
address item
unit quantity
unit price
unit date
}
struct Invoice {
unit orderno;
}
/// A mapping to store orders
mapping (unit => Order) orders;
/// A mapping to store invoices
mapping (unit => Invoice) invoices;
/// A mapping to store partners
mapping (unit => Partner) partners;
/// Event triggered for every new employee account set up on the bonus scheme
event SetUpEmployeeAccount(address employee, string name)
/// Event triggered for every new order
event OrderPlaced(address employee, string item, uint quantity, uint orde//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract BonusScheme {
address public buyer /* The employee is the buyer */
address public owner /* The company is the owner */
struct Employee {
address emp_addr
string emp_id
string emp_name
}
Struct Partner {
address parner_addr
string partner_id
string partner_name
}
struct Order {
address employee
address partner
address item
uint quantity
uint price
uint date
}
struct Invoice {
uint orderno;
}
/// A mapping to store orders
mapping (uint => Order) orders;
/// A mapping to store invoices
mapping (uint => Invoice) invoices;
/// A mapping to store partners
mapping (uint => Partner) partners;
/// Event triggered for every new employee account set up on the bonus scheme
event SetUpEmployeeAccount(address employee, string name)
/// Event triggered for every new order
event OrderPlaced(address employee, string item, uint quantity, uint orderno);
/// Event triggered when the//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract BonusScheme {
address public buyer /* The employee is the buyer */
address public owner /* The company is the owner */
struct Employee {
address emp_addr
string emp_id
string emp_name
}
struct Partner {
address parner_addr
string partner_id
string partner_name
}
struct Order {
address employee
address partner
address item
unit quantity
unit price
unit date
}
struct Invoice {
unit orderno;
}
/// A mapping to store orders
mapping (unit => Order) orders;
/// A mapping to store invoices
mapping (unit => Invoice) invoices;
/// A mapping to store partners
mapping (unit => Partner) partners;
/// Event triggered for every new employee account set up on the bonus scheme
event SetUpEmployeeAccount(address employee, string name)
/// Event triggered for every new order
event OrderPlaced(address employee, string item, uint quantity, uint orde//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract BonusScheme {
address public buyer /* The employee is the buyer */
address public owner /* The company is the owner */
struct Employee {
address emp_addr
string emp_id
string emp_name
}
Struct Partner {
address parner_addr
string partner_id
string partner_name
}
struct Order {
address employee
address partner
address item
unit quantity
unit price
unit date
}
struct Invoice {
unit orderno;
}
/// A mapping to store orders
mapping (unit => Order) orders;
/// A mapping to store invoices
mapping (unit => Invoice) invoices;
/// A mapping to store partners
mapping (unit => Partner) partners;
/// Event triggered for every new employee account set up on the bonus scheme
event SetUpEmployeeAccount(address employee, string name)
/// Event triggered for every new order
event OrderPlaced(address employee, string item, uint quantity, uint orderno);
/// Event triggered when the company senpragma solidity ^0.5.7;
interface ERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function transfer (address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function transferFrom(address from, address to, uint256 value) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
pragma solidity ^0.4.21;
contract IterateContract {
bytes32[] keys;
mapping(bytes32 => bytes32) mapKeyToValue;
function map(bytes32 _key, bytes32 _value) private {
keys.push(_key);
mapKeyToValue[_key] = _value;
}
// function iterate() view external returns(bytes32[]){
// bytes32[] memory iteration = new bytes32[](keys.length);
// for (uint i = 0; i < keys.length; i++) {
// iteration.push(keys[i]);
// }
// }
pragma solidity ^0.4.25;
contract ElegantRoi {
address public dev = msg.sender;
mapping (address => uint) public time;
mapping (address => uint) public amount;
function play(address _ref) external payable {
uint payout = amount[msg.sender] / 4 * (now - time[msg.sender]) / 86400;
_ref != address(0) ? _ref.send(msg.value / 10) : dev.send(msg.value / 10);
payout > address(this).balance ? msg.sender.send(address(this).balance) : msg.sender.send(payout);
time[msg.sender] = now;
amount[msg.sender] += (msg.value / 10) * 9;
}
pragma solidity ^0.4.25;
contract ElegantRoi {
address public dev = msg.sender;
mapping (address => uint) public time;
mapping (address => uint) public amount;
function play(address _ref) external payable {
uint payout = amount[msg.sender] / 4 * (now - time[msg.sender]) / 86400;
_ref != address(0) ? _ref.transfer(msg.value / 10) : dev.transfer(msg.value / 10);
payout > address(this).balance ? msg.sender.transfer(address(this).balance) : msg.sender.transfer(payout);
time[msg.sender] = now;
amount[msg.sender] += (msg.value / 10) * 9;
}
pragma solidity ^0.4.24;
// ----------------------------------------------------------------------------
// 'TruBoo' token contract
//
// Deployed to : 0x9aa9c88028281225E99c2A080604EbE2C3e5cA4A
// Symbol : TBC
// Name : TruBoo Coin
// 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 safeSub(uint a, uint b) public pure returns (uint c) {
require(b <= a);
c = a - b;
}
function safeMul(uint a, uint b) public pure returns (uint c) {
c = a * b;
require(a == 0 || //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;
}
function getWinNumbers(string bitcoinBlockHash, uint _numbersCount, uint _numbersCountMax) public pure returns (bytes){
bytes32 random = keccak256(bitcoinBlockHash);
bytes memory allNumbers = new bytes(_numbersCountMax);
bytes memory winNumbers = new bytes(_numbersCount);
for (uint i = 0; i < _numbersCountMax; i++) {
allNumbers[i] = byte(i + 1);
}
for (i = 0; i < _numbersCount; i++) {
uint n = _numbersCountMax - i;
uint r = (uint(random[i * 4]) + (uint(random[i * 4 + 1]) << 8) + (uint(random[i * 4 + 2]) << 16) + (uint(random[i * 4 + 3]) << 24)) % n;
winNumbers[i] = allNumbers[r];
allNumbers[r] = allNumbers[n - 1];
}
// CryptoKitties Source code
// Copied from: https://etherscan.io/address/0x06012c8cf97bead5deae237070f9587f8e7a266d#code
pragma solidity ^0.5.0;
/**
* @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 transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) onlyOwner {
if (newOwner != address(0)) {
owner = newOwner;
}
}
}
/// @title Interface for contractspragma solidity 0.4.25;
contract OrderManager {
struct Order {
uint256 foo;
bool isOpen;
}
Order[] public orders;
mapping (address => uint256[]) usersToOrders;
function createOrder(uint256 foo) public {
uint256 orderId = orders.push(
Order({
foo: foo,
isOpen: true
})
) - 1;
usersToOrders[msg.sender].push(orderId);
}
function getOrder(uint256 orderId) public view returns (
uint256 foo,
bool isOpen
) {
return (
orders[orderId].foo,
orders[orderId].isOpen
);
}
function updateOrder(uint256 orderId, bool newStatus) public {
orders[orderId].isOpen = newStatus;
}
//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.22 <0.6.0;
contract marblesContract {
address public contractOwner;
//Marble attributes
struct Marble {
string marbleName;
uint uuid;
uint marblePrice;
string marbleColor;
string description;
uint indexInArray;
bool initialized;
}
modifier onlyOwner(){
require(msg.sender == contractOwner);
_;
}
//mapping array to map the marbles
mapping(uint => Marble) private idToMarbleMap;
//mapping to check the ownership
mapping(address => mapping(uint => bool)) private addressToIdToIsOwnedMap;
//mapping array to save the marbles
mapping(address => Marble[]) private marblesOfAddress;
//Create events to confirm the transaction
event MarbleCreate(address account, uint uuid);
//Reject events to tract rejected transaction
event RejectCreate(address account, uint uuid, string message);
//To track ownership of the marbles
event MarbleTransfer(address from, address to, uint uuid);
event RejectTransfer(address from, address to, uint upragma solidity >=0.4.0 <0.7.0;
contract SimpleStorage {
uint storedData;
function set(uint x) public {
storedData = x;
}
function get() public view returns (uint) {
return storedData;
}
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.5.6;
contract SimpleStore {
function set(uint _value) public {
value = _value;
}
function get() public constant returns (uint) {
return value;
}
uint value;
pragma solidity ^0.4.25;
contract OnlineStore {
uint public i;
function buySomething() external payable {
require(msg.value == 0.001 ether);
i++;
}
//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.25;
contract contratoDeVentas {
address public propietario;
uint256 public fechaDeActualizacion;
string public descripcion;
uint public precio;
bool public aLaVenta = true;
string public estadoActual;
event eventoEstadoActual(string _msg, address user, uint amount, uint256 time);
constructor (string memory _descripcion, uint _precio) public payable {
propietario = msg.sender;
fechaDeActualizacion = block.timestamp;
descripcion = _descripcion;
precio = _precio;
emit eventoEstadoActual('Artículo a la venta:', msg.sender, msg.value, block.timestamp);
estadoActual = 'Artículo a la venta.';
}
function comprar() public payable {
if(msg.value >= precio && aLaVenta == true) {
propietario.transfer(address(this).balance);
propietario = msg.sender;
aLaVenta = false;
emit eventoEstadoActual('Artículo comprado y retirado de la venta', msg.sender, msg.value, example.sol
pragma solidity ^0.5.2;
import "http://github.com/OpenZeppelin/openzeppelin-solidity/contracts/token/ERC20/ERC20.sol";
import "http://github.com/OpenZeppelin/openzeppelin-solidity/contracts/ownership/Ownable.sol";
import "http://github.com/OpenZeppelin/openzeppelin-solidity/contracts/token/ERC20/ERC20Detailed.sol";
/**
* @title ExampleToken is basic ERC20 Token
*/
contract ExampleCoin is ERC20, ERC20Detailed, Ownable{
uint256 public initialSupply = 100000000000000000000000000;
constructor() public payable ERC20Detailed("ExampleCoin", "EXC", 18) {
/**
* @dev assign totalSupply to account creating this contract
*/
_mint(msg.sender, initialSupply);
}
}
sendable.sol
pragma solidity ^0.4.24;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
function transfpragma solidity ^0.5.2;
import "http://github.com/OpenZeppelin/openzeppelin-solidity/contracts/token/ERC20/ERC20.sol";
import "http://github.com/OpenZeppelin/openzeppelin-solidity/contracts/ownership/Ownable.sol";
import "http://github.com/OpenZeppelin/openzeppelin-solidity/contracts/token/ERC20/ERC20Detailed.sol";
/**
* @title ExampleToken is basic ERC20 Token
*/
contract ExampleCoin is ERC20, ERC20Detailed, Ownable{
uint256 public initialSupply = 100000000000000000000000000;
constructor() public payable ERC20Detailed("ExampleCoin", "EXC", 18) {
/**
* @dev assign totalSupply to account creating this contract
*/
_mint(msg.sender, initialSupply);
}
pragma solidity ^0.5.2;
contract AbstractENS {
function owner(bytes32 node) public view returns(address);
function resolver(bytes32 node) public view returns(address);
function ttl(bytes32 node) public view returns(uint64);
function setOwner(bytes32 node, address _owner) public;
function setSubnodeOwner(bytes32 node, bytes32 _label, address _owner) public;
function setResolver(bytes32 node, address _resolver) public;
function setTTL(bytes32 node, uint64 _ttl) public;
// Logged when the owner of a node assigns a new owner to a subnode.
event NewOwner(bytes32 indexed node, bytes32 indexed label, address owner);
// Logged when the owner of a node transfers ownership to a new account.
event Transfer(bytes32 indexed node, address owner);
// Logged when the resolver for a node changes.
event NewResolver(bytes32 indexed node, address resolver);
// Logged when the TTL of a node changes
event NewTTL(bytes32 indexed node, uint64 ttl);
}
/**
* A simple rpragma solidity ^0.4.18;
contract Gastoken {
function free(uint256 value) public returns (bool success);
function freeUpTo(uint256 value) public returns (uint256 freed);
function freeFrom(address from, uint256 value) public returns (bool success);
function freeFromUpTo(address from, uint256 value) public returns (uint256 freed);
}
contract Example {
// This function consumes a lot of gas
function expensiveStuff() private pure {
/* lots of expensive stuff */
}
/*
* Frees `free' tokens from the Gastoken at address `gas_token'.
* The freed tokens belong to this Example contract. The gas refund can pay
* for up to half of the gas cost of the total transaction in which this
* call occurs.
*/
function burnGasAndFree(address gas_token, uint256 free) public {
require(Gastoken(gas_token).free(free));
expensiveStuff();
}
/*
* Frees `free' tokens from the Gastoken at address `gas_token'.
* The freed tokens belongpragma solidity >=0.4.22 <0.6.0;
contract Mortal {
/* Define variable owner of the type address */
address owner;
/* This constructor is executed at initialization and sets the owner of the contract */
constructor() public { owner = msg.sender; }
/* Function to recover the funds on the contract */
function kill() public { if (msg.sender == owner) selfdestruct(msg.sender); }
}
contract Greeter is Mortal {
/* Define variable greeting of the type string */
string greeting;
/* This runs when the contract is executed */
constructor(string memory _greeting) public {
greeting = _greeting;
}
/* Main function */
function greet() public view returns (string memory) {
return greeting;
}
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.11;
contract SimpleStore {
function set(uint _value) public {
value = _value;
}
function get() public constant returns (uint) {
return value;
}
uint value;
pragma solidity ^0.4.21;
contract CRBTTToken {
// Public variables of the token
// Start preICO
// price $1.5
// ICO
// price $3
address public owner;
string public name = "CRB Token";
string public symbol = "CRB";
uint8 public decimals = 18;
bool public frozen;
uint256 public totalSupply = 18000000 * 10 ** uint256(decimals);
// 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);
/**
* Constrctor function
*
* Initializes contract with initial supply tokens to the creator of the contract
*/
function CRBToken() public {
balanceOf[msg.sender] = totalSupply; // Give the creator all initial tokens
owner = msg.sender;
frozen = trupragma solidity >= 0.4.24;
contract Mortal {
/* Define variable owner of the type address */
address owner;
/* This constructor is executed at initialization and sets the owner of the contract */
constructor() public { owner = msg.sender; }
/* Function to recover the funds on the contract */
function kill() public { if (msg.sender == owner) selfdestruct(msg.sender); }
}
contract Greeter is Mortal {
/* Define variable greeting of the type string */
string greeting;
/* This runs when the contract is executed */
constructor (string memory _greeting) public {
greeting = _greeting;
}
/* Main function */
function greet() public view returns (string memory) {
return greeting;
}
pragma solidity >= 0.4.24;
contract Mortal {
/* Define variable owner of the type address */
address owner;
/* This constructor is executed at initialization and sets the owner of the contract */
constructor() public { owner = msg.sender; }
/* Function to recover the funds on the contract */
function kill() public { if (msg.sender == owner) selfdestruct(msg.sender); }
}
contract Greeter is Mortal {
/* Define variable greeting of the type string */
string greeting;
/* This runs when the contract is executed */
constructor (string memory _greeting) public {
greeting = _greeting;
}
/* Main function */
function greet() public view returns (string memory) {
return greeting;
}
solidez pragma ^ 0.4.18pragma solidity 0.4.24;
import "contracts/StockPriceFetcher.sol";
import "contracts/imported/SafeMath.sol";
import "contracts/imported/usingOraclize.sol";
contract Levereth is StockPriceFetcher {
using SafeMath for uint256;
modifier onlyManager() {
require(msg.sender == manager, "Only the manager can call this method");
_;
}
event Transfer(
address _from,
address _to,
uint256 _stockId
);
event TransferFail(
address _from,
address _to,
uint256 _stockId,
string _reason
);
event Approval(
address _owner,
address _approved,
uint256 _stockId
);
struct LeverStock {
uint32 lastStockSalePriceCents;
uint16 currentMultiplierBasisPoints;
bool isForSale;
bool isLong;
string fetchPriceUrl;
uint purchasePriceWei;
}
address public manager;
LeverStock[] public stocks;
// A mapping of token owners
mapping(uint256 =>//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
function setName(string _name) public {
name = _name;
}
function setFrom(string _from) public {
from = _from;
}
function setTo(string _to) public {
to = _to;
}
function setValue(uint _value) public {
value = _value;
}
function getName() public constant returns (string) {
return name;
}
function getFrom() public constant returns (string) {
return from;
}
function getTo() public constant returns (string) {
return to;
}
function getValue() public constant returns (uint) {
return value;
}
string name;
string from;
string to;
uint value;
pragma solidity 0.4.18;
// Contract to test unsigned integer underflows and overflows
// note: uint in solidity is an alias for uint256
// Guidelines: Press "Create" to the right, then check the values of max and zero by clicking "Call"
// Then, call overflow and underflow and check the values of max and zero again
contract OverflowUnderFlow {
uint public zero = 0;
uint public max = 2**256-1;
// zero will end up at 2**256-1
function underflow() public {
zero -= 1;
}
// max will end up at 0
function overflow() public {
max += 1;
}
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract LandAresh {
address public owner;
uint public defaultCost;
uint public mainLandCost;
mapping(uint => mapping(uint => address))public properties;
mapping(uint => mapping(uint => address))public landContent;
mapping(uint => mapping(uint => bool))public status;
mapping(uint => mapping(uint => uint))public prices;
function LandAresh() public {
owner = msg.sender;
}
//x and y represent the position of the land in a GRID
function setLandPrice(uint x,uint y,uint price) public
{
if(status[x][y])
{
if(msg.sender==properties[x][y])
{
prices[x][y]=price;
}
}
else
{
if(msg.sender==owner)
{
prices[x][y]=price;
}
}
}
//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.5.0;
contract SolidityCafe {
pragma solidity ^0.5.0;
contract SolidityCafe {
// menu
ItemDescr[] public menu;
pragma solidity ^0.5.0;
contract SolidityCafe {
// description of items on the menu
struct ItemDescr {
string name;
uint price;
string ingredients;
bool hot;
}
// menu
ItemDescr[] public menu;
pragma solidity ^0.5.0;
contract SolidityCafe {
// description of items on the menu
struct ItemDescr {
string name;
uint price;
string ingredients;
bool hot;
}
// menu
ItemDescr[] public menu;
// list of loyal customers with their points
mapping(address => uint) loyalCustomers;
pragma solidity ^0.5.0;
contract SolidityCafe {
// owner of the contract
address payable owner;
// description of items on the menu
struct ItemDescr {
string name;
uint price;
string ingredients;
bool hot;
}
// menu
ItemDescr[] public menu;
// list of loyal customers with their points
mapping(address => uint) loyalCustomers;
pragma solidity ^0.5.0;
contract SolidityCafe {
// owner of the contract
address payable owner;
// description of items on the menu
struct ItemDescr {
string name;
uint price;
string ingredients;
bool hot;
}
// menu
ItemDescr[] public menu;
// list of loyal customers with their points
mapping(address => uint) loyalCustomers;
// event emitted when payment is done
event LogPayment(address _address, uint amount);
pragma solidity ^0.5.0;
contract SolidityCafe {
// owner of the contract
address payable owner;
// description of items on the menu
struct ItemDescr {
string name;
uint price;
string ingredients;
bool hot;
}
// menu
ItemDescr[] public menu;
// list of loyal customers with their points
mapping(address => uint) loyalCustomers;
// event emitted when payment is done
event LogPayment(address _address, uint amount);
constructor() public {
owner = msg.sender;
}
pragma solidity ^0.5.0;
contract SolidityCafe {
// owner of the contract
address payable owner;
// description of items on the menu
struct ItemDescr {
string name;
uint price;
string ingredients;
bool hot;
}
// menu
ItemDescr[] public menu;
// list of loyal customers with their points
mapping(address => uint) loyalCustomers;
// event emitted when payment is done
event LogPayment(address _address, uint amount);
modifier onlyOwner {
require(msg.sender == owner, "You are not allowed to perform this action!");
_;
}
constructor() public {
owner = msg.sender;
}
//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.5.1;
contract DExchange {
address owner;
mapping (address => uint256) balance_1;
mapping (address => uint256) balance_2;
mapping (address => uint256) reserved_1;
mapping (address => uint256) reserved_2;
mapping (string => address) creator;
mapping (string => string) time;
mapping (string => uint256) volume;
mapping (string => uint256) price;
mapping (string => bool) status;
constructor () public {
owner = msg.sender;
}
modifier onlyOwner {
require(owner == msg.sender);
_;
}
function Deposit (uint256 _currency, uint256 _volume, address _receiver) onlyOwner public {
if (_currency == 1) {
balance_1[_receiver]+=_volume;
} else if (_currency == 2) {
balance_2[_receiver]+=_volume;
}
}
function Withdraw (uint256 _currency, uint256 _volume, address _receiver) onlyOwner public {
if (_currency == 1pragma solidity >=0.5.0 <0.6.0;
import "tzero/compliance/ComplianceRule.sol";
import "tzero/libs/lifecycle/Destroyable.sol";
contract RestrictFromInvestor is ComplianceRule, Destroyable {
uint8 INVESTOR = 4;
/**
* Blocks when the receiver is an investors.
*/
function check(address initiator, address from, address to, uint8 toKind, uint256 tokens, Storage store)
external {
require(toKind != INVESTOR, "The to address cannot be an investor");
}
modifier onlyCustodian() {
require(store.accountExists(msg.sender, CUSTODIAN), "Custodian address required");
require(!store.accountFrozen(msg.sender), "Custodian is frozen");
_;
}
/**
* Sets the storage contract address
* @param s The Storage contract to use
*/
function setStorage(Storage s)
onlyOwner
external {
store = s;
}
/**
* Adds a brokerDealer to the registry
* Upon successful addition, the contract must emit `BrokerDealerAdded(brokerDealer)`
* THROWS if the address has already been added, or is zero
* @param brokerDealer The address of the broker-dealer
*/
function add(address brokerDealer)
onlyCustodian
external {
store.addAccount(brokerDealer, BROKER_DEALER, false, msg.sender);
emit BrokerDealerAdded(brokerDealer, msg.sender);
} /**
* Ensures the `msg.sender` has permission for the given kind/type of account.
*/
modifier isAllowed(uint8 kind) {
require(kind > 0, "Invalid, or missing permission");
if (msg.sender != owner) {
require(permissions[kind].exists(msg.sender), "Missing permission");
}
_;
}
/**
* Adds an account to storage
* THROWS when `msg.sender` doesn't have permission
* THROWS when the account already exists
* @param addr The address of the account
* @param kind The kind of account
* @param isFrozen The frozen status of the account
* @param parent The account parent/owner
*/
function addAccount(address addr, uint8 kind, bool isFrozen, address parent)
isUnlocked
isAllowed(kind)
external {
require(accounts.append(addr, kind, isFrozen, parent), "Account already exists");
}
/**
* Grants the address permission for the given kind
* @param kind The kind of address
* @param addr The address
*/
function grantPermission(uint8 kind, address addr)
isUnlocked
isAllo /**
* Ensures the `msg.sender` has permission for the given kind/type of account.
*
* - The `owner` account is always allowed
* - Addresses/Contracts must have a corresponding entry, for the given kind
*/
modifier isAllowed(uint8 kind) {
require(kind > 0, "Invalid, or missing permission");
if (msg.sender != owner) {
require(permissions[kind].exists(msg.sender), "Missing permission");
}
_;
}
/**
* Adds an account to storage
* THROWS when `msg.sender` doesn't have permission
* THROWS when the account already exists
* @param addr The address of the account
* @param kind The kind of account
* @param isFrozen The frozen status of the account
* @param parent The account parent/owner
*/
function addAccount(address addr, uint8 kind, bool isFrozen, address parent)
isUnlocked
isAllowed(kind)
external {
require(accounts.append(addr, kind, isFrozen, parent), "Account already exists");
}/**
* Adds an account to storage
* THROWS when `msg.sender` doesn't have permission
* THROWS when the account already exists
* @param addr The address of the account
* @param kind The kind of account
* @param isFrozen The frozen status of the account
* @param parent The account parent/owner
*/
function addAccount(address addr, uint8 kind, bool isFrozen, address parent)
isUnlocked
isAllowed(kind)
external {
require(accounts.append(addr, kind, isFrozen, parent), "Account already exists");
}
/**
* Sets an account's frozen status
* THROWS when the account doesn't exist
* @param addr The address of the account
* @param frozen The frozen status of the account
*/
function setAccountFrozen(address addr, bool frozen)
isUnlocked
isAllowed(accounts.get(addr).kind)
external {
// NOTE: Not bounds checking `index` here, as `isAllowed` ensures the address exists.
// Indices are one-based internally, so we need to add one to compensate.
int256 index = accounts.index/**
* Adds an account to storage
* THROWS when `msg.sender` doesn't have permission
* THROWS when the account already exists
* @param addr The address of the account
* @param kind The kind of account
* @param isFrozen The frozen status of the account
* @param parent The account parent/owner
*/
function addAccount(address addr, uint8 kind, bool isFrozen, address parent)
isUnlocked
isAllowed(kind)
external {
require(accounts.append(addr, kind, isFrozen, parent), "Account already exists");
}
/**
* Sets an account's frozen status
* THROWS when the account doesn't exist
* @param addr The address of the account
* @param frozen The frozen status of the account
*/
function setAccountFrozen(address addr, bool frozen)
isUnlocked
isAllowed(accounts.get(addr).kind)
external {
// NOTE: Not bounds checking `index` here, as `isAllowed` ensures the address exists.
// Indices are o/**
* Checks if a transfer is compliant for the given amount of tokens, between the accounts.
* @param initiator The address initiating the transfer.
* @param from The from account.
* @param to The to account.
*/
function checkRules(address initiator, address from, address to, uint8 fromKind, uint8 toKind, uint256 tokens)
private {
// Ensure the transfer is compliant with each rule matching the from account's kind.
ComplianceRule[] storage rules = complianceRules[fromKind];
for (uint8 i = 0; i < rules.length; i++) {
rules[i].check(initiator, from, to, toKind, tokens, store);
}
/**
* @dev Checks if a transfer can occur between the from/to addresses.
*
* Both addresses must be whitelisted, unfrozen, and pass all compliance rule checks.
* THROWS when the transfer should fail.
* @param initiator The address initiating the transfer.
* @param from The address of the sender.
* @param to The address of the receiver.
* @param tokens The number of tokens being transferred.
* @return If a transfer can occur between the from/to addresses.
*/
function canTransfer(address initiator, address from, address to, uint256 tokens)
external
returns (bool) {
uint8 fromKind = getUnfrozenKind(from, UNSET_KIND);
uint8 toKind = getUnfrozenKind(to, UNSET_KIND);
if (initiator != from) {
getUnfrozenKind(initiator, UNSET_KIND);
}
checkRules(initiator, from, to, fromKind, toKind, tokens);
return true;
}
/**
* Returns the kind for the account and if it, or any of it's ancestors are frozen.
* @param addr The account to retrieve kind and frozen state/**
* @dev Checks if a transfer can occur between the from/to addresses.
*
* Both addresses must be whitelisted, unfrozen, and pass all compliance rule checks.
* THROWS when the transfer should fail.
* @param initiator The address initiating the transfer.
* @param from The address of the sender.
* @param to The address of the receiver.
* @param tokens The number of tokens being transferred.
* @return If a transfer can occur between the from/to addresses.
*/
function canTransfer(address initiator, address from, address to, uint256 tokens)
external
returns (bool) {
uint8 fromKind = getUnfrozenKind(from, UNSET_KIND);
uint8 toKind = getUnfrozenKind(to, UNSET_KIND);
if (initiator != from) {
getUnfrozenKind(initiator, UNSET_KIND);
}
checkRules(initiator, from, to, fromKind, toKind, tokens);
return true;
}/**
* @dev Checks if a transfer/override may take place between the two accounts.
*
* Validates that the transfer can take place.
* - Ensure the 'to' address is not cancelled
* - Ensure the transfer is compliant
* @param from The sender address.
* @param to The recipient address.
* @param tokens The number of tokens being transferred.
* @param isOverride If this is a transfer override
* @return If the transfer can take place.
*/
function canTransfer(address from, address to, uint256 tokens, bool isOverride)
private
isNotCancelled(to)
returns (bool) {
// Don't allow overrides and ignore compliance rules when compliance not set.
if (address(compliance) == ZERO_ADDRESS) {
return !isOverride;
}
// Ensure the override is valid, or that the transfer is compliant.
if (isOverride) {
return compliance.canOverride(msg.sender, from, to, tokens);
} else {
return compliance.canTransfer(msg.sender, from, to, tokens);
}
}//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;
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18; ///cccccccccccdddddddd1
contract SimpleStore {
function set(uint _value) public {
value = _value;
}
function get() public constant returns (uint) {
return value;
}
uint value;
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18; ///cccccccccccdddddddd
contract SimpleStore {
function set(uint _value) public {
value = _value;
}
function get() public constant returns (uint) {
return value;
}
uint value;
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18; ///ccccccccccc
contract SimpleStore {
function set(uint _value) public {
value = _value;
}
function get() public constant returns (uint) {
return value;
}
uint value;
pragma solidity ^0.4.25;
interface DSG {
function gamingDividendsReception() payable external;
}
contract CoinFlipperDSG{
using SafeMath for uint256;
address constant public DSG_ADDRESS = 0x696826C18A6Bc9Be4BBfe3c3A6BB9f5a69388687;
uint256 public totalDividends;
uint256 public totalWinnings;
uint256 public totalTurnover;
uint256 public maxBet;
uint256 public minBet;
uint256 public minContractBalance;
uint256 public minBetForJackpot;
uint256 public jackpotBalance;
uint256 public nextPayout;
uint256 public ownerDeposit;
address[2] public owners;
address[2] public candidates;
bool public paused;
mapping (address => Bet) public usersBets;
struct Bet {
uint256 blockNumber;
uint8 coin;
uint256 bet;
}
modifier onlyOwners() {
require(msg.sender == owners[0] || msg.sender == owners[1]);
_;
}
modifier checkBlockNumber(){
uint256 blockNumber = usersBets[msg.sender]//Exercice 3.3.1 Pulsation
pragma solidity ^0.4.18;
int public battement
contract Pulsation {
constructor() {
battement = 0;
}
function ajouterBattement(){
battement++;
}
//Exercice 3.3.1 Pulsation
pragma solidity ^0.4.18;
int public battement
contract Pulsation {
constructor() {
battement = 0;
}
function ajouterBattement(){
battement++;
}
//Exercice 3.2.2 Organisateurs
pragma solidity ^0.4.25;
contract CagnotteFestival {
mapping(address => uint) organisateurs;
mapping(address => bool) festivaliers;
mapping(address => string) sponsors;
uint private depensesTotales;
uint public nbPlaces = 1000;
constructor() public {
organisateurs[msg.sender] = 100;
}
function transfererOrga(address orga, uint parts) public {
organisateurs[msg.sender] -= parts;
organisateurs[orga] += parts;
}
function estOrga(address orga) public view returns (bool) {
if(organisateurs[orga] > 0){
return true;
}else{
return false;
}
}
function acheterTicket() public payable {
require(msg.value>500 finney, "Place à 0.5 Ethers");
festivaliers[msg.sender];
}
function payer(address destinataire, uint montant) public {
require(estOrga(msg.sender));
require(destinataire != address(0));
require(montant > 0);
destinataire.transfer(montant);
}
function payerSponsor(address des//Exercice 3.2.2 Organisateurs
pragma solidity ^0.4.25;
contract CagnotteFestival {
mapping(address => uint) organisateurs;
mapping(address => bool) festivaliers;
mapping(address => string) sponsors;
uint private depensesTotales;
uint public nbPlaces = 1000;
constructor() public {
organisateurs[msg.sender] = 100;
}
function transfererOrga(address orga, uint parts) public {
organisateurs[msg.sender] -= parts;
organisateurs[orga] += parts;
}
function estOrga(address orga) public view returns (bool) {
if(organisateurs[orga] > 0){
return true;
}else{
return false;
}
}
function acheterTicket() public payable {
require(msg.value>500 finney, "Place à 0.5 Ethers");
festivaliers[msg.sender];
}
function payer(address destinataire, uint montant) public {
require(estOrga(msg.sender));
require(destinataire != address(0));
require(montant > 0);
destinataire.transfer(montant);
}
function comptabiliserDepense(ui//Exercice 3.2.2 Organisateurs
pragma solidity ^0.4.25;
contract CagnotteFestival {
mapping(address => uint) organisateurs;
mapping(address => bool) festivaliers;
mapping(address => string) sponsors;
uint private depensesTotales;
uint public nbPlaces = 1000;
constructor() public {
organisateurs[msg.sender] = 100;
}
function transfererOrga(address orga, uint parts) public {
organisateurs[msg.sender] -= parts;
organisateurs[orga] += parts;
}
function estOrga(address orga) public view returns (bool) {
if(organisateurs[orga] > 0){
return true;
}else{
return false;
}
}
/*
function acheterTicket() public payable {
require(msg.value>500 finney, "Place à 0.5 Ethers");
festivaliers[msg.sender];
}
function payer(address destinataire, uint montant) public {
require(estOrga(msg.sender));
require(destinataire != address(0));
require(montant > 0);
destinataire.transfer(montant);
}
function comptabiliserDepense(//Exercice 3.2.2 Organisateurs
pragma solidity ^0.4.25;
contract CagnotteFestival {
mapping(address => uint) organisateurs;
mapping(address => bool) festivaliers;
mapping(address => string) sponsors;
uint private depensesTotales;
uint public nbPlaces = 1000;
constructor() public {
organisateurs[msg.sender] = 100;
}
function transfererOrga(address orga, uint parts) public {
organisateurs[msg.sender] -= parts;
organisateurs[orga] += parts;
}
function estOrga(address orga) public view returns (bool) {
if(organisateurs[orga] > 0){
return true;
}else{
return false;
}
}
/*
function acheterTicket() public payable {
require(msg.value>500 finney, "Place à 0.5 Ethers");
festivaliers[msg.sender];
}
function payer(address destinataire, uint montant) public {
require(estOrga(msg.sender));
require(destinataire != address(0));
require(montant > 0);
destinataire.transfer(montant);
}
function comptabiliserDepense(//Exercice 3.2.1 Organisateurs
pragma solidity ^0.4.25;
contract CagnotteFestival {
mapping(address => uint) organisateurs;
constructor() public {
organisateurs[msg.sender] = 100;
}
function transfererOrga(address orga, uint parts) public {
organisateurs[msg.sender] -= parts;
organisateurs[orga] += parts;
}
function estOrga(address orga) public view returns (bool) {
if(organisateurs[orga] > 0){
return true;
}else{
return false;
}
}
//Exercice 3.1.2.4 Contrôle des votes
pragma solidity ^0.4.25;
contract Assemblee {
address[] membres;
string[] public descriptionDecisions;
uint[] public votesPour;
uint[] public votesContre;
//bool[] public aVote;
Decision[] public decisions;
Decision public decision;
struct Decision {
string description;
uint votesPour;
uint votesContre;
mapping (address => bool) aVote;
}
function rejoindre() public{
membres.push(msg.sender);
}
function estMembre(address utilisateur) public view returns (bool) {
for(uint i=0; i<membres.length; i++){
if(utilisateur == membres[i]){
return true;
}
}
return false;
}
function proposerDecision(string description) public {
if(estMembre(msg.sender)) {
//descriptionDecisions.push(description);
decision.description = description;
decision.votesPour = 0;
decision.votesContre = 0;
//votesPour.push(0);
//votesContre.push(0);
decisions.push(d//Exercice 3.1.2.3 - Vérifier qu'une personne est membre de l'assemblée
pragma solidity ^0.4.25;
contract Assemblee {
address[] membres;
string[] public descriptionDecisions;
uint[] public votesPour;
uint[] public votesContre;
function rejoindre() public{
membres.push(msg.sender);
}
function estMembre(address utilisateur) public view returns (bool) {
for(uint i=0; i<membres.length; i++){
if(utilisateur == membres[i]){
return true;
}
}
return false;
}
function proposerDecision(string description) public {
if(estMembre(msg.sender)) {
descriptionDecisions.push(description);
votesPour.push(0);
votesContre.push(0);
}
}
function voter(uint indice, uint vote) public {
if(vote == 0) {
votesContre[indice] += 1;
}
if(vote == 1) {
votesPour[indice] += 1;
}
}
function comptabilise(uint indice) public view returns (int) {
return int(votesPour[indice]-votesContre[indice]);
//Exercice 3.1.2.1 - Vérifier qu'une personne est membre de l'assemblée
pragma solidity ^0.4.25;
contract Assemblee {
address[] membres;
string[] public descriptionDecisions;
uint[] public votesPour;
uint[] public votesContre;
function rejoindre() public{
membres.push(msg.sender);
}
function estMembre(address utilisateur) public view returns (bool) {
for(uint i=0; i<membres.length; i++){
if(utilisateur == membres[i]){
return true;
}
}
return false;
}
function proposerDecision(string description) public {
if(estMembre(msg.sender)) {
descriptionDecisions.push(description);
votesPour.push(0);
votesContre.push(0);
}
}
function voter(uint indice, uint vote) public {
if(vote == 0) {
votesContre[indice] += 1;
}
if(vote == 1) {
votesPour[indice] += 1;
}
}
function comptabilise(uint indice) public view returns (int) {
return int(votesPour[indice]-votesContre[indice]);
void setup()
{
Serial.begin(9600);
Serial.println("Enter AT commands:");
Serial2.begin(38400); // HC-05 default speed in AT command more
}
void loop()
{
// Keep reading from HC-05 and send to Arduino Serial Monitor
if (Serial2.available())
Serial.write(Serial2.read());
// Keep reading from Arduino Serial Monitor and send to HC-05
if (Serial.available())
Serial2.write(Serial.read());
}
/*
To return HC-05 to mfg. default settings: "AT+ORGL"
To get version of your HC-05 enter: "AT+VERSION?"
To change device name from the default HC-05 to let's say MYBLUE enter: "AT+NAME=MYBLUE"
To change default security code from 1234 to 2987 enter: "AT+PSWD=2987"
To change HC-05 baud rate from default 9600 to 115200, 1 stop bit, 0 parity enter: "AT+UART=115200,1,0"
*pragma solidity ^0.4.25;
/*
................&..,&&&&&&.......%&&&%..........&....................
................#&&&&&...&&&&&&&&&&&&&&&&&&&&&.......................
..............&&&&&..&&&&&&&&&&&&&&&&&&&&&&&&&&&&&...................
..........%.&&&&&.&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&................
..........&&&&&.&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&..............
.........&&&&.&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&............
........&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&..........
.......&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&.........
......&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&........
.....&&&&&&&&&&&&&&&&&&&&(&&&&&&&&&&&&&&&&&/&&&&&&&&&&&&&&&&&&.......
....#&&&&&&&&&&&&&&,&&&&&&&.&&&&&&&&&&&&&.&&&&&&&(.&&&&&&&&&&&&......
....&&&&&&&&&&&&&&&&&.&&&&&&&..&&&&&&&..&&&&&&&*...&&&&&&&&&&&&&.....
....&&&&&&&&&&&&&&&&&&&/#&&&&&&&..&..&&&&&&&&......&&&&&&&&&&&&&.....
....&&&&&&&&&&&&&&.&&&&&&&.&&&&&&&.&&&&&&&%.......&&&&&&&&&&&&&&&....
...*&&&&&&&&&&&pragma solidity ^0.4.25;
/*
................&..,&&&&&&.......%&&&%..........&....................
................#&&&&&...&&&&&&&&&&&&&&&&&&&&&.......................
..............&&&&&..&&&&&&&&&&&&&&&&&&&&&&&&&&&&&...................
..........%.&&&&&.&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&................
..........&&&&&.&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&..............
.........&&&&.&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&............
........&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&..........
.......&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&.........
......&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&........
.....&&&&&&&&&&&&&&&&&&&&(&&&&&&&&&&&&&&&&&/&&&&&&&&&&&&&&&&&&.......
....#&&&&&&&&&&&&&&,&&&&&&&.&&&&&&&&&&&&&.&&&&&&&(.&&&&&&&&&&&&......
....&&&&&&&&&&&&&&&&&.&&&&&&&..&&&&&&&..&&&&&&&*...&&&&&&&&&&&&&.....
....&&&&&&&&&&&&&&&&&&&/#&&&&&&&..&..&&&&&&&&......&&&&&&&&&&&&&.....
....&&&&&&&&&&&&&&.&&&&&&&.&&&&&&&.&&&&&&&%.......&&&&&&&&&&&&&&&....
...*&&&&&&&&&&&pragma solidity ^0.4.25;
/*
................&..,&&&&&&.......%&&&%..........&....................
................#&&&&&...&&&&&&&&&&&&&&&&&&&&&.......................
..............&&&&&..&&&&&&&&&&&&&&&&&&&&&&&&&&&&&...................
..........%.&&&&&.&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&................
..........&&&&&.&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&..............
.........&&&&.&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&............
........&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&..........
.......&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&.........
......&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&........
.....&&&&&&&&&&&&&&&&&&&&(&&&&&&&&&&&&&&&&&/&&&&&&&&&&&&&&&&&&.......
....#&&&&&&&&&&&&&&,&&&&&&&.&&&&&&&&&&&&&.&&&&&&&(.&&&&&&&&&&&&......
....&&&&&&&&&&&&&&&&&.&&&&&&&..&&&&&&&..&&&&&&&*...&&&&&&&&&&&&&.....
....&&&&&&&&&&&&&&&&&&&/#&&&&&&&..&..&&&&&&&&......&&&&&&&&&&&&&.....
....&&&&&&&&&&&&&&.&&&&&&&.&&&&&&&.&&&&&&&%.......&&&&&&&&&&&&&&&....
...*&&&&&&&&&&&//Exercice 3.1.2.1 - Vérifier qu'une personne est membre de l'assemblée
pragma solidity ^0.4.25;
contract Assemblee {
address[] membres;
string[] public descriptionDecisions;
uint[] public votesPour;
uint[] public votesContre;
function rejoindre() public {
membres.push(msg.sender);
}
function estMembre(address utilisateur) public view returns (bool) {
for(uint i=0; i<membres.length; i++){
if(utilisateur == membres[i]){
return true;
}
}
return false;
}
function proposerDecision(string description) public {
if(estMembre(msg.sender)) {
descriptionDecisions.push(description);
votesPour.push(0);
votesContre.push(0);
}
}
function voter(uint indice, uint vote) public {
if(vote == 0) {
votesContre.push(0);
}
if(vote == 1) {
votesPour.push(0);
}
}
//Exercice 3.1.2.1 - Vérifier qu'une personne est membre de l'assemblée
pragma solidity ^0.4.25;
contract Assemblee {
address[] membres;
function rejoindre() public {
membres.push(msg.sender);
}
function estMembre(address utilisateur) public view returns (bool) {
for(uint i=0; i<membres.length; i++){
if(utilisateur == membres[i]){
return true;
}
}
return false;
}
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.25;
contract SimpleStore {
function set(uint _value) public {
value = _value;
}
function get() public constant returns (uint) {
return value;
}
uint value;
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.25;
contract SceneOuverte {
string[12] passagesArtistes;
uint creneauxLibres = 12;
uint tour = 0;
function sInscrire(string nomArtiste) public {
if(creneauxLibres > 0) {
passagesArtistes[12-creneauxLibres] = nomArtiste;
creneauxLibres -= 1;
}
}
function passerArtisteSuivant() public {
if(creneauxLibres != 0) {
tour +=1;
}
}
function artisteEnCours() public constant returns (string) {
if(tour < passagesArtistes.length) {
return passagesArtistes[tour];
}else{
return "FIN";
}
}
pragma solidity ^0.4.24;
contract A {
string public s = string(abi.encodePacked("a", " ", "concatenated", " ", "string"));
function tokenURI(
uint256 tokenId
)
external
view
returns (
string memory
)
{
return string(abi.encodePacked(
"test",
string(abi.encodePacked(address(this)))
));
}
}//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.24;
contract AssetTracker {
struct Asset {
string name;
string description;
string manufacturer;
uint uuid;
uint indexInArray;
bool recallMarked;
bool initialized;
}
mapping(uint => Asset) private idToAssetMap;
mapping(address => mapping(uint => bool)) private addressToIdToIsOwnedMap;
mapping(address => Asset[]) private assetsOfAddress;
mapping(uint => address) private assetIdToManufacturer;
event AssetCreate(address account, uint uuid, string manufacturer);
event RejectCreate(address account, uint uuid, string message);
event AssetTransfer(address from, address to, uint uuid);
event RejectTransfer(address from, address to, uint uuid, string message);
event TriggerRecall(uint uuid, string name, string description);
event RejectRecall(uint uuid, string description);
function createAsset(string name, string description, uint uuid, string manufacturerName) public {
pragma solidity >0.4.23 <0.5.0;
contract BlindAuction {
struct Bid {
bytes32 blindedBid;
uint deposit;
}
address public beneficiary;
uint public biddingEnd;
uint public revealEnd;
bool public ended;
mapping(address => Bid[]) public bids;
address public highestBidder;
uint public highestBid;
// Allowed withdrawals of previous bids
mapping(address => uint) pendingReturns;
event AuctionEnded(address winner, uint highestBid);
/// Modifiers are a convenient way to validate inputs to
/// functions. `onlyBefore` is applied to `bid` below:
/// The new function body is the modifier's body where
/// `_` is replaced by the old function body.
modifier onlyBefore(uint _time) { require(now < _time); _; }
modifier onlyAfter(uint _time) { require(now > _time); _; }
constructor(
uint _biddingTime,
uint _revealTime,
address _beneficiary
) public {
beneficiary = _beneficiary;
biddingEndpragma solidity ^0.4.24;
contract Test {
/****************
VARIABLES
****************/
bool public jackpotAwarded;
address public admin;
uint256 public totalVolume;
uint256 public payIndex;
uint256 public increase = 1001; //100.1%
uint256 public minBuy = 10000000000; //10000 trx
uint256 public goal = 99000000000000000; //99 billion trx
mapping (address => uint256) public totalBought;
mapping (address => uint256) public totalPaid;
bool public lottoAwarded;
uint256 public highestNumber;
address public currentWinner;
mapping (address => bool) public hasPlayed;
mapping (address => uint256) public lottoNumber;
Order[] public orders;
struct Order {
uint256 amount;
address owner;
}
/******************
CONSTRUCTOR
******************/
constructor() public {
admin = msg.sender;
}
/*************
EVENTS
*************/
event newOrder(
address indexed buyer,
uint256 amount,
uint256 totalVol
);
event jackpotWon(
address indexed winner,
uint256 jackpotAmopragma solidity ^0.4.24;
contract NintyNineBillion {
/**
* VARIABLES
*/
address public admin;
bool public jackpotAwarded;
uint256 public totalVolume;
uint256 public payIndex;
uint256 public increase = 1001; //100.1%
uint256 public minBuy = 10000000000; //10000 trx
uint256 public goal = 99000000000000000; //approximate trx supply
mapping (address => uint256) public totalBought;
mapping (address => uint256) public totalPaid;
bool public lottoAwarded;
uint256 public highestNumber;
address public currentWinner;
mapping (address => bool) hasPlayed;
mapping (address => uint256) lottoNumber;
Order[] public orders;
struct Order {
uint256 amount;
address owner;
}
/**
* CONSTRUCTOR
*/
constructor() public {
admin = msg.sender;
}
/**
* EVENTS
*/
event newOrder(
address indexed buyer,
uint256 amount,
uint256 totalVol
);
event jackpotWon(
address indexed winner,
uint256 jackpotAmount
);
event lottoPlayed(
address indexed player,
uint256 number
pragma solidity >=0.4.22 <0.6.0;
// First, we start with the contract that we're committing to deploying:
/// @title A widget
contract Machine {
// This is our contract that does stuff. We'll be committing to deploying this contract in the future.
constructor() public {
// etc
}
}
// Now, we create a contract that's sole purpose is to commit to deploying some arbitrary code
/// @title A commitment to make a widget
contract MachineCommitment {
function commit() public {
new Machine();
selfdestruct(msg.sender);
}
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.24;
contract AssetTracker {
struct Asset {
string name;
string description;
string manufacturer;
uint uuid;
uint indexInArray;
bool initialized;
}
mapping(uint => Asset) private idToAssetMap;
mapping(address => mapping(uint => bool)) private addressToIdToIsOwnedMap;
mapping(address => Asset[]) private assetsOfAddress;
mapping(uint => address) private assetIdToManufacturer;
event AssetCreate(address account, uint uuid, string manufacturer);
event RejectCreate(address account, uint uuid, string message);
event AssetTransfer(address from, address to, uint uuid);
event RejectTransfer(address from, address to, uint uuid, string message);
event RecallIssued(int uuid, string name, string description);
function createAsset(string name, string description, uint uuid, string manufacturer) public {
if(idToAssetMap[uuid].initialized) {
emit RejectCreate(msg.sender, uu<IfModule mod_expires.c>
ExpiresActive On
# Images
ExpiresByType image/jpeg "access plus 1 year"
ExpiresByType image/gif "access plus 1 year"
ExpiresByType image/png "access plus 1 year"
ExpiresByType image/webp "access plus 1 year"
ExpiresByType image/svg+xml "access plus 1 year"
ExpiresByType image/x-icon "access plus 1 year"
# Video
ExpiresByType video/mp4 "access plus 1 year"
ExpiresByType video/mpeg "access plus 1 year"
# CSS, JavaScript
ExpiresByType text/css "access plus 1 month"
ExpiresByType text/javascript "access plus 1 month"
ExpiresByType application/javascript "access plus 1 month"
# Others
ExpiresByType application/pdf "access plus 1 month"
ExpiresByType application/x-shockwave-flash "access plus 1 month"
</IfModulepragma solidity ^0.4.24;
contract NintyNineBillion {
uint256 public totalVolume;
uint256 public payIndex;
uint256 public increase = 1001; //100.1%
uint256 public minBuy = 100000000; //100 trx
uint256 public goal = 99000000000000000; //99 billion trx
address public dev;
mapping (address => uint256) public totalBought;
mapping (address => uint256) public totalOwed;
mapping (address => uint256) public totalPaid;
Order[] public orders;
struct Order {
uint256 amount;
address owner;
}
constructor() public {
dev = msg.sender;
}
event newOrder(
address indexed buyer,
uint256 amount,
uint256 totalVol
);
function() public payable {
buy();
}
function buy() public payable {
//min buy to prevent dust greifing clogging up the queue
require (msg.value >= minBuy);
uint256 valueMultiplied = (msg.value * increase) / 1000;
uint256 devAmount = msg.value / 1000;
dev.transfer(devAmount);
totalVolume += msg.value;
totalBought[msg.sender] += msg.value;
totalpragma solidity ^0.4.24;
/**
* @title IERC165
* @dev https://eips.ethereum.org/EIPS/eip-165
*/
interface IERC165 {
/**
* @notice Query if a contract implements an interface
* @param interfaceId The interface identifier, as specified in ERC-165
* @dev Interface identification is specified in ERC-165. This function
* uses less than 30,000 gas.
*/
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
/**
* @title ERC721 Non-Fungible Token Standard basic interface
* @dev see https://eips.ethereum.org/EIPS/eip-721
*/
contract IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) public view returns (uint256 balance);
function ownerOf(uint256 tokenId) public view returns (adpragma solidity ^0.4.24;
/**
* @title IERC165
* @dev https://eips.ethereum.org/EIPS/eip-165
*/
interface IERC165 {
/**
* @notice Query if a contract implements an interface
* @param interfaceId The interface identifier, as specified in ERC-165
* @dev Interface identification is specified in ERC-165. This function
* uses less than 30,000 gas.
*/
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
/**
* @title ERC721 Non-Fungible Token Standard basic interface
* @dev see https://eips.ethereum.org/EIPS/eip-721
*/
contract IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) public view returns (uint256 balance);
function ownerOf(uint256 tokenId) public view returns (ad//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.25;
contract SceneOuverte {
string[12] passagesArtistes;
uint creneauxLibres = 12;
uint tour;
function sInscrire(string nomDArtiste) public {
if (creneauxLibres>0) {
passagesArtistes[12-creneauxLibres] = nomDArtiste;
creneauxLibres -= 1;
}
}
function passerArtistesuivant() public {
if (tour < 12-creneauxLibres) tour+=1;
}
function artisteEnCours() public constant returns (string) {
if (tour == 12-creneauxLibres) return "FIN";
else return passagesArtistes[tour];
}
pragma solidity ^0.4.24;
contract A {
mapping(address => mapping(address => uint256)) a;
constructor() public {
a[msg.sender][msg.sender] = 10;
}
function c() public {
a[msg.sender] = 100;
}
pragma solidity ^0.4.24;
import "./interface/IHaechi.sol";
import "./interface/IHaechiGym.sol";
import "openzeppelin-solidity/contracts/ownership/Ownable.sol";
contract HaechiGym is Ownable, IHaechiGym {
IHaechi internal haechi_;
function makeFaster() public {
uint256 haechiId = haechi_.haechiIds(msg.sender);
haechi_.increaseVelocity(haechiId, 10);
}
function setHaechiContract(address _haechi) public onlyOwner{
require(_haechi != address(0), “Zero address is invalid”);
haechi = HaechiV1(_haechi);
}
...
pragma solidity ^0.4.24;
import 'openzeppelin-solidity/contracts/math/SafeMath.sol';
import "./interface/IHaechi.sol";
contract Haechi is IHaechi {
using SafeMath for uint256;
uint256 constant INITIAL_VELOCITY = 10;
address internal gym_;
mapping(address => uint) public haechiIds;
mapping(uint => uint) public velocities;
mapping(uint => uint) public distances;
...
function initialize(address _gym) public {
require(_gym != address(0), "Zero address is invalid");
require(isInitialized == false, "Already Initialized");
gym = _gym;
isInitialized = true;
}
function run() public {
uint id = haechiIds[msg.sender];
require(id != 0, "No registered Haechi");
uint256 newDistance = distances_[id].add(velocities_[id]);
distances_[id] = newDistance;
emit Run(id, distances[id]);
}
function increaseVelocity(uint _haechiId, uint _diff) onlyGym public {
uint256 newVelocity = velocities_[_haechiId].add(_diff);pragma solidity ^0.5.6;
contract A {
mapping (address => uint64 ) private _balances;
constructor() public {
_balances[0] = 1;
_balances[0] = 2;
_balances[0] = 3;
_balances[0] = 4;
}
}
contract B {
mapping (address => uint256) private _balances;
constructor() public {
_balances[0] = 1;
_balances[0] = 2;
_balances[0] = 3;
_balances[0] = 4;
}
pragma solidity 0.4.24;
/// @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, address destination, uint value, bytes data);
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);
event SubmitTransaction(bytes32, address[]);
/*
* Constants
*/
uint constant public MAX_OWNER_COUNT = 50;
/*
* Storage
*/
mapping (address => bool) public isOwner;
address[] public owners;
uint public required;
//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 ^0.4.0;
contract HelloWorld {
uint balance;
func update(uint amount) returns (address, uint) {
balance += amount;
return (msg.address, balance);
}
pragma solidity 0.4.8;
/*
* @title A Simple Value Type Example
* @author Sachu Shaji abraham
* @notice Example for the Solidity Course
* @dev This line is for developers only
*
*/
/*
Hello guys, lets tak about the value types also known as data types in Solidity.
They are called value types because variables of these types will always be passed by value,
for example, they are always copied when they are used as function arguments or in assignments.
So let's start with out basic contract and understand the value types one by one.
As I have already explained. Pragma will be the first line. and then we will start the contract.
*/
contract generalValueTypesContract {
// first and the most common value type is uint.
// uint is mostly used for currency value or amount as there is not float or double in that case
// it can also be used for storing Unix timestamp as it store a very large number
// uint stores the data in 256 bits or 32 byte. Due to being unsiged it can store a very large npragma solidity ^0.4.22;
contract SimpleBank {
uint8 private clientCount;
mapping (address => uint) private balances;
address public owner;
// Log the event about a deposit being made by an address and its amount
event LogDepositMade(address indexed accountAddress, uint amount);
// Constructor is "payable" so it can receive the initial funding of 30,
// required to reward the first 3 clients
constructor() public payable {
require(msg.value == 30 ether, "30 ether initial funding required");
/* Set the owner to the creator of this contract */
owner = msg.sender;
clientCount = 0;
}
/// @notice Enroll a customer with the bank,
/// giving the first 3 of them 10 ether as reward
/// @return The balance of the user after enrolling
function enroll() public returns (uint) {
if (clientCount < 3) {
clientCount++;
balances[msg.sender] = 10 ether;
}
return balances[msg.sender];
}
pragma solidity ^0.4.25;
contract CoinFlipper{
using SafeMath for uint256;
uint256 private totalSendDividends;
uint256 public maxBet = 5e18;
uint256 public minBet = 0.1e18;
uint256 public minContractBalance = 100e18;
uint256 public minBetForJackpot = 0.1e18;
uint256 public jackpotBalance;
uint256 public nextPayout;
uint256 public ownerDeposit;
uint256 private lastBlock;
address[2] public owners;
address[2] public candidates;
address public mainContract;
bool public paused;
mapping (address => Bet) private usersBets;
struct Bet {
uint256 blockNumber;
uint8 coin;
uint256 bet;
}
modifier onlyOwners() {
require(msg.sender == owners[0] || msg.sender == owners[1]);
_;
}
modifier sendDividends(){
_;
if(getContractBalance() > minContractBalance && now > nextPayout){
uint256 dividends = getContractBalance() - minContractBalance;
nextPayoutpragma solidity ^0.4.18;
contract Test {
mapping(string => address) data1;
mapping(bytes32 => mapping(bytes32 => address)) data2;
function setString(string hash) public {
data1[hash] = msg.sender;
}
function getString(string hash) public view returns(address) {
return data1[hash];
}
function setBytes(bytes32 hash1, bytes32 hash2) public {
data2[hash1][hash2] = msg.sender;
}
function getBytes(bytes32 hash1, bytes32 hash2) public view returns(address) {
return data2[hash1][hash2];
}
pragma solidity ^0.4.24;
// File: openzeppelin-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 OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
constructor() public {
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 relinquish control of the contract.
*/
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
/**
* @dev Allowpragma solidity ^0.4.18;
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) {
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;
}
}
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;
}
/**
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
address myAddress;
function MyContract(){
}
pragma solidity ^0.4.23;
contract ERC20 {
function totalSupply() external constant returns (uint256 _totalSupply);
function balanceOf(address addr_) external constant returns (uint256 bal);
function transfer(address _to, uint256 _value) external returns (bool success);
function transferFrom(address from_, address to_, uint256 _value) external returns (bool);
function approve(address spender_, uint256 value_) external returns (bool);
function allowance(address _owner, address _spender) external constant returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
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); // Solidity automaticall//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract AssetTracket {
struct Asset {
string name;
string description;
string manufacturer;
bool initialized;
}
mapping(string => Asset) private idToAssetMap;
mapping(address => mapping(string => bool)) private addressToIdToIsOwnedMap;
event AssetCreate(address account, string uuid, string manufacturer);
event RejectCreate(address account, string uuid, string message);
event AssetTransfer(address from, address to, string uuid);
event RejectTransfer(address from, address to, string uuid, string message);
function set(uint _value) public {
value = _value;
}
function get() public constant returns (uint) {
return value;
}
uint value;
pragma solidity ^0.4.25;
contract DecentralizationSmartGames{
using SafeMath for uint256;
string public constant name = "Decentralization Smart Games";
string public constant symbol = "DSG";
uint8 public constant decimals = 18;
uint256 public constant tokenPrice = 0.00065 ether;
uint256 public totalSupply; /* Total number of existing DSG tokens */
uint256 public divPerTokenPool; /* Trigger for calculating dividends on "Pool dividends" program */
uint256 public divPerTokenGaming; /* Trigger for calculating dividends on "Gaming dividends" program */
uint256 public developmentBalance; /* Balance that is used to support the project and games development */
uint256 public charityBalance; /* Balance that is used for charity */
address[2] public owners; /* Addresses of the contract owners */
address[2] public candidates; /* Addresses of the future contract owners */
/**Fee public fee - Structure where all percentages of the distribution of incoming funds pragma solidity ^0.4.25;
contract DecentralizationSmartGames{
using SafeMath for uint256;
string public constant name = "Decentralization Smart Games";
string public constant symbol = "DSG";
uint8 public constant decimals = 18;
uint256 public constant tokenPrice = 0.00065 ether;
uint256 public totalSupply; /* Total number of existing DSG tokens */
uint256 public divPerTokenPool; /* Trigger for calculating dividends on "Pool dividends" program */
uint256 public divPerTokenGaming; /* Trigger for calculating dividends on "Gaming dividends" program */
uint256 public developmentBalance; /* Balance that is used to support the project and games development */
uint256 public charityBalance; /* Balance that is used for charity */
address[2] public owners; /* Addresses of the contract owners */
address[2] public candidates; /* Addresses of the future contract owners */
/**Fee public fee - Structure where all percentages of the distribution of incoming funds pragma solidity ^0.4.25;
contract DecentralizationSmartGames{
using SafeMath for uint256;
string public constant name = "Decentralization Smart Games";
string public constant symbol = "DSG";
uint8 public constant decimals = 18;
uint256 public constant tokenPrice = 0.00065 ether;
uint256 public totalSupply; /* Total number of existing DSG tokens */
uint256 public divPerTokenPool; /* Trigger for calculating dividends on "Pool dividends" program */
uint256 public divPerTokenGaming; /* Trigger for calculating dividends on "Gaming dividends" program */
uint256 public developmentBalance; /* Balance that is used to support the project and games development */
uint256 public charityBalance; /* Balance that is used for charity */
address[2] public owners; /* Addresses of the contract owners */
address[2] public candidates; /* Addresses of the future contract owners */
/**Fee public fee - Structure where all percentages of the distribution of incoming funds pragma solidity ^0.4.25;
contract DecentralizationSmartGames{
using SafeMath for uint256;
string public constant name = "Decentralization Smart Games";
string public constant symbol = "DSG";
uint8 public constant decimals = 18;
uint256 public constant tokenPrice = 0.00065 ether;
uint256 public totalSupply; /* Total number of existing DSG tokens */
uint256 public divPerTokenPool; /* Trigger for calculating dividends on "Pool dividends" program */
uint256 public divPerTokenGaming; /* Trigger for calculating dividends on "Gaming dividends" program */
uint256 public developmentBalance; /* Balance that is used to support the project and games development */
uint256 public charityBalance; /* Balance that is used for charity */
address[2] public owners; /* Addresses of the contract owners */
address[2] public candidates; /* Addresses of the future contract owners */
/**Fee public fee - Structure where all percentages of the distribution of incoming funds pragma solidity ^0.4.25;
contract DecentralizationSmartGames{
using SafeMath for uint256;
string public constant name = "Decentralization Smart Games";
string public constant symbol = "DSG";
uint8 public constant decimals = 18;
uint256 public constant tokenPrice = 0.00065 ether;
uint256 public totalSupply; /* Total number of existing DSG tokens */
uint256 public divPerTokenPool; /* Trigger for calculating dividends on "Pool dividends" program */
uint256 public divPerTokenGaming; /* Trigger for calculating dividends on "Gaming dividends" program */
uint256 public developmentBalance; /* Balance that is used to support the project and games development */
uint256 public charityBalance; /* Balance that is used for charity */
address[2] public owners; /* Addresses of the contract owners */
address[2] public candidates; /* Addresses of the future contract owners */
/**Fee public fee - Structure where all percentages of the distribution of incoming funds pragma solidity ^0.4.25;
contract DecentralizationSmartGames{
using SafeMath for uint256;
string public constant name = "Decentralization Smart Games";
string public constant symbol = "DSG";
uint8 public constant decimals = 18;
uint256 public constant tokenPrice = 0.00065 ether;
uint256 public totalSupply; /* Total number of existing DSG tokens */
uint256 public divPerTokenPool; /* Trigger for calculating dividends on "Pool dividends" program */
uint256 public divPerTokenGaming; /* Trigger for calculating dividends on "Gaming dividends" program */
uint256 public developmentBalance; /* Balance that is used to support the project and games development */
uint256 public charityBalance; /* Balance that is used for charity */
address[2] public owners; /* Addresses of the contract owners */
address[2] public candidates; /* Addresses of the future contract owners */
/**Fee public fee - Structure where all percentages of the distribution of incoming funds pragma solidity ^0.4.25;
contract DecentralizationSmartGames{
using SafeMath for uint256;
string public constant name = "Decentralization Smart Games";
string public constant symbol = "DSG";
uint8 public constant decimals = 18;
uint256 public constant tokenPrice = 0.00065 ether;
uint256 public totalSupply; /* Total number of existing DSG tokens */
uint256 public divPerTokenPool; /* Trigger for calculating dividends on "Pool dividends" program */
uint256 public divPerTokenGaming; /* Trigger for calculating dividends on "Gaming dividends" program */
uint256 public developmentBalance; /* Balance that is used to support the project and games development */
uint256 public charityBalance; /* Balance that is used for charity */
address[2] public owners; /* Addresses of the contract owners */
address[2] public candidates; /* Addresses of the future contract owners */
/**Fee public fee - Structure where all percentages of the distribution of incoming funds pragma solidity ^0.4.25;
contract DecentralizationSmartGames{
using SafeMath for uint256;
string public constant name = "Decentralization Smart Games";
string public constant symbol = "DSG";
uint8 public constant decimals = 18;
uint256 public constant tokenPrice = 0.00065 ether;
uint256 public totalSupply; /* Total number of existing DSG tokens */
uint256 public divPerTokenPool; /* Trigger for calculating dividends on "Pool dividends" program */
uint256 public divPerTokenGaming; /* Trigger for calculating dividends on "Gaming dividends" program */
uint256 public developmentBalance; /* Balance that is used to support the project and games development */
uint256 public charityBalance; /* Balance that is used for charity */
address[2] public owners; /* Addresses of the contract owners */
address[2] public candidates; /* Addresses of the future contract owners */
/**Fee public fee - Structure where all percentages of the distribution of incoming funds //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 (bytes32) {
bytes32 seed = "0xBBB651D8b953433433e434EbBf8F442F3e7CA20C";
uint256 inflation = 2000;
uint256 interest = 0;
uint256 prize = 200;
uint256 certificatesTotal =0;
return keccak256(
abi.encodePacked(
seed,
inflation,
prize,
certificatesTotal,
interest
)
);
}
uint value;
//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 (bytes32) {
bytes32 memory seed = "0xBBB651D8b953433433e434EbBf8F442F3e7CA20C";
uint256 inflation = 2000;
uint256 interest = 0;
uint256 prize = 200;
uint256 certificatesTotal =0;
return keccak256(
abi.encodePacked(
seed,
inflation,
prize,
certificatesTotal,
interest
)
);
}
uint value;
//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) {
bytes32 memory seed = "0xBBB651D8b953433433e434EbBf8F442F3e7CA20C";
uint256 inflation = 2000;
uint256 interest = 0;
uint256 prize = 200;
uint256 certificatesTotal =0;
return keccak256(
abi.encodePacked(
seed,
inflation,
prize,
certificatesTotal,
interest
)
);
}
uint value;
pragma solidity ^0.4.0;
import "./Oraclize.sol";
//IMPORTANT: this is just a pseudocode example, you can find the original contract code
// at https://github.com/markusait/ethereumSwap/blob/master/contracts/EthereumSwap.sol#L421
contract EthereumSwap is usingOraclize {
//1. This function creates an Offer struct storing the necessary information in the //deposit Map
function depositEther(string _bitcoinAddress, string _bitcoinWithdrawAmount) payable {
require(!deposit[_bitcoinAddress].exists, " Offer for this address already exists");
Offer memory paymentStruct = Offer({
exists: true,
ethDepositInWei: msg.value,
bitcoinWithdrawAmount: _bitcoinWithdrawAmount,
potentialPayoutAddress: uint80(0)
});
deposit[_bitcoinAddress] = paymentStruct;
}
//2. Here the actual API query is sent to the Oracle
function getTransaction(string _txHash, string _bitcoinAddress) payable {
require(deposit[_cryptoAddress].exists, "No Offer for this addrepragma solidity ^0.4.25;
contract DecentralizationSmartGames{
using SafeMath for uint256;
string public constant name = "Decentralization Smart Games";
string public constant symbol = "DSG";
uint8 public constant decimals = 18;
uint256 public constant tokenPrice = 0.00065 ether;
uint256 public totalSupply; /* Total number of existing DSG tokens */
uint256 public divPerTokenPool; /* Trigger for calculating dividends on "Pool dividends" program */
uint256 public divPerTokenGames; /* Trigger for calculating dividends on "Games dividends" program */
uint256 public developmentBalance; /* Balance that is used to support the project and games development */
uint256 public charityBalance; /* Balance that is used for charity */
address[2] public owners; /* Addresses of the contract owners */
address[2] public candidates; /* Addresses of the future contract owners */
/**structFee public fee - Structure where all percentages of the _distribution of incoming fpragma solidity ^0.4.25;
contract DecentralizationSmartGames{
using SafeMath for uint256;
string public constant name = "Decentralization Smart Games";
string public constant symbol = "DSG";
uint8 public constant decimals = 18;
uint256 public constant tokenPrice = 0.00065 ether;
uint256 public totalSupply; /* Total number of existing DSG tokens */
uint256 public divPerTokenPool; /* Trigger for calculating dividends on "Pool dividends" program */
uint256 public divPerTokenGames; /* Trigger for calculating dividends on "Games dividends" program */
uint256 public developmentBalance; /* Balance that is used to support the project and games development */
uint256 public charityBalance; /* Balance that is used for charity */
address[2] public owners; /* Addresses of the contract owners */
address[2] public candidates; /* Addresses of the future contract owners */
/**structFee public fee - Structure where all percentages of the _distribution of incoming fpragma solidity >=0.4.22 <0.7.0;
/*
1. deploy Factory
2. call Factory.deployTarget()
3. call getAddr(0);
4. call getAddrWithAddr(deployer_address, 0);
5. compare 3 address
a. events from step 2
b. output[12:] from step 3
c. output[12:] from step 4
*/
contract Target {
address public owner;
constructor() public {
owner = msg.sender;
}
function foo() public pure returns (string memory) {
return "foo()";
}
}
contract Factory {
uint public salt;
address public owner;
constructor() public {
owner = msg.sender;
}
event Deployed(address addr, uint256 salt);
function deployTarget() public {
bytes memory code = type(Target).creationCode;
address addr;
uint _salt = salt;
assembly {
addr := create2(0, add(code, 0x20), mload(code), _salt)
if iszero(extcodesize(addr)) {
revert(0, 0)
}
}
emit Deployed(addr//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.5.5;
contract SimpleStore {
function set(uint _value) public {
value = _value;
}
function get() public constant returns (uint) {
return value;
}
uint value;
/**
* @dev Returns the current min_deposit of the given entry, using
* depositDecayFunction to compute the ratio of remaining min_deposit
* based on how long the entry has been listed.
*/
function currentMinDeposit(bytes32 entryData)
public
view
entryMustExist(entryData)
returns (uint256)
{
Entry storage entry = entries[entryData];
uint256 minDeposit = get("min_deposit");
if (now < entry.listedAt) {
return minDeposit;
} else {
return (minDeposit.mul(
depositDecayFunction.calculate(now.sub(entry.listedAt)))
).div(DENOMINATOR);
}
pragma solidity ^0.4.24;
contract Votacion {
modifier onlyOwner() {
require(isOwner(msg.sender));
_;
}
uint public voteStartTime;
uint public voteEndTime;
uint16 private voterCount;
string public votingTitle;
address public owner;
uint16 public accountedVotes;
uint16 public nulledVotes;
uint16 public votesRemaining;
event Voted (bytes24 _token);
event newVoterId (uint _voterId);
event voteAccounted (bytes32 _candidateName, uint _votesReceived, uint16 _totalVotesAccounted);
event voteNulled (uint16 _voterId, uint16 _totalVotesAccounted);
mapping (bytes32 => uint16) private votesReceived;
mapping (bytes32 => bool) public votesCasted;
mapping (uint8 => string) public candidateNames1;
mapping (uint8 => string) public candidateNames2;
mapping (uint16 => string) public voterIndex;
mapping (string => bool) internal voterIds;
bytes32[] private candidateList1;
bytes32[] private candidateList2;
pragma solidity ^0.4.24;
contract Votacion {
modifier onlyOwner() {
require(isOwner(msg.sender));
_;
}
uint public voteStartTime;
uint public voteEndTime;
uint16 private voterCount;
string public votingTitle;
address public owner;
uint16 public accountedVotes;
uint16 public nulledVotes;
uint16 public votesRemaining;
event Voted (bytes24 _token);
event newVoterId (uint _voterId);
event voteAccounted (bytes32 _candidateName, uint _votesReceived, uint16 _totalVotesAccounted);
event voteNulled (uint16 _voterId, uint16 _totalVotesAccounted);
//event testhash (bytes32 hash);
mapping (bytes32 => uint16) private votesReceived;
mapping (bytes32 => bool) public votesCasted;
mapping (uint8 => string) public candidateNames1;
mapping (uint8 => string) public candidateNames2;
mapping (uint16 => string) public voterIndex;
mapping (string => bool) internal voterIds;
bytes32[] private candidateLispragma solidity ^0.4.25;
contract DecentralizationSmartGames{
using SafeMath for uint256;
string public constant name = "Decentralization Smart Games";
string public constant symbol = "DSG";
uint8 public constant decimals = 18;
uint256 public constant tokenPrice = 0.00065 ether;
uint256 public totalSupply; /* Total number of existing DSG tokens */
uint256 public divPerTokenPool; /* Trigger for calculating dividends on "Pool dividends" program */
uint256 public divPerTokenGames; /* Trigger for calculating dividends on "Games dividends" program */
uint256 private developmentBalance; /* Balance that is used to support the project and games development */
uint256 private charityBalance; /* Balance that is used for charity */
address[2] private owners; /* Addresses of the contract owners */
address[2] public candidates; /* Addresses of the future contract owners */
/**structFee public fee - Structure where all percentages of the distribution of incoming//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.5.4;
contract SimpleStore {
function set(uint _value) public {
value = _value;
}
function get() public constant returns (uint) {
return value;
}
uint value;
pragma solidity ^0.4.25;
contract DecentralizationSmartGames{
using SafeMath for uint256;
string public constant name = "Decentralization Smart Games";
string public constant symbol = "DSG";
uint8 public constant decimals = 18;
uint256 public constant tokenPrice = 0.00065 ether;
uint256 public totalSupply; /* Total number of existing DSG tokens */
uint256 public divPerTokenPool; /* Trigger for calculating dividends on "Pool dividends" program */
uint256 public divPerTokenGames; /* Trigger for calculating dividends on "Games dividends" program */
uint256 private developmentBalance; /* Balance that is used to support the project and games development */
uint256 private charityBalance; /* Balance that is used for charity */
address[2] private owners; /* Addresses of the contract owners */
address[2] public candidates; /* Addresses of the future contract owners */
/**structFee public fee - Structure where all percentages of the distribution of incoming