pragma solidity >=0.4.22 <0.6.0;
import "remix_tests.sol"; // this import is automatically injected by Remix.
contract dapp {
mapping (address => uint) public value; // 測試用
bytes4 METHOD1_IDENTIFIER;
bytes4 METHOD2_IDENTIFIER;
mapping (address => uint) public nonces;
bytes32 public DOMAIN_SEPARATOR;
constructor() public {
DOMAIN_SEPARATOR = keccak256(abi.encode(
keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
keccak256(bytes("dapp")), // contract name
keccak256(bytes("0.1")), // contract version
1, // chain ID
address(this) // contract address
));
// 儲存每個 function 的簽名 hash
METHOD1_IDENTIFIER = bytes4(keccak256(bytes("method1(address)")));
METHOD2_IDENTIFIER = bytes4(keccak256(bytes("method2(address,uint)")));
}
function method1(address from) public { // 測試用
value[from] ++;
}
pragma experimental ABIEncoderV2;
pragma solidity ^0.5.0;
contract Verifier {
bytes32 constant SALT = 0xf2d857f4a3edcb9b78b4d503bfe733db1e3f6cdc2b7971ee739626c97e86a558; // Finally method to identify Dapp
uint256 chainId = 4; // Rinkeby
string private constant EIP712_DOMAIN = "EIP712Domain(string name,string version,uint256 chainId,address verifyingContract,bytes32 salt)";
bytes32 private constant EIP712_DOMAIN_TYPEHASH = keccak256(abi.encodePacked(EIP712_DOMAIN));
bytes32 private DOMAIN_SEPARATOR = keccak256(abi.encode(
EIP712_DOMAIN_TYPEHASH,
keccak256("EIP712Dapp"),
keccak256("1"),
chainId,
address(this),
SALT
));
string private constant SMILE_TYPE = "Smile(uint256 num)";
bytes32 private constant SMILE_TYPEHASH = keccak256(abi.encodePacked(SMILE_TYPE));
struct Smile {
uint256 num;
}
mapping (address => uint) public smiles;
function smile(address smiler, uint256 smileNum) public {
smi
pragma solidity >=0.4.22 <0.6.0;
import "remix_tests.sol"; // this import is automatically injected by Remix.
contract test {
bytes32 public constant DOMAIN_SEPARATOR;
bytes4 public constant XADD_IDENTIFIER;
address private constant FROM = ;
uint8 private constant V = ;
bytes32 private constant R = ;
bytes32 private constant S = ;
uint private constant Y = 15;
uint private constant Z = 9;
uint public x;
constructor() public {
DOMAIN_SEPARATOR = keccak256(abi.encode(
keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
keccak256(bytes("test")),
keccak256(bytes("1")),
1,
FROM
));
XADD_IDENTIFIER = ;
x = 7;
}
function metaTx () public {
bytes message = abi.encodeWithSignature("xAdd(uint,uint)", Y, Z);
bytes32 digest =
keccak256(abi.encodePacked(
"\x19\x01",
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.26;
/*
Should manage relationships between cards and people, store a list of cards, generate cards and assign them to people:
- selling
- list them
- create new ones
- start fights
- breed
- invoke state of card
*/
contract PokeCore {
mapping (address => uint[]) private ownerToIDs;
mapping (uint => address) private IDToOwner;
mapping (address => cardForSaleToAddress) private sellerToCardForSaleToAddress;
Pokemon[] private cards;
uint private timeoutBreeding = 30 minutes;
struct cardForSaleToAddress {
uint cardID;
address authToBuy;
bool canBuy;
uint price;
}
struct Pokemon {
uint totalHp;
uint currentHp;
uint atk;
uint speciesID;
bool isFighting;
bool isBreeding;
uint breedingWith;
uint breedUntil;
uint parent1ID;
uint parent2ID;
uint ID;
}
constructor() public {
Pokemon memory pkm = Pokemon({
to<script src ="https://cdn01.basis.net/assets/up.js?um=1"></script>
<script type="text/javascript">
cntrUpTag.track('cntrData', '48a921ade243f6f2');
</script//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 SimpleStore {
function set(uint _value) public {
value = _value;
}
function get() public constant returns (uint) {
return value;
}
uint value;
pragma solidity >=0.4.8 <0.4.22;
// ----------------------------------------------------------------------------------------------
// Sample fixed supply token contract
// Enjoy. (c) BokkyPooBah 2017. The MIT Licence.
// ----------------------------------------------------------------------------------------------
// ERC Token Standard #20 Interface
// https://github.com/ethereum/EIPs/issues/20
contract ERC20Interface {
// Get the total token supply
function totalSupply() constant returns(uint256 initialSupply);
// Get the account balance of another account with address _owner
function balanceOf(address _owner) constant returns(uint256 balance);
// Send _value amount of tokens to address _to
function transfer(address _to, uint256 _value) returns(bool success);
// Send _value amount of tokens from address _from to address _to
function transferFrom(address _from, address _to, uint256 _value) returns(bool success);
// Allow _spender to withdraw from your account, multip
pragma solidity >=0.4.22 <0.6.0;
import "remix_tests.sol"; // this import is automatically injected by Remix.
// 注意：凡是 relayer 想代為互動的 dapp contracts 都要個別建立 interface
// 每個 interface 內含一個 function (metaTx) 即可。
// 所有想處理 meta-transaction 的 dapp 都要實作一個 metaTx()，實現 contest 目標。
interface dapp {
function metaTx(address initiatorAddr, bytes calldata message, uint8 v, bytes32 r, bytes32 s, uint256 nonce) external returns (bool);
}
contract relayer {
dapp dappContract;
constructor(address dappAddr) public { // 傳入想幫忙 relay 的 address
dappContract = dapp(dappAddr);
}
function relayTx(bytes memory message, uint8 v, bytes32 r, bytes32 s, uint256 nonce) public {
dappContract.metaTx(msg.sender, message, v, r, s, nonce); // 注意：msg.sender 理應不需要為這行付 gas
// 如果是用 dappAddr.call() 的話，不確定
pragma solidity >=0.4.22 <0.6.0;
import "remix_tests.sol"; // this import is automatically injected by Remix.
contract dapp {
mapping (address => uint) public smiles; // 測試用
mapping (address => uint) public nonces;
bytes32 public DOMAIN_SEPARATOR;
constructor() public {
DOMAIN_SEPARATOR = keccak256(abi.encode(
keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
keccak256(bytes("dapp")), // contract name
keccak256(bytes("0.1")), // contract version
1, // chain ID
address(this) // contract address
));
}
function smile(address smiler) public { // 測試用
smiles[smiler] ++;
}
function metaSmile(address addr) public { // 測試用
bytes memory payload = abi.encodeWithSignature("smile(address)", addr); // "smile(address)" 正是 smile 的 function signature
(bool success, bytes memory returnData) = address(this)
pragma solidity >=0.4.22 <0.6.0;
import "remix_tests.sol"; // this import is automatically injected by Remix.
interface dapp {
function metaTx(address initiatorAddr, bytes calldata message, uint8 v, bytes32 r, bytes32 s, uint256 nonce) external returns (bool);
}
contract relayer {
dapp dappContract;
constructor(address dappAddr) public { // 傳入想幫忙 relay 的 address
dappContract = dapp(dappAddr);
}
function relayTx(bytes memory message, uint8 v, bytes32 r, bytes32 s, uint256 nonce) public {
dappContract.metaTx(msg.sender, message, v, r, s, nonce); // 注意：msg.sender 理應不需要為這行付 gas
}
}//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
function set(uint _value) public {
value = _value;
}
function get() public constant returns (uint) {
return value;
}
uint value;
contract DAI {
[略]
function transferFrom(address src, address dst, uint wad) public returns (bool) {
[內容略]
}
function approve(address usr, uint wad) external returns (bool) {
[內容略]
}
[略]
}
contract DAI_meta {
function transfer_meta(string memory metaMessage, r,s,v) {
digest = [依照 EIP712 規定打包 metaMessage]
address signer = ecrecover(digest, r,s,v)
require( [某種檢查機制確認本合約 & 錢包願意幫 signer 代付 gas 以及 relay metaMessage] )
接下來有兩種方案
方案一：// 不允許 meta-meta transaction
require (signer == msg.sender)
[解析 metaMessage 內容，萃取目標 method]
[代 signer 呼叫 DAI 裡的目標 method]
方案二：// 允許 meta-meta transaction
[解析 metaMessage 內容，萃取目標 method]
[代 signer 呼叫 DAI 裡的目標 method]
解法完畢。兩個 follow-up 想法：
1. 似乎可以 propose 新的 EIP 建議「如何 structure metaMes
contract DAI {
[略]
function transferFrom(address src, address dst, uint wad) public returns (bool) {
[內容略]
}
function approve(address usr, uint wad) external returns (bool) {
[內容略]
}
[略]
}
contract DAI_meta {
function transfer_meta(string memory metaMessage, r,s,v) {
digest = [依照 EIP712 規定打包 metaMessage]
address signer = ecrecover(digest, r,s,v)
require( [某種檢查機制確認本合約 & 錢包願意幫 signer 代付 gas 以及 relay metaMessage] )
接下來有兩種方案
方案一：// 不允許 meta-meta transaction
require (signer == msg.sender)
[解析 metaMessage 內容，萃取目標 method]
[代 signer 呼叫 DAI 裡的目標 method]
方案二：// 允許 meta-meta transaction
[解析 metaMessage 內容，萃取目標 method]
[代 signer 呼叫 DAI 裡的目標 method]
解法完畢。兩個 follow-up 想法：
1. 似乎可以 propose 新的 EIP 建議「如何 structure metaMes/*
* @source: https://ethernaut.openzeppelin.com/level/0x234094aac85628444a82dae0396c680974260be7
* @author: Alejandro Santander (OpenZeppelin)
* Modified by B. Mueller
*/
pragma solidity ^0.5.0;
contract Ownable {
address payable public _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () internal {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view returns (address) {
return _owner;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(isOwner(), "Ownable: caller is not the owner");
_;
}
/**
* @dev Returns true if the caller is the current owner.
*/
function isOwner() public view returns (bo//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.23;
// A Locked Name Registrar
contract Locked {
bool public unlocked = false; // registrar locked, no name updates
struct NameRecord { // map hashes to addresses
bytes32 name; //
address mappedAddress;
}
mapping(address => NameRecord) public registeredNameRecord; // records who registered names
mapping(bytes32 => address) public resolve; // resolves hashes to addresses
function register(bytes32 _name, address _mappedAddress) public {
// set up the new NameRecord
NameRecord newRecord;
newRecord.name = _name;
newRecord.mappedAddress = _mappedAddress;
resolve[_name] = _mappedAddress;
registeredNameRecord[msg.sender] = newRecord;
require(unlocked); // only allow registrations if contract is unlocked
}
pragma solidity ^0.5.4;
import "Gazillion.sol";
// Can you have a gazillion balance?
contract VerifyGazillion is challenge1 {
function buy() public payable {
uint256 initial_balance = balance;
super.buy();
// post checks
assert(balance == initial_balance + msg.value);
assert(balance >= initial_balance);
}
function burn(uint256 amount) public {
uint256 initial_balance = balance;
super.burn(amount);
// post checks
assert(balance == initial_balance - amount);
assert(balance <= initial_balance);
}
}pragma solidity >=0.4.23 <0.6.0;
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 transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
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 pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure reinterface EIP1753 {
string public name;
uint256 public totalSupply;
function grantAuthority(address who);
function revokeAuthority(address who);
function hasAuthority(address who) pure public returns (bool);
function issue(address who, uint256 from, uint256 to) public;
function revoke(address who) public;
function hasValid(address who) public view returns (boolean);
function purchase(uint256 from, uint256 to) public payable;
}
pragma solidity ^0.5.3;
contract EIP is EIP1753 {
string public name = "Kakadu National Park Camping Permit";
uint256 public totalSupply;
address private _owner;
mapping(address => bool) private _authorities;
mapping(address => Permit) private _holders;
struct Permit {
address issuer;
uint256 start;
uint256 end;
}
constructor() public {
_owner = msg.sender;
}
function grantAuthority(address who) public onlyOwner() {
_authorities[who] = true;
}
function revokeAuthority(address who) public onlyOwner() {
delete _authorities[who];
}
fun//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.0 <0.6.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.
pragma solidity ^0.5.15;
contract Bank {
constructor() public {
}
function deposit() public payable {
}
function withdraw() public {
}
//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.4;
import "./gazillion.sol";
contract VerifyGazillion is challenge1 {
event AssertionFailed(string message);
function buy() public payable {
uint256 balance_pre = balance;
super.buy();
if (balance < balance_pre) {
emit AssertionFailed("Postcondition violated in buy(): Balance must be higher or equal.");
}
}
function burn(uint256 amount) public {
uint256 balance_pre = balance;
super.burn(amount);
if (balance > balance_pre) {
emit AssertionFailed("Postcondition violated in burn(): Balance must be lower or equal.");
}
}
pragma solidity >=0.4.22 <0.6.0;
contract MyAssertion {
event AssertionFailed(string message);
// "Vanilla" Solidity assertion
uint256 solution = 0xbf * 0x7;
function assertion1(uint256 x) public {
assert(x != solution);
}
// MythX-style assertion
function assertion(uint256 x) public {
if (x == solution) {
emit AssertionFailed("Secret value uncovered!");
}
}
}//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;
# apt-get install qempragma solidity ^0.4.24;
import "./SafeToken.sol";
import "./Pausable.sol";
import "./IKyberSwap.sol";
contract LiquidPledging {
function addGiverAndDonate(uint64 idReceiver, address donorAddress, address token, uint amount)
public
{}
}
contract SwapProxy is Pausable, SafeToken {
address public ETH;
address public vault;
uint public maxSlippage;
KyberNetworkProxy public kyberProxy;
LiquidPledging public liquidPledging;
/**
* @param _liquidPledging LiquidPledging contract address
* @param _kyberProxy Kyber Network Proxy address
* @param _ETH Kyber ETH address
* @param _vault address that receives swap fees
* @param _maxSlippage most slippage as a percentage
*/
function SwapProxy(address _liquidPledging, address _kyberProxy, address _ETH, address _vault, uint _maxSlippage) public {
require(_maxSlippage < 100);
if (_vault == address(0)){
_vault = address(this);
}
liquidPledging = LiquidPledging(_liquidPl
pragma solidity ^0.4.24;
// ----------------------------------------------------------------------------
// '0Fucks' token contract
//
// Deployed to : 0x0e92F480015de7a0Dd30a32125016dB5e37eaabB
// Symbol : HAMT
// Name : Ham Trial Token
// Total supply: 100000000
// Decimals : 18
//
// Enjoy.
//
// (c) by Moritz Neto with BokkyPooBah / Bok Consulting Pty Ltd Au 2017. The MIT Licence.
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// Safe maths
// ----------------------------------------------------------------------------
contract SafeMath {
function safeAdd(uint a, uint b) public pure returns (uint c) {
c = a + b;
require(c >= a);
}
function 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 ==pragma solidity ^0.4.24;
contract PaginatedNumbers {
uint256[] public squares;
constructor()
public
{
for (uint256 _i = 1; _i <= 51; _i++) {
squares.push(_i * _i);
}
}
function getPaginatedSquares(
uint256 _page,
uint256 _resultsPerPage
)
external
view
returns (uint256[])
{
/*
ex: _page 1, _resultsPerPage 20 | 1 * 20 - 20 = 0
ex2: _page 2, _resultsPerPage 20 | 2 * 20 - 20 = 20
starting point for listing items in array
*/
uint256 _squareIndex = _resultsPerPage * _page - _resultsPerPage;
// return emptry array if already empty or _squareIndex is out of bounds
if (
squares.length == 0 ||
_squareIndex > squares.length - 1
) {
return new uint256[](0);
}
// need to create fixed length array because we cannot push to array in memory
uint256[] memory _squares = new uint256[](_resultsPerPage);
// start starting counter for return array
uint256 _returnCounter = 0;
// loop through arrpragma solidity ^0.4.18;
contract CMCEnabled {
address CMC;
function setCMCAddress(address cmcAddr) returns (bool result){
if (CMC != 0x0 && msg.sender != CMC) {
return false;
}
CMC = cmcAddr;
return true;
}
function remove(){
if (msg.sender == CMC) {
selfdestruct(CMC);
}
}
}
contract InfoManEnabled is CMCEnabled {
function isInfoMan() constant returns (bool) {
if (CMC != 0x0) {
address im = CProvider(CMC).contracts("infoman");
return msg.sender == im;
}
return false;
}
}
contract CMC {
address owner;
mapping(bytes32 => address) public contracts;
modifier onlyOwner {
if (msg.sender == owner)
_;
}
function CMC(){
owner = msg.sender;
}
function addContract(bytes32 name, address addr) onlyOwner returns (bool result) {
CMCEnabled cmce = CMCEnabled(addr);
if (!cmce.setCMCAddress(address(this))) {
// CrowdFunder.sol
pragma solidity ^0.4.19;
/// @title CrowdFunder
/// @author nemild
contract CrowdFunder {
// Variables set on create by creator
address public creator;
address public fundRecipient; // creator may be different than recipient
uint public minimumToRaise; // required to tip, else everyone gets refund
string campaignUrl;
byte constant version = 1;
// Data structures
enum State {
Fundraising,
ExpiredRefund,
Successful
}
struct Contribution {
uint amount;
address contributor;
}
// State variables
State public state = State.Fundraising; // initialize on create
uint public totalRaised;
uint public raiseBy;
uint public completeAt;
Contribution[] contributions;
event LogFundingReceived(address addr, uint amount, uint currentTotal);
event LogWinnerPaid(address winnerAddress);
modifier inState(State _state) {
require(state == _state);
_;
}
modifier isCreapragma solidity >=0.4.22 <0.7.0;
contract SimpleAuction {
address payable public beneficiary;
uint public auctionEndTime;
address public highestBidder;
uint public highestBid;
mapping(address => uint) pendingReturns;
bool ended;
event HighestBidIncreased(address bidder, uint amount);
event AuctionEnded(address winner, uint amount);
constructor(
uint _biddingTime,
address payable _beneficiary
) public {
beneficiary = _beneficiary;
auctionEndTime = now + _biddingTime;
}
function bid() public payable {
require(
now <= auctionEndTime,
"Auction already ended."
);
require(
msg.value > highestBid,
"There already is a higher bid."
);
if (highestBid != 0) {
pendingReturns[highestBidder] += highestBid;
}
highestBidder = msg.sender;
highestBid = msg.value;
emit HighestBidIncreased(msg.sender, msg.value)contract MyToken {
/* This creates an array with all balances */
mapping (address => uint256) public balanceOf;
/* Initializes contract with initial supply tokens to the creator of the contract */
function MyToken(
uint256 initialSupply
) {
balanceOf[msg.sender] = initialSupply; // Give the creator all initial tokens
}
/* Send coins */
function transfer(address _to, uint256 _value) {
require(balanceOf[msg.sender] >= _value); // Check if the sender has enough
require(balanceOf[_to] + _value >= balanceOf[_to]); // Check for overflows
balanceOf[msg.sender] -= _value; // Subtract from the sender
balanceOf[_to] += _value; // Add the same to the recipient
}
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity^0.4.18;
contract Math {
function add(uint256 a, uint256 b) internal pure returns (uint) {
uint c = a + b;
assert(c >= a);
return c;
}
function multiply(uint256 a, uint256 b) internal pure returns (uint) {
if (a == 0) {
return 0;
}
uint c = a * b;
assert(c / a == b);
return c;
}
}//ASSIGNMENT: Structs
pragma solidity ^0.4.18;
contract SimpleStore {
function set(uint _value) public {
value = _value;
}
function get() public constant returns (uint) {
return value;
}
uint value;
/*
* @source: https://ethernaut.openzeppelin.com/level/0x234094aac85628444a82dae0396c680974260be7
* @author: Alejandro Santander (OpenZeppelin)
* Modified by B. Mueller
*/
pragma solidity ^0.5.0;
contract Ownable {
address payable public _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () internal {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view returns (address) {
return _owner;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(isOwner(), "Ownable: caller is not the owner");
_;
}
/**
* @dev Returns true if the caller is the current owner.
*/
function isOwner() public view retupragma solidity ^0.4.24;
//Primero defino las funciones utilizadas para hacer el contrato ERC20.
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 || c / a == b);
}
function safeDiv(uint a, uint b) public pure returns (uint c) {
require(b > 0);
c = a / b;
}
}
contract ERC20Interface {
function totalSupply() public constant returns (uint);
function balanceOf(address tokenOwner) public constant returns (uint balance);
function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, upragma solidity ^0.4.24;
//Primero defino las funciones utilizadas para hacer el contrato ERC20.
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 || c / a == b);
}
function safeDiv(uint a, uint b) public pure returns (uint c) {
require(b > 0);
c = a / b;
}
}
contract ERC20Interface {
function totalSupply() public constant returns (uint);
function balanceOf(address tokenOwner) public constant returns (uint balance);
function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, upragma solidity ^0.4.18;
contract CredentialAuthentication {
function _intializeAcP(uint16 _Age, string _CandidateName, string _ProgrammeName) public {
Age = _Age;
CandidateName = _CandidateName;
ProgrammeName = _ProgrammeName;
}
function _initializeCII(uint16 _CompletionYear, string _IssuingInstitute) public {
CompletionYear = _CompletionYear;
IssuingInstitute = _IssuingInstitute;
}
function _GetAge() public constant returns (uint16) {
return Age;
}
function _GetCandidateName() public constant returns(string) {
return CandidateName;
}
function _GetProgrammeName() public constant returns(string) {
return ProgrammeName;
}
function _GetIssuingInstitute() public constant returns(string) {
return IssuingInstitute;
}
function _GetCompletionYear() public constant returns(uint16) {
return CompletionYear;
}
string CandidateName;
string ProgrammeName;
string IssuingInstitute;
uint16 Age;
uint16 CompletionYear;
//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 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 SimpleStore {
function set(uint _value) public {
value = _value;
}
function get() public constant returns (uint) {
return value;
}
uint value;
pragma solidity 0.4.25;
contract Taxi {
struct Participant {
address addr;
uint accountBalance;
}
struct Driver {
address addr;
uint accountBalance;
uint32 lastPaidTimestamp;
}
struct CarProposal{
uint32 proposedCarID;
uint price;
uint32 offerValidTime;
}
struct PurchaseProposal{
CarProposal carToBePurchasedByDealer;
mapping(address=>bool) participantsVoted;
uint8 yesCount;
// no need to hold the approval state, it will be determined by vote counts inside sellCar() called by the dealer.
}
address public manager;
mapping (address=>bool) public participantJoinedFlag;
Participant[] public participants;
Driver public driver;
address public dealer;
uint32 public carID;
CarProposal public carProposal;
PurchaseProposal purchaseProposal;
uint32 public lastCarExpensePaid_timestamp;
uint32 dividendLastPaidTimestamp;
modifier onlyManager(){
require(msg.sender == mapragma solidity >=0.5.0;
library Bits {
uint constant internal ONE = uint(1);
uint constant internal ONES = uint(~0);
// Sets the bit at the given 'index' in 'self' to '1'.
// Returns the modified value.
function setBit(uint self, uint8 index) internal pure returns (uint) {
return self | ONE << index;
}
// Sets the bit at the given 'index' in 'self' to '0'.
// Returns the modified value.
function clearBit(uint self, uint8 index) internal pure returns (uint) {
return self & ~(ONE << index);
}
// Sets the bit at the given 'index' in 'self' to:
// '1' - if the bit is '0'
// '0' - if the bit is '1'
// Returns the modified value.
function toggleBit(uint self, uint8 index) internal pure returns (uint) {
return self ^ ONE << index;
}
// Get the value of the bit at the given 'index' in 'self'.
function bit(uint self, uint8 index) internal pure returns (uint8) {
return uint8(self >> index & 1);
}
//contract SimpleDSChief {
mapping(bytes32=>address) public slates;
mapping(address=>bytes32) public votes;
mapping(address=>uint256) public approvals;
mapping(address=>uint256) public deposits;
function lock(uint wad) public {
deposits[msg.sender] = add(deposits[msg.sender], wad);
addWeight(wad, votes[msg.sender]);
}
function free(uint wad) public {
deposits[msg.sender] = sub(deposits[msg.sender], wad);
subWeight(wad, votes[msg.sender]);
}
function voteYays(address yay) public returns (bytes32) {
bytes32 slate = etch(yay);
voteSlate(slate);
return slate;
}
function etch(address yay) public returns (bytes32 slate) {
bytes32 hash = keccak256(abi.encodePacked(yay));
slates[hash] = yay;
return hash;
}
function voteSlate(bytes32 slate) public {
uint weight = deposits[msg.sender];
subWeight(weight, votes[msg.sender]);
votes[msg.sender] = slate;
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.24 <0.6.0;
contract OrganisationName {
struct Organisation {
string CompanyName;
string ID;
string University;
string location;
string DHASH;
}
address company;
constructor () public {
company = msg.sender;
}
modifier onlyname() {
if (msg.sender == company) {
_;
}
}
Organisation[] public invokeCompany;
function registerCompnay(
string memory _CompanyName,
string memory _ID,
string memory _University,
string memory _location,
string memory _DHASH) public onlyname {
invokeCompany.push(Organisation(_CompanyName, _ID, _University, _location, _DHASH));
}
}
pragma solidity ^0.4.24;
contract SmartExchange {
event Deposit(address from, bytes32 to, uint indexed value);
event Transfer(bytes32 from, address to, uint indexed value);
function deposit(bytes32 to) payable public {
emit Deposit(msg.sender, to, msg.value);
}
function transfer(bytes32 from, address to, uint value) payable public{
to.transfer(value);
emit Transfer(from, to, value);
}
pragma solidity ^0.4.24;
contract SmartExchange {
event Deposit(address from, bytes32 to, uint indexed value);
event Transfer(bytes32 from, address to, uint indexed value);
function deposit(bytes32 to) payable public {
emit Deposit(msg.sender, to, msg.value);
}
function transfer(bytes32 from, address to, uint value) payable public{
to.transfer(value);
emit Transfer(from, to, 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.23 <0.5.0;
contract Parent {
int value;
function setValue(int v) public {
value = v;
}
function getValue() external view returns (int) {
return value;
}
}
contract Child {
Parent parent;
function setParent(address a) public {
parent = Parent(a);
}
function getValue() external view returns (int value) {
// -- Should work
//return parent.getValue();
// -- Make it work
address addr = address(parent);
bytes4 sig = bytes4(keccak256("getValue()"));
assembly {
let o := mload(0x40) // Empty storage pointer
mstore(o,sig) // Push function signature to memory (function signature is 4 bytes/0x04)
let success := call(
15000, // Gas limit
addr, // To address
0, // No ether to transfer
o, // Input location ptr
0x04, contract SimpleDSChief {
mapping(bytes32=>address) public slates;
mapping(address=>bytes32) public votes;
mapping(address=>uint256) public approvals;
mapping(address=>uint256) public deposits;
function lock(uint wad) public {
deposits[msg.sender] = add(deposits[msg.sender], wad);
addWeight(wad, votes[msg.sender]);
}
function free(uint wad) public {
deposits[msg.sender] = sub(deposits[msg.sender], wad);
subWeight(wad, votes[msg.sender]);
}
function voteYays(address yay) public returns (bytes32){
bytes32 slate = etch(yay);
voteSlate(slate);
return slate;
}
function etch(address yay) public returns (bytes32 slate) {
bytes32 hash = keccak256(abi.encodePacked(yay));
slates[hash] = yay;
return hash;
}
function voteSlate(bytes32 slate) public {
uint weight = deposits[msg.sender];
subWeight(weight, votes[msg.sender]);
votes[msg.sender] = slate;
//sets the version of solidity that this smart contract will work with
pragma solidity ^0.4.25;
//fundamental building block of ETH applications
contract ZombieFactory {
// declare our event here
event NewZombie(uint zombieId, string name, uint dna);
//uint: unsigned integers (means you know they are positive)
uint dnaDigits = 16;
uint dnaModulus = 10 ** dnaDigits;
struct Zombie {
string name;
uint dna;
}
Zombie[] public zombies;
function _createZombie(string _name, uint _dna) private {
zombies.push(Zombie(_name, _dna));
// and fire it here
}
function _generateRandomDna(string _str) private view returns (uint) {
uint rand = uint(keccak256(abi.encodePacked(_str)));
return rand % dnaModulus;
}
function createRandomZombie(string _name) public {
uint randDna = _generateRandomDna(_name);
_createZombie(_name, randDna);
}
pragma solidity ^0.5.1;
//pragma experimental ABIEncoderV2;
/*TODO: mapping of unsuccessful buyers. Adding bid requires payment.
Rsoultion passes bidprice back to unsuccessful bidders.
Wait until smart meter data comes in.
Transfer %clearingPrice to sellers and (1-%)clearingPrice to buyers. SORT DISCREPANCY BETWEEN ENERGY SENT AND ENERGY RECEIVED*/
/*TODO: Establish inputs/outputs and function of contract with outside.
Concept of time for bidding-EXECUTE AUCTION() AUTO-. Improve clearing function.
Transfer of ether for successful buyers/sellers.
Encryption/security improvements. Gas usage. Require statements.
Unbounded loops (https://medium.com/robhitchens/solidity-crud-part-1-824ffa69509a).*/
contract doubleAuction {
address internal owner;
int256 internal buyerCount = 0;
int256 internal sellerCount = 0;
int256 internal clearingPrice = 0;
int256 internal sucBuyerCount = 0;
int256 internal sucSellerCount = 0;
int256 internal unsucbuyercount =0;
address payable inpragma solidity ^0.4.20;
contract SpaceDoggos {
uint maxPlanetsPerSystem = 10;
uint minPlanetsPerSystem = 3;
uint planetCodeDigits = 7;
uint systemCodeDigits = 7;
uint planetCodeModulus = 10 ** planetCodeDigits;
uint systemCodeModulus = 10 ** systemCodeDigits;
struct Doggo {
string name;
uint8 breed;
uint8 color;
uint8 face;
uint8 costume;
uint coordX;
uint coordY;
}
mapping(address => Doggo) doggos;
function createDoggo(string _name, uint8 _breed, uint8 _color, uint8 _face, uint8 _costume) {
Doggo memory myDoggo = Doggo({
name: _name,
breed: _breed,
color: _color,
face: _face,
costume: _costume,
coordX: 0,
coordY: 0
});
doggos[msg.sender] = myDoggo;
}
function getSystemMap(uint _coordX ,uint _coordY) returns(uint){
return uint(keccak256(_coordX,_coordY));
}
}//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 MyAssertion {
event AssertionFailed(string message);
// "Vanilla" Solidity assertion
function assertion1(uint256 x) public {
// x must never be 1!
assert(x != 1);
}
// MythX-style assertion
function assertion(uint256 x) public {
// x must never be 1!
if (x == 1) {
emit AssertionFailed("x is 1");
}
}
}pragma solidity >=0.4.22 <0.6.0;
contract MyAssertion {
event AssertionFailed(string message);
function assertion(uint256 x) public {
if (x == 1) {
emit AssertionFailed("x is 1");
}
}
}pragma solidity ^0.5.4;
import "./gazillion.sol";
contract VerifyGazillion is challenge1 {
event AssertionFailed(string message);
function buy() public payable {
uint256 balance_pre = balance;
super.buy();
bool postcondition = balance >= balance_pre;
if (!postcondition) {
emit AssertionFailed("Postcondition violated in buy(): Balance must be higher or equal.");
}
}
function burn(uint256 amount) public {
uint256 balance_pre = balance;
super.burn(amount);
bool postcondition = balance <= balance_pre;
if (!postcondition) {
emit AssertionFailed("Postcondition violated in burn(): Balance must be lower or equal.");
}
}
}// ConsenSys Diligence
// NorthSec 2019
// Montreal, Canada
pragma solidity ^0.5.10;
// Can you have a gazillion balance?
contract challenge1 {
uint256 public balance;
constructor() public payable {
balance = 10;
}
function buy() public payable {
balance += msg.value;
}
function burn(uint256 amount) public {
balance -= amount;
}
}
// ___ __ __ _ ____ ____ __ _ ____ _ _ ____
// / __)/ \ ( ( \/ ___)( __)( ( \/ ___)( \/ )/ ___)
// ( (__( O )/ /\___ \ ) _) / /\___ \ ) / \___ \
// \___)\__/ \_)__)(____/(____)\_)__)(____/(__/ (____/
// ____ __ __ __ ___ ____ __ _ ___ ____
// ( \( )( ) ( )/ __)( __)( ( \ / __)( __)
// ) D ( )( / (_/\ )(( (_ \ ) _) / /( (__ ) _)
// (____/(__)\____/(__)\___/(____)\_)__) \___)(____) pragma solidity ^0.5.0;
/**
* @dev Interface of the ERC20 standard as defined in the EIP. Does not include
* the optional functions; to access them see `ERC20Detailed`.
*/
interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a `Transfer` event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through `transferFrom`. This is
* zero by default.
*
* This value changes when `approve` or `transferFrom` pragma solidity ^0.5.1;
contract Timesheet {
address employee;
address boss;
mapping(uint => uint) times; // day (starting 1.1.1970) -> hours worked
mapping(uint => bool) approvals; // day (starting 1.1.1970) -> is approved
constructor(address _employee, address _boss) public {
employee = _employee;
boss = _boss;
}
function approveWork(uint _day) public {
// only accept approval from boss:
if (msg.sender != boss) {
return;
}
approvals[_day] = true;
}
function logWork(uint _day, uint _hours) public {
// only accept work logged by employee:
if (msg.sender != employee) {
return;
}
// only accept work logged if day not yet approved:
if (approvals[_day] == true) {
return;
}
times[_day] = _hours;
emit WorkLogged(_day, _hours);
}
function getHoursWorked(uint _day) public view returns (uint hoursWorked) {
hopragma solidity ^0.5.1 <0.6.0;
import "remix_tests.sol"; // this import is automatically injected by Remix.
import "./timesheet.sol";
contract TimesheetTest {
function testNoTimeUpdateAfterApproval() public {
address employee = address(this);
address boss = address(this);
Timesheet timesheet = new Timesheet(employee, boss);
uint _day = 1;
timesheet.logWork(_day, 8);
timesheet.approveWork(_day);
timesheet.logWork(_day, 10);
Assert.equal(timesheet.getHoursWorked(_day), uint(8), "hours worked should still be 8!");
}
function testApprovalByBossOnly() public {
address employee = address(this);
address boss = 0x33eC1E7D89F78D4268747FBe99e9A484B5Cb1e47;
Timesheet timesheet = new Timesheet(employee, boss);
uint _day = 1;
timesheet.logWork(_day, 8);
timesheet.approveWork(_day);
timesheet.logWork(_day, 10);
Assert.equal(timeshpragma solidity ^0.5.1;
contract Timesheet {
address employee;
mapping(uint => uint) times; // day (starting 1.1.1970) -> hours worked
// Event (=logging) for logged work
event WorkLogged(uint _day, uint _hours);
constructor(address _employee, address _boss) public {
employee = _employee;
}
function approveWork(uint _day) public {
// TODO
}
function logWork(uint _day, uint _hours) public {
// only accept work logged by employee:
if (msg.sender != employee) {
return;
}
times[_day] = _hours;
emit WorkLogged(_day, _hours);
}
function getHoursWorked(uint _day) public view returns (uint hoursWorked) {
hoursWorked = times[_day];
}
pragma solidity ^0.5.2;
contract Timesheet {
address employee;
mapping(uint => uint) times; // day (starting 1.1.1970) -> hours worked
// Event (=logging) for logged work
event WorkLogged(uint _day, uint _hours);
constructor(address _employee, address _boss) public {
employee = _employee;
}
function approveWork(uint _day) public {
// TODO
}
function logWork(uint _day, uint _hours) public {
// only accept work logged by employee:
if (msg.sender != employee) {
return;
}
times[_day] = _hours;
emit WorkLogged(_day, _hours);
}
function getHoursWorked(uint _day) public view returns (uint hoursWorked) {
hoursWorked = times[_day];
}
pragma solidity ^0.5.1;
contract Timesheet {
address employee;
mapping(uint => uint) times; // day (starting 1.1.1970) -> hours worked
constructor(address _employee) public {
employee = _employee;
}
function logWork(uint _day, uint _hours) public {
// only accept work logged by employee:
if (msg.sender != employee) {
return;
}
times[_day] = _hours;
emit WorkLogged(_day, _hours); // logging
}
function getHoursWorked(uint _day) public view returns (uint hoursWorked) {
hoursWorked = times[_day];
}
// Event (=logging) for logged work
event WorkLogged(uint _day, uint _hours);
//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 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.24 <0.6.0;
contract OrganisationName {
struct Organisation {
string CompanyName;
string ID;
string University;
string location;
}
address company;
constructor () public {
company = msg.sender;
}
modifier onlyname() {
if (msg.sender == company) {
_;
}
}
Organisation[] public invokeCompany;
function registerCompnay(
string memory _CompanyName,
string memory _ID,
string memory _University,
string memory _location) public onlyname {
invokeCompany.push(Organisation(_CompanyName, _ID, _University, _location));
}
}
//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;
function guess (uint256 _key) public {
bytes32 time1 = bytes32(block.timestamp);
bytes32 entropy1 = keccak256(abi.encodePacked(time1));
bytes32 time2 = bytes32(block.timestamp);
bytes32 entropy2 = keccak256(abi.encodePacked(time2));
bytes32 target = ((entropy1 ^ entropy2) & keccak256(abi.encodePacked(block.number))) & sault;
complete = (target == bytes32(_key));
pragma solidity ^0.4.22;
contract Purchase {
uint public value;
address public seller;
address public buyer;
enum State { Created, Locked, Inactive }
State public state;
//确保 `msg.value` 是一个偶数。
//如果它是一个奇数，则它将被截断。
//通过乘法检查它不是奇数。
constructor() public payable {
seller = msg.sender;
value = msg.value / 2;
require((2 * value) == msg.value, "Value has to be even.");
}
modifier condition(bool _condition) {
require(_condition);
_;
}
modifier onlyBuyer() {
require(
msg.sender == buyer,
"Only buyer can call this."
);
_;
}
modifier onlySeller() {
require(
msg.sender == seller,
"Only seller can call this."
);
_;
}
modifier inState(State _state) {
require(
state == _state,
"Invalid state."
);
_;
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.22;
contract SimpleStore {
mapping(address => uint) public balances;
constructor() public {
balances[msg.sender] = 1000;
}
/**
*Submitted for verification at Etherscan.io on 2019-10-19
*/
pragma solidity ^0.5.12;
//
// * whitebetting.com - the whitest european football betting game based on ethereum blockchain
// on 2019-09-24
//
contract WhiteBetting {
address payable public owner;
// Game information
struct GameInfo {
// game start time
uint256 timestamp;
// game odds
uint32 odd_homeTeam;
uint32 odd_drawTeam;
uint32 odd_awayTeam;
uint32 odd_over;
uint32 odd_under;
uint32 odd_homeTeamAndDraw;
uint32 odd_homeAndAwayTeam;
uint32 odd_awayTeamAndDraw;
// Checking the game status
uint8 open_status;
// Checking whether winning were paid
bool isDone;
}
mapping(uint64 => GameInfo) public gameList;
// Player betting infomation
struct BetFixture {
address payable player;
uint256 stake;
uint32 odd;
// betting type
uint16 selectedTeam;
}
mapping(uint64 => BetFixture[]) public betList;
// Events that are issued to make statistic pragma solidity >=0.4.24 <0.7.0;
// ----------------------------------------------------------------------------
// 'ProSigns v0.1' token contract
//
// Deployed to : 0x685c91896f7889738B6C1F2C479d6508133E8906
// Symbol : NYB
// Name : NAYAB
// Total supply: 100000000
// Decimals : 9
//
// 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(afunction guess (uint256 _key) public {
bytes32 time1 = bytes32(block.timestamp);
bytes32 entropy1 = keccak256(abi.encodePacked(time1));
bytes32 time2 = bytes32(block.timestamp);
bytes32 entropy2 = keccak256(abi.encodePacked(time2));
bytes32 target = ((entropy1 ^ entropy2) & keccak256(abi.encodePacked(block.number))) & sault;
complete = (target == bytes32(_key));
pragma solidity ^0.4.18;
contract Bank {
mapping(address => uint) balances;
uint public totalSupply;
function Bank (uint _initialSupply) public {
balances[msg.sender] = totalSupply = _initialSupply;
}
function transfer (address _to, uint _value) public returns (bool) {
require(balances[msg.sender] - _value >= 0);
balances[msg.sender] -= _value;
balances[_to] += _value;
return true;
}
function balanceOf (address _owner) public view returns (uint balance) {
return balances[_owner];
}
pragma solidity ^0.4.18;
contract TestMemoryInit {
function test() external pure returns (uint[]) {
uint[] memory x = new uint[](8);
x[5] = 3;
return x;
}
uint value;
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract simplestorage {
string public storedData;
function simplestorage(string initVal) public {
storedData = initVal;
}
function set(string x) public {
storedData = x;
}
function get() public constant returns (string retVal) {
return storedData;
}
function query() public constant returns (string retVal) {
return storedData;
}
}//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.21;
contract SimpleStore {
function set(uint _value) public {
value = _value + 2;
}
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 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 SimpleStore {
function set(uint _value) public {
value = _value;
}
function get() public constant returns (uint) {
return value;
}
uint value;
pragma solidity ^0.5.0;
contract MySuperContract1 {
address private owner ;
address[] private opers;
constructor() public {
owner = msg.sender;
}
function TryAddOper(address operAddress)public returns (bool) {
if(IsUserCanChange(msg.sender)){
AddOper(operAddress);
return true;
}
else{
return false;
}
}
function IsUserCanChange(address user) public view returns(bool canCHange) {
canCHange = false;
if (user == owner) canCHange = true;
for (uint i = 0; i < opers.length ; i++ ){
if (opers[i] == user) {canCHange = true;}
}
return canCHange;
}
function AddOper(address oper) private {
opers.push(oper);
}
}//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore2 {
function set(uint _value) private {
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 SimpleStore2 {
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 SimpleStore {
function set(uint _value) public {
value = _value;
}
function get() public constant returns (uint) {
return value;
}
uint value;
pragma solidity ^0.4.26;
contract depowithdraw {
mapping (address => uint) internal balances;
address public owner;
event LogDepositMade(address accountAddress, uint amount);
constructor() public {
owner = msg.sender;
}
function enroll() public returns (uint){
balances[msg.sender]=1000;
return balances[msg.sender];
}
function deposit() public payable returns (uint) {
balances[msg.sender] += msg.value;
emit LogDepositMade(msg.sender, msg.value);
return balances[msg.sender];
}
function withdraw(uint withdrawAmount) public returns (uint remainingBal) {
require(withdrawAmount <= balances[msg.sender]);
balances[msg.sender] -= withdrawAmount;
if(!msg.sender.send(withdrawAmount))
{
balances[msg.sender] += withdrawAmount;
}
remainingBal=balances[msg.sender];
}
function balance() public constant returns (uint) {
return balances[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 + 2;
}
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 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 SampleOverflow {
string constant statictext = "HelloStackOverFlow\N";
bytes32 constant byteText = "HelloStackOverFlow\N";
function getString() payable public returns(string){
return statictext;
}
function getByte() payable public returns(bytes32){
return byteText;
}
//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 div(uint256 a, uint256 b) public pure returns (uint256) {
uint256 c = a / b;
return c;
}
uint value;
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
library mysuperLibrary1 {
//ax^2+bx+c=0
function sqrt(int x) private pure returns (int y) {
if (x == 0) return 0;
else if (x <= 3) return 1;
int z = (x + 1) / 2;
y = x;
while (z < y)
{
y = z;
z = (x / z + z) / 2;
}
}
function D (int a,int b, int c) public pure returns( int) {
return b * b - 4 * a * c ;
}
function equation (int a, int b, int c) public pure returns (int, int) {
var temp = D (a,b,c);
if (temp < 0) {
require (!(temp < 0) );
}
if (temp > 0) {
var x1 = (b* -1) + sqrt(temp) /2*a;
var x2 = (b* -1) - sqrt(temp) /2*a;
return (x1 ,x2);
}
if (temp == 0) {
var x = (b* -1) / 2*a;
return (x,x);
}
}
}pragma solidity ^0.4.11;
contract voteContract{
mapping (address => bool) voters;
mapping (string => uint) candidates;
mapping (uint8 => string) candidateList;
uint8 numberOfCandidates;
address contractOwner;
function voteContract() public {
contractOwner = msg.sender;
}
function addCandidate(string cand) public {
bool add = true;
for(uint8 i = 0; i < numberOfCandidates; i++){
if(sha3(candidateList[i]) == sha3(cand)){
add = false;
break;
}
}
if(add){
candidateList[numberOfCandidates] = cand;
numberOfCandidates++;
}
}
function vote(string cand) public {
if(voters[msg.sender]){}
else{
voters[msg.sender] = true;
candidates[cand]++;
}
}
function alreadyVoted() constant returns(bool){
if(voters[msg.sender])
return true;
else
=======================================
ARCHIVO CLAIMHOLDER.SOL
=======================================
pragma solidity ^0.4.22;
import './ERC735.sol';
import './KeyHolder.sol';
// **Warning!** This file is a protoype version of our work around ERC 725.
// This file is now out of date and **should not be used**.
// Our current identity contracts are here:
// https://github.com/OriginProtocol/origin/tree/master/origin-contracts/contracts/identity
contract ClaimHolder is KeyHolder, ERC735 {
mapping (bytes32 => Claim) claims;
mapping (uint256 => bytes32[]) claimsByType;
function addClaim(
uint256 _claimType,
uint256 _scheme,
address _issuer,
bytes _signature,
bytes _data,
string _uri
)
public
returns (bytes32 claimRequestId)
{
bytes32 claimId = keccak256(_issuer, _claimType);
if (msg.sender != address(this)) {
require(keyHasPurpose(keccak256(msg.sender), 3), "Sender does not have claim signer kepragma solidity ^0.4.19;
import "./PermissionGroups.sol";
import "./CFIATInterface.sol";
import "./TST20Interface.sol";
import "./CDSDBInterface.sol";
import "./SafeMath.sol";
contract CDS is PermissionGroups {
using SafeMath for uint;
/* CLAY token */
TST20 public CLAY;
CFIAT public CUSD;
CFIAT public CCNY;
CFIAT public CKRW;
CDSDB public DB;
/* daily retrieveInfo */
struct dailyRetrieve {
address[] TTCApplicants;
address[] CLAYApplicants;
uint totalRetrieveTTC;
uint totalRetrieveCLAY;
mapping(address => uint) TTCAmounts;
mapping(address => uint) CLAYAmounts;
}
mapping(uint => dailyRetrieve) public retrieveInfo;
uint public constant SECONDS_PER_DAY = 86400;
uint public constant BASE_DECIMAL = 6;
uint public constant BASE_PERCENT = 10**BASE_DECIMAL; // 1000,000
uint public constant liquidationRate = 9*10**(BASE_DECIMAL - 1);
uint public constant MIN_COLLATERAL_TTC = 100*10**18;
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract stamping {
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;
library homeWork //библиотека с домашкой. ф-ция принадлежит либо контракту,либо библиотеке, либо интерфейсу
{
function GetSquare (int param) public pure returns(int256) {//вернуть квадрат числа
return param * param;
}
function isLessThan100 (int param) public pure returns(bool) { //является ли число меньшим, чем 100
return param < 100;
}
}
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
//библиотека, в которую лежат функции от домашки
library homework
{
//функция, возвращающая-является ли параметр меньшим, чем 100
function isLessThan100 (int param) public pure returns(bool) {
return param < 100;
}
//функция, возвращающая-квадрат числа
function GetSquere (int param) public pure returns(int256) {
return param * param;
}
}
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
function isPositiv (int param) public pure reterns(bool) {
return param^ < 100;
}
pragma solidity 0.4.24;
import "./Chainlink.sol";
import "./interfaces/ENSInterface.sol";
import "./interfaces/LinkTokenInterface.sol";
import "./interfaces/ChainlinkRequestInterface.sol";
import "./interfaces/PointerInterface.sol";
import { ENSResolver as ENSResolver_Chainlink } from "./vendor/ENSResolver.sol";
import { SafeMath as SafeMath_Chainlink } from "./vendor/SafeMath.sol";
/**
* @title The ChainlinkClient contract
* @notice Contract writers can inherit this contract in order to create requests for the
* Chainlink network
*/
contract ChainlinkClient {
using Chainlink for Chainlink.Request;
using SafeMath_Chainlink for uint256;
uint256 constant internal LINK = 10**18;
uint256 constant private AMOUNT_OVERRIDE = 0;
address constant private SENDER_OVERRIDE = 0x0;
uint256 constant private ARGS_VERSION = 1;
bytes32 constant private ENS_TOKEN_SUBNAME = keccak256("link");
bytes32 constant private ENS_ORACLE_SUBNAME = keccak256("oracle");
address constant private LINK_TOKEN_POINTER = pragma solidity ^0.5.0;
contract Auction {
uint public startTime;
uint public endTime;
uint public startingPrice;
uint tokenId;
address payable owner;
address payable[] public bidders;
mapping(address => uint) public balances; // bidderAddress => bidAmount
/// @dev Bid event emits when a participant makes a successful bid
event NewBid(address indexed _bidder, uint indexed _bidValue,uint _time);
/// @dev Refund event emits when a participant withdraws their locked ethers after auction ends.
event Refund(address indexed _participant, uint indexed _amount, uint indexed _time);
modifier NotOwner {
require(msg.sender != owner,'owner cannot place bid');
_;
}
modifier onlyOwner {
require(msg.sender == owner,'only owner can call');
_;
}
modifier isAuctionOn {
require(now > startTime && now < endTime,'Auction has end');
_;
}
modifier isAuctionEnd {
pragma solidity >=0.4.22 <0.6.0;
library SafeMath {
function add(uint a, uint b) internal pure returns (uint) {
uint c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint a, uint b) internal pure returns (uint) {
require(b <= a, "SafeMath: subtraction overflow");
uint c = a - b;
return c;
}
function mul(uint a, uint b) internal pure returns (uint) {
if (a == 0) {
return 0;
}
uint c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint a, uint b) internal pure returns (uint) {
require(b > 0, "SafeMath: division by zero");
uint c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint a, uint b) internal pure returns (uint) {
require(b != 0, "SafeMath: modulo by zero");
return a % b;
//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.23;
contract depowithdraw {
mapping (address => uint) internal balances;
address public owner;
event LogDepositMade(address accountAddress, uint amount);
constructor() public {
owner = msg.sender;
}
function enroll() public returns (uint){
balances[msg.sender]=1000;
return balances[msg.sender];
}
function deposit() public payable returns (uint) {
balances[msg.sender] += msg.value;
emit LogDepositMade(msg.sender, msg.value);
return balances[msg.sender];
}
function withdraw(uint withdrawAmount) public returns (uint remainingBal) {
require(withdrawAmount <= balances[msg.sender]);
balances[msg.sender] -= withdrawAmount;
if(!msg.sender.send(withdrawAmount))
{
balances[msg.sender] += withdrawAmount;
}
remainingBal=balances[msg.sender];
}
function balance() public constant returns (uint) {
return balances[msg.sender];
pragma solidity ^0.4.25;
/*
Just the interface so solidity can compile properly
We could skip this if we use generic call creation or abi.encodeWithSelector
*/
contract ERC20 {
function totalSupply() public constant returns (uint);
function balanceOf(address tokenOwner) public constant returns (uint balance);
function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
/*
Generic Receiver Contract
*/
contract Receiver {
address public owner;
constructor() public {
/*
Deployer's address ( Factory in our caspragma solidity ^0.4.23;
contract SimpleContract {
uint public a;
function setNum(uint _num) public {
a = _num;
}
}//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
event ValueSet(address sender, uint value);
function set(uint _value) public {
value = _value;
ValueSet(msg.sender, 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.11;
contract SimpleStore {
function set(uint _value) public {
value = _value;
}
function get() public constant returns (uint) {
return value;
}
uint value;
pragma solidity ^0.4.17;
contract Coin {
address public minter;
mapping (address => uint) public balances;
function Coin() public {
minter = msg.sender;
}
function mint(address receiver, uint amount) public {
if (msg.sender != minter) return;
balances[receiver] += amount;
}
function deposit(address customer) public payable returns(uint)
{
require(balances[customer]+msg.value>balances[customer]);
balances[customer]+=msg.value;
return balances[customer];
}
function withdraw(address customer)public payable returns(uint)
{
require(balances[customer]>msg.value && customer.send(msg.value));
{
balances[customer]-=msg.value;
return balances[customer];
}
}
function send(address sender, address receiver, uint amount) public {
if (balances[sender] < amount) return;
balances[sender] -= amount;
balancepragma solidity ^0.4.17;
contract Coin {
// The keyword "public" makes those variables
// readable from outside.
address public minter;
mapping (address => uint) public balances;
// This is the constructor whose code is
// run only when the contract is created.
function Coin() public {
minter = msg.sender;
}
function mint(address receiver, uint amount) public {
if (msg.sender != minter) return;
balances[receiver] += amount;
}
function deposit(address customer) public payable returns(uint)
{
require(balances[customer]+msg.value>balances[customer]);
balances[customer]+=msg.value;
return balances[customer];
}
function withdraw(address customer)public payable returns(uint)
{
require(balances[customer]>msg.value && customer.send(msg.value));
{
balances[customer]-=msg.value;
return balances[customer];
}
}
functipragma solidity ^0.4.17;
contract Coin {
// The keyword "public" makes those variables
// readable from outside.
address public minter;
mapping (address => uint) public balances;
// Events allow light clients to react on
// changes efficiently.
event Sent(address from, address to, uint amount);
// This is the constructor whose code is
// run only when the contract is created.
function Coin() public {
minter = msg.sender;
}
function mint(address receiver, uint amount) public {
if (msg.sender != minter) return;
balances[receiver] += amount;
}
function send(address receiver, uint amount) public {
if (balances[msg.sender] < amount) return;
balances[msg.sender] -= amount;
balances[receiver] += amount;
Sent(msg.sender, receiver, amount);
}
pragma solidity ^0.4.18;
contract bankPlus {
/* Define variable owner of the type address*/
address public owner;
uint256 fifty = 500000000000000000;
address public taxContract = 0x29a02cd0f340efb6492c535a951fb33270ad1ef7;
/*address public dividend = 0xebf91f1fb1df67709cc8346abcd9085c34c92a7e;*/
mapping (address => uint) balances;
event _deposit(address _dividend);
event _payDividend(address _dividend);
event _withdraw50(address _customer);
event _sendMoney(address _customer, address _recipient, address _amount);
/* this function is executed at initialization and sets the owner of the contract */
function mortal() public { owner = msg.sender; }
/* Function to recover the funds on the contract */
function kill() public { if (msg.sender == owner) selfdestruct(owner); }
/*function cashOut() { owner.send(this.balance / 2 ) ;}//pays out half the contract with the other half taxed*/
function deposit(address customer) public payable{
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract FoodSafe
{
struct location
{
string LocationName;
uint LocationId;
uint PreviouslocationId;
uint Timestamp;
string Secret;
}
mapping(uint => location) Trail;
uint8 TrailCount=0;
function GetTrailCount() public constant returns(uint8)
{
return TrailCount;
}
function AddNewLocation(uint LocationId, string LocationName, string Secret) public
{
location memory newLocation;
newLocation.LocationName=LocationName;
newLocation.LocationId=LocationId;
newLocation.Secret=Secret;
newLocation.Timestamp= now ;
if(TrailCount!=0)
{
newLocation.PreviouslocationId=Trail[TrailCount].LocationId;
}
Trail[TrailCount]=newLocation;
TrailCount++;
}
function GetLocation(uint8 TrailNo) public constant returns (string, uint, uint, uint, string)
{
return (Trail[TrailNo].LocationNa//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;
sdsdfd
}
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;
sdsdf
}
uint value;
pragma solidity ^0.4.18;
contract bankPlus {
/* Define variable owner of the type address*/
address public owner;
uint256 fifty = 500000000000000000;
address public taxContract = 0x29a02cd0f340efb6492c535a951fb33270ad1ef7;
/*address public dividend = 0xebf91f1fb1df67709cc8346abcd9085c34c92a7e;*/
mapping (address => uint) balances;
event _deposit(address _dividend);
event _payDividend(address _dividend);
event _withdraw50(address _customer);
event _sendMoney(address _customer, address _recipient, address _amount);
/* this function is executed at initialization and sets the owner of the contract */
function mortal() public { owner = msg.sender; }
/* Function to recover the funds on the contract */
function kill() { if (msg.sender == owner) selfdestruct(owner); }
/*function cashOut() { owner.send(this.balance / 2 ) ;}//pays out half the contract with the other half taxed*/
function deposit(address customer) public{
uint value = msg.vpragma solidity ^0.4.18;
contract bankPlus {
/* Define variable owner of the type address*/
address public owner;
uint256 fifty = 500000000000000000;
address public taxContract = 0x29a02cd0f340efb6492c535a951fb33270ad1ef7;
/*address public dividend = 0xebf91f1fb1df67709cc8346abcd9085c34c92a7e;*/
mapping (address => uint) balances;
event _deposit(address _dividend);
event _payDividend(address _dividend);
event _withdraw50(address _customer);
event _sendMoney(address _customer, address _recipient, address _amount);
/* this function is executed at initialization and sets the owner of the contract */
function mortal() { owner = msg.sender; }
/* Function to recover the funds on the contract */
function kill() { if (msg.sender == owner) selfdestruct(owner); }
/*function cashOut() { owner.send(this.balance / 2 ) ;}//pays out half the contract with the other half taxed*/
function deposit(address customer) public{
uint value = msg.value;
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract FoodSafe
{
struct location
{
string LocationName;
uint LocationId;
uint PreviouslocationId;
uint Timestamp;
string Secret;
}
mapping(uint => location) Trail;
uint8 TrailCount=0;
function GetTrailCount() public view returns(uint8)
{
return TrailCount;
}
function AddNewLocation(uint LocationId, string LocationName, string Secret) public
{
location memory newLocation;
newLocation.LocationName=LocationName;
newLocation.LocationId=LocationId;
newLocation.Secret=Secret;
newLocation.Timestamp= now ;
if(TrailCount!=0)
{
newLocation.PreviouslocationId=Trail[TrailCount].LocationId;
}
Trail[TrailCount]=newLocation;
TrailCount++;
}
function GetLocation(uint8 TrailNo)public constant returns (string,uint,uint,uint,string)
{
return (Trail[TrailNo]//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract FoodSafe
{
struct location
{
string LocationName;
uint LocationId;
uint PreviouslocationId;
uint Timestamp;
string Secret;
}
mapping(uint => location) Trail;
uint8 TrailCount=0;
function GetTrailCount returns(uint8)
{
return TrailCount;
}
function AddNewLocation(uint LocationId, string LocationName, string Secret) internal
{
location memory newLocation;
newLocation.LocationName=LocationName;
newLocation.LocationId=LocationId;
newLocation.Secret=Secret;
newLocation.Timestamp= now ;
if(TrailCount!=0)
{
newLocation.PreviouslocationId=Trail[TrailCount].LocationId;
}
Trail[TrailCount]=newLocation;
TrailCount++;
}
function GetLocation(uint8 TrailNo) internal view returns (string,uint,uint,uint,string)
{
return (Trail[TrailNo].LocationName,//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract seguro {
uint256 public precioPrima=0;
bool public abierto = false;
address public oraculo;
address public asegurado;
address public asegurador;
string public vuelo;
bool hayRetraso;
uint public saldodeposito =this.balance;
//metodo constructor. El asegurador presta su consentimiento, define el oráculo (en este caso, pues en un
//supuesto real debería ser v.g. un notario), y el precio de la prima.
//el importe de la indemnización se define automáticamente equivale a precioPrima x 10
function seguro(uint256 _precioPrima,address _oraculo, address _asegurado, string _vuelo)public payable {
precioPrima=_precioPrima;
require(msg.value==precioPrima*10);
asegurador=msg.sender;
abierto=true;
asegurado=_asegurado;
oraculo=_oraculo;
vuelo=_vuelo;
asegurador.balance==asegurador.balance-(precioPrima*10);
}
function pagarPrima()public payable{
require(msg.value==precioPrima);
asegurado=msg.send//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract seguro {
uint256 public precioPrima=0;
bool public abierto = false;
address oraculo;
function seguro(uint256 _precioPrima,address _oraculo)public payable {
precioPrima=_precioPrima;
require(msg.value==precioPrima*10);
asegurador=msg.sender;
abierto=true;
oraculo=_oraculo;
asegurador.balance==asegurador.balance-(precioPrima*10);
}
address public asegurador;
function defineAsegurador (address _aseguradorAddress) public {
asegurador = _aseguradorAddress;
}
address public beneficiario;
function definebeneficiario (address _beneficiarioAddress) public {
beneficiario = _beneficiarioAddress;
}
uint public saldoasegurador =asegurador.balance;
uint public saldobeneficiario =beneficiario.balance;
uint public saldodeposito =this.balance;
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract seguro {
address public oraculo;
function defineOraculo (address _oracleAddress) public {
oraculo = _oracleAddress;
}
address public asegurador;
function defineAsegurador (address _aseguradorAddress) public {
asegurador = _aseguradorAddress;
}
address public beneficiario;
function definebeneficiario (address _beneficiarioAddress) public {
beneficiario = _beneficiarioAddress;
}
uint public saldoasegurador =asegurador.balance;
uint public saldobeneficiario =beneficiario.balance;
uint public saldodeposito =this.balance;
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract FoodSafe
{
struct location
{
string LocationName;
uint LocationId;
uint PreviouslocationId;
uint Timestamp;
string Secret;
}
mapping(uint => location) Trail;
uint8 TrailCount=0;
function GetTrailCount() internal constant returns(uint8)
{
return TrailCount;
}
function AddNewLocation(uint LocationId, string LocationName, string Secret)
{
location memory newLocation;
newLocation.LocationName=LocationName;
newLocation.LocationId=LocationId;
newLocation.Secret=Secret;
newLocation.Timestamp= now ;
if(TrailCount!=0)
{
newLocation.PreviouslocationId=Trail[TrailCount].LocationId;
}
Trail[TrailCount]=newLocation;
TrailCount++;
}
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract FoodSafe
{
struct location
{
string LocationName;
uint LocationId;
uint PreviouslocationId;
uint Timestamp;
string Secret;
}
mapping(uint => location) Trail;
uint8 TrailCount=0;
function GetTrailCount() internal constant returns(uint8)
{
return TrailCount;
}
function AddNewLocation(uint LocationId, string LocationName, string Secret)internal view
{
location memory newLocation;
newLocation.LocationName=LocationName;
newLocation.LocationId=LocationId;
newLocation.Secret=Secret;
newLocation.Timestamp= now ;
}
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
function set(uint _value) public {
value = _value;
}
function get() public constant returns (uint) {
return value;
}
uint value;
}
contract coin
{
address public minter;
mapping(address => uint) public balances;
event Sent(address from, address to, uint amount);
function coin() public
{
minter=msg.sender;
}
function mint(address receiver, uint amount) public
{
if(msg.sender!=minter)
{
return;
}
balances[receiver]+=amount;
}
function send(address receiver,uint amount) public
{
if(balances[msg.sender]<amount)return;
balances[msg.sender]-=amount;
balances[receiver]+=amount;
//emit Sent (msg.sender, receiver, amount);
}
function checkbal(address addr) public view returns(uint)
{
return balances[addr];
}
}//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
function set(uint _value) public {
value = _value;
}
function get() public constant returns (uint) {
return value;
}
uint value;
}
contract coin
{
address public minter;
mapping(address => uint) public balances;
event Sent(address from, address to, uint amount);
function coin() public
{
minter=msg.sender;
}
function mint(address receiver, uint amount) public
{
if(msg.sender!=minter)
{
return;
}
balances[receiver]+=amount;
}
function send(address receiver,uint amount) public
{
if(balances[msg.sender]<amount)return;
balances[msg.sender]-=amount;
balances[receiver]+=amount;
emit Sent (msg.sender, receiver, amount);
}
function checkbal(address addr) public view returns(uint)
{
return balances[addr];
}
}//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
address asegurador;
address asegurado;
address oraculo;
uint256 precio_prima;
uint256 indemnizacion;
bool abierto;
string numerovuelo;
function setasegurador(address _value) public {
asegurador= _value;
}
function getasegurado() public constant returns (address) {
return asegurador;
}
function setpoliza(address _asegurado, uint256 _precio_prima, uint256 _indemnizacion, string _numerovuelo )public{
precio_prima=_precio_prima;
indemnizacion=_indemnizacion;
asegurado=_asegurado;
numerovuelo=_numerovuelo;
abierto=true;
}
//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.7;
import "github.com/OpenZeppelin/openzeppelin-solidity/contracts/math/SafeMath.sol";
contract Credibilite {
using SafeMath for uint256;
mapping (address => uint256) public cred;
bytes32[] private devoirs;
function produireHash(string memory url) public returns (bytes32){
bytes32 condensat = keccak256(bytes(url));
devoirs.push(condensat);
return condensat;
}
function transfert(address payable destinataire, uint256 valeur) public {
require(cred[msg.sender]>valeur, "tu n'as pas assez de cred");
require(cred[msg.sender]>1, "Tu dois avoir au mloins 1 cred");
destinataire.transfer(valeur);
}
function remettre(bytes32 devoir) public view returns (uint256) {
for(uint256 i=0;i<devoirs.length;i++){
if(devoirs[i] == devoir){
return i+1;
}
}
return 0;
}
pragma solidity 0.4.19;
contract PiggyBank {
address owner;
uint248 balance;
bytes32 hashedPassword;
function piggyBank(bytes32 _hashedPassword) payable {
owner = msg.sender;
balance += uint248(msg.value);
hashedPassword = _hashedPassword;
}
function () payable {
if (msg.sender != owner) revert();
balance += uint248(msg.value);
}
function kill(bytes32 password) {
if (keccak256(owner, password) != hashedPassword) revert();
selfdestruct(owner);
}
//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 despragma solidity ^0.5.0;
contract feeApplicator {
address[] public coins
mapping(address => mapping(address => address[]) ) public pairsToShells;
mapping(address => mapping(address => uint256) ) public shells;
constructor () public {
}
function addShell (address[] memory coins) public {
Shell shell = new Shell(coins);
for (uint8 i = 0; i < coins.length; i++) {
for (uint j = i + 1; j < coins.length; j++){
pairsToShells[coins[i]][coins[j]].push(shell)
pairsToShells[coins[j]][coins[i]].push(shell)
}
shells[shell][coins[i]] = 0
}
}
function swap(ERC20 origin, ERC20 target, uint256 originInput) public {
address[] storage shells = pairsToShells[origin][target];
uint256[shells.length] fees;
uint256 originSupply = origin.balanceOf(address(this));
uint256 targetSupply = target.balanceOf(address(thispragma solidity ^0.5.0;
contract feeApplicator {
address[] public coins
mapping(address => mapping(address => address[]) ) public pairsToShells
mapping(address => mapping(address => uint256) ) public shells
constructor () public {
}
function addShell (address[] memory coins) public {
Shell shell = new Shell(coins);
for (uint8 i = 0; i < coins.length; i++) {
for (uint j = i + 1; j < coins.length; j++){
pairsToShells[coins[i]][coins[j]].push(shell)
pairsToShells[coins[j]][coins[i]].push(shell)
}
shells[shell][coins[i]] = 0
}
}
function swap(ERC20 origin, ERC20 target, uint256 originInput) public {
address[] storage shells = pairsToShells[origin][target];
uint256[shells.length] fees;
uint256 originSupply = origin.balanceOf(address(this));
uint256 targetSupply = target.balanceOf(address(this))pragma solidity ^0.4.25;
contract sample {
struct Human {
string name;
uint32 age;
}
Human human = Human("taro", 20);
uint store;
function setStore(uint _value) public {
store = _value;
}
function getStore() public view returns(uint) {
return store;
}
function setHuman(string _name, uint32 _age) public {
human = Human(_name, _age);
}
function getHuman() public view returns(Human) {
ABIEncoderV2
}
pragma solidity 0.4.24;
// 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;
}
function getMax() public constant returns (uint256) {
return 2**256-1;
}
//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.24;
contract SimpleStore {
function set(uint _value) public {
value = _value;
}
function get() public constant returns (uint) {
return value;
}
function add1() public returns(uint) {
value++;
return value;
}
uint value;
pragma solidity ^0.4.25;
contract ZombieFactory {
event NewZombie(uint zombieId, string name, uint dna);
uint dnaDigits = 16;
uint dnaModulus = 10 ** dnaDigits;
uint cooldownTime = 1 days;
struct Zombie {
string name;
uint dna;
uint32 level;
uint32 readyTime;
}
Zombie[] public zombies;
mapping (uint => address) public zombieToOwner;
mapping (address => uint) ownerZombieCount;
function _createZombie(string _name, uint _dna) internal {
uint id = zombies.push(Zombie(_name, _dna, 1, uint32(now + cooldownTime))) - 1;
zombieToOwner[id] = msg.sender;
ownerZombieCount[msg.sender]++;
emit NewZombie(id, _name, _dna);
}
function _generateRandomDna(string _str) private view returns (uint) {
uint rand = uint(keccak256(abi.encodePacked(_str)));
return rand % dnaModulus;
}
function createRandomZombie(string _name) public {
require(ownerZombieCount[msg.sender] == 0);
uint randDna = _generateRandomDna(_name);
function set_root(
bytes32 root,
uint height,
uint[] memory signers,
uint8[] memory vs,
bytes32[] memory rs,
bytes32[] memory ss
) public {
require(height > Height + T_anchor, "Next anchor height not reached");
bytes32 message = keccak256(abi.encodePacked(root, height, Nonce, ContractID, "R"));
validate_signatures(message, signers, vs, rs, ss);
Root = root;
Height = height;
Nonce += 1;
emit anchorEvent(root, height);
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
pragma solidity ^0.5.0;
contract DeUber{
mapping(address => uint) addressRiderID;
mapping(address => uint) addressDriverID;
struct Ride {
uint rideID;
uint riderID;
uint driverID;
uint totalCost;
uint[] bids;
bool rideStart;
bool rideFinish;
bool riderPaymentPermission;
bool paymentFinish;
string source;
string destination;
}
constructor() public {
addressRiderID[msg.sender]=5000;
}
function registerDriver() public payable returns(string memory) {
require(addressDriverID[msg.sender] == 0,"Already registered as Driver.");
return "Already registered as Driver.";
}
function registerRider() public payable returns(string memory) {
require(addressRiderID[msg.sender] == 0, "Already registered as Rider.");
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract DeUber{
mapping(address => uint) addressRiderID;
mapping(address => uint) addressDriverID;
struct Ride {
uint rideID;
uint riderID;
uint driverID;
uint totalCost;
uint[] bids;
bool rideStart;
bool rideFinish;
bool riderPaymentPermission;
bool paymentFinish;
string source;
string destination;
}
constructor() public {
addressRiderID[msg.sender]=5000;
}
function registerDriver() public payable returns(string memory) {
require(addressDriverID[msg.sender] == 0,"Already registered as Driver.");
return "Already registered as Driver.";
}
function registerRider() public payable returns(string memory) {
require(addressRiderID[msg.sender] == 0, "Already registered as Rider.");
return "Already regi//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 {sd
value = _value;
}
function get() public constant returns (uint) {
return value;
}
uint value;
pragma solidity ^0.4.25;
contract SupplyChain {
enum Status { Created, Delivering, Delivered, Accepted, Declined }
Order[] orders;
struct Order {
string title;
string description;
address supplier;
address deliveryCompany;
address customer;
Status status;
}
event OrderCreated(
uint256 index,
address indexed supplier,
address indexed deliveryCompany,
address indexed customer
);
event OrderDelivering(
uint256 index,
address indexed supplier,
address indexed deliveryCompany,
address indexed customer
);
event OrderDelivered(
uint256 index,
address indexed supplier,
address indexed deliveryCompany,
address indexed customer
);
event OrderAccepted(
uint256 index,
address indexed supplier,
address indexed deliveryCompany,
address indexed customer
);
evepragma solidity ^0.4.25;
contract SupplyChain {
enum Status { Created, Delivering, Delivered, Accepted, Declined }
Order[] orders;
struct Order {
string title;
string description;
address supplier;
address deliveryCompany;
address customer;
Status status;
}
event OrderCreated(
uint256 index,
address indexed supplier,
address indexed deliveryCompany,
address indexed customer
);
event OrderDelivering(
uint256 index,
address indexed supplier,
address indexed deliveryCompany,
address indexed customer
);
event OrderDelivered(
uint256 index,
address indexed supplier,
address indexed deliveryCompany,
address indexed customer
);
event OrderAccepted(
uint256 index,
address indexed supplier,
address indexed deliveryCompany,
address indexed customer
);
evepragma solidity ^0.4.0;
contract PizzaOrNot{
struct Candidate {
string name;
uint voteCount;
}
struct Voter {
bool voted;
uint voteIndex;
uint weight;
}
address public owner;
string public name;
mapping(address => Voter) public voters;
Candidate[] public candidates;
uint public auctionEnd;
event ElectionResult(string name, uint voteCount);
function Election(string _name, uint durationMinutes, string candidate1, string candidate2) public{
owner = msg.sender;
name = _name;
auctionEnd = now + (durationMinutes * 1 minutes);
candidates.push(Candidate(candidate1,0));
candidates.push(Candidate(candidate2,0));
}
function authorize(address voter) public {
require(msg.sender == owner);
require(!voters[voter].voted);
voters[voter].weight = 1 ;
}
function vote(uint voteIndex) {
require(now < auctionEpragma solidity ^0.5.10;
contract Token {
bytes32 public standard;
bytes32 public name;
bytes32 public symbol;
uint256 public totalSupply;
uint8 public decimals;
bool public allowTransactions;
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
function transfer(address _to, uint256 _value) returns (bool success);
function approveAndCall(address _spender, uint256 _value, bytes _extraData) returns (bool success);
function approve(address _spender, uint256 _value) returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) returns (bool success);
}
contract Dex {
function safeMul(uint a, uint b) internal returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function safeSub(uint a, uint b) internal returns (uint) {
assert(b <= a);
return a - b;
}
function safeAdd(uint a, uint b) internal returns (uint) {
uint c = pragma solidity 0.4.16;
contract token {
string public standard = 'yuyangray';
string public name; //代币名称
string public symbol; //代币符号比如'$'
//代币单位，展示的小数点后面多少个0,和以太币一样后面是是18个0
uint8 public decimals = 2;
uint256 public totalSupply; //代币总量
mapping (address => uint256) public balanceOf;
event Transfer(address indexed from, address indexed to, uint256 value);
function token(address _owned, string tokenName, string tokenSymbol) public {
//合约的管理者获得的代币总量
balanceOf[_owned] = totalSupply;
name = tokenName;
symbol = tokenSymbol;
}
function transfer(address _to, uint256 _value) public {
//从发送者减掉发送额
balanceOf[msg.sender] -= _value;
//给接收者加上相同的量
balanceOf[_to] += _value;
//通知任何监听该交易的客户端
Transfer(msg.sender, _to, _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;
//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) {
value = 0;
return value;
}
uint value;
pragma solidity >=0.4.3 <0.6.0;
contract MeetingContract {
address owner;
uint16 private numMeeting;
Meeting[] private meetings;
constructor () public {
owner = msg.sender;
}
function createMeeting(string memory _description) public onlyOwner fieldCantBeEmpty(_description) returns (uint16) {
require(numMeeting + 1 > numMeeting, "reached maximum number of meetings");
meetings.length = numMeeting + 1;
meetings[numMeeting] = Meeting({description:_description, amountMembers:0});
numMeeting += 1;
return numMeeting;
}
function registerMemberToMeeting(string memory _passport, uint16 _meetingId) public fieldCantBeEmpty(_passport) checkMeetingId(_meetingId) returns (bool){
require(numMeeting + 1 > numMeeting, "no meeting places");
require(checkMemberRegistration(_passport, _meetingId) == false, "this user is already registered");
bytes32 passportHash = getHash(_passport);
pragma solidity 0.4.16;
contract token {
string public standard = 'yuyangray';
string public name; //代币名称
string public symbol; //代币符号比如'$'
//代币单位，展示的小数点后面多少个0,和以太币一样后面是是18个0
uint8 public decimals = 2;
uint256 public totalSupply; //代币总量
mapping (address => uint256) public balanceOf;
event Transfer(address indexed from, address indexed to, uint256 value);
function token(address _owned, string tokenName, string tokenSymbol) public {
//合约的管理者获得的代币总量
balanceOf[_owned] = totalSupply;
name = tokenName;
symbol = tokenSymbol;
}
function transfer(address _to, uint256 _value) public {
//从发送者减掉发送额
balanceOf[msg.sender] -= _value;
//给接收者加上相同的量
balanceOf[_to] += _value;
//通知任何监听该交易的客户端
Transfer(msg.sender, _to, _value)pragma solidity ^0.5.0;
import "../../sether-interface/contracts/FacebookSetherAPI.sol";
contract MyContract is FacebookSetherAPI {
event MyEvent(
bool targetAchieved,
bytes32 requestID
);
uint64 targetLikes;
constructor() public
{
targetLikes = 1000;
}
function checkFacebookLikesTarget( bytes32 setherToken, bytes32 date, bytes32 targetId, uint8 level, bytes32 requestID) public
{
super.get_facebook_page_likes(setherToken, "", date, targetId, level, requestID);
}
function callback(uint64 setherMetric, bytes32 requestID) public
{
emit MyEvent(setherMetric >= targetLikes, requestID);
}
pragma solidity ^0.5.0;
import "../../sether-interface/contracts/FacebookSetherAPI.sol";
contract MyContract is FacebookSetherAPI {
event MyEvent(
bool targetAchieved,
bytes32 requestID
);
uint64 targetLikes;
constructor() public
{
targetLikes = 1000;
}
function checkFacebookLikesTarget( bytes32 setherToken, bytes32 date, bytes32 targetId, uint8 level, bytes32 requestID) public
{
get_facebook_page_likes(setherToken, "", date, targetId, level, requestID);
}
function callback(uint64 setherMetric, bytes32 requestID) public
{
emit MyEvent(setherMetric >= targetLikes, requestID);
}
pragma solidity ^0.4.24;
contract tbdocs {
address owner;
string public testData;
constructor() public {
owner = msg.sender;
}
function getOwner() public view returns (address) {
return owner;
}
function setTestData(string data) public returns (string) {
testData = data;
return testData;
}
function getTestData() public view returns (string) {
return testData;
}
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
function sets(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 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.7;
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 SimpleStore {
function set(uint _value) public {
value = _value;
}
function get() public constant returns (uint) {
return value+1;
}
uint value;
pragma solidity ^0.5.0;
import "../../sether-interface/contracts/FacebookSetherAPI.sol";
contract MyContract is FacebookSetherAPI {
event MyEvent(
uint64 setherMetric,
string requestID
);
uint64 target_likes;
constructor() public
{
target_likes = 1000;
}
function callback(uint64 setherMetric, string memory requestID) public
{
if(setherMetric >= target_likes)
{
emit MyEvent(setherMetric, requestID);
}
}
pragma solidity ^0.5.0;
import "../../sether-interface/contracts/FacebookSetherAPI.sol";
contract MyContract is FacebookSetherAPI {
event MyEvent(
uint64 setherMetric,
string requestID
);
constructor() public
{
}
function callback(uint64 setherMetric, string memory requestID) public
{
emit MyEvent(setherMetric, requestID);
}
//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 sumPublic(uint _value) public returns (uint) {
value += _value;
return value;
}
function sumExternal(uint _value) public returns (uint) {
value += _value;
return value;
}
function getPublic(uint _value) public returns (uint) {
return value;
}
function getExternal(uint _value) public 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 SimpleStore {
function set(uint _value) public {
value = _value;
}
function sumPublic(uint _value) public returns (uint) {
return value;
}
function sumExternal(uint value) public returns (uint) {
return value;
}
uint value;
pragma solidity ^0.4.25;
//copy by wiki https://theethereum.wiki/w/index.php/ERC20_Token_Standard
// ----------------------------------------------------------------------------
// 'FIXED' 'Example Fixed Supply Token' token contract
//
// Symbol : FIXED
// Name : Example Fixed Supply Token
// Total supply: 1,000,000.000000000000000000
// Decimals : 18
//
// Enjoy.
//
// (c) BokkyPooBah / Bok Consulting Pty Ltd 2018. The MIT Licence.
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// Safe maths
// ----------------------------------------------------------------------------
library SafeMath {
function add(uint a, uint b) internal pure returns (uint c) {
c = a + b;
require(c >= a);
}
function sub(uint a, uint b) internal pure returns (uint c) {
require(b <= a);
c = a - b;
}
function mul(uint a, uint b) internal pure returns (uint c)//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
function set(uint _value) public {
value = _value;
}
function get() public constant returns (uint) {
return value;
}
uint value;
//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.24;
// This is a very simple subscription contract
// Puts into context how to manage periodic states
// Using Lazy Evaluation. It uses
import "openzeppelin-solidity/contracts/ECRecovery.sol";
import "openzeppelin-solidity/contracts/math/SafeMath.sol";
import "openzeppelin-solidity/contracts/ownership/Ownable.sol";
import "openzeppelin-solidity/contracts/token/ERC20/ERC20.sol";
contract Subscription is Ownable {
using ECRecovery for bytes32;
using SafeMath for uint256;
constructor() public { }
// similar to a nonce that avoids replay attacks this allows a single execution
// every x seconds for a given subscription
// subscriptionHash => next valid block number
mapping(bytes32 => uint256) public nextValidTimestamp;
// for some cases of delegated execution, this contract will pay a third party
// to execute the transfer. If this happens, the owner of this contract must
// sign the subscriptionHash
mapping(bytes32 => bool) public publ
//
contract Eager {
uint256 public variable;
// This function will be called
// You need to trust it!
function increment(){
a++;
}
}
contract Lazy {
uint256 public variable;
// This function will be called
// You need to trust it!
function increment(){
a++;
}
contract Eager {
uint256 public a;
function increment(){
a++;
}
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.26;
contract SimpleStore {
using SafeMath for uint;
function getChangeOrderOfOpps() public constant returns (uint) {
uint amt = uint(1000).mul(10**18);
uint percent = 75;
uint res = amt.mul(percent.div(100));
return res;
}
function getWithoutPrecision() public constant returns (uint) {
uint amt = uint(1000).mul(10**18);
uint percent = 75;
uint res = amt.mul(percent).div(100);
return res;
}
function getWithPrecision() public constant returns (uint) {
uint amt = uint(1000).mul(10**18);
uint percent = uint(75).mul(10**18);
uint denominator = uint(100).mul(10**18);
uint res = amt.mul(percent).div(denominator);
return res;
}
}
/**
* @title SafeMath
* @dev Math operations with safety checks that revert on error
*/
library SafeMath {
int256 constant private INT256_MIN = -2**255;
/**
* @dev Multiplies two unsigned integers, rpragma solidity ^0.4.18;
/**
* @title SafeMath
* @dev Math operations with safety checks that revert on error
*/
library SafeMath {
int256 constant private INT256_MIN = -2**255;
/**
* @dev Multiplies two unsigned integers, reverts on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
/**
* @dev Multiplies two signed integers, reverts on overflow.
*/
function mul(int256 a, int256 b) internal pure returns (int256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZe//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.24;
/**
* @title SafeMath
* @dev Math operations with safety checks that revert on error
*/
library SafeMath {
int256 constant private INT256_MIN = -2**255;
/**
* @dev Multiplies two unsigned integers, reverts on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
/**
* @dev Multiplies two signed integers, reverts on overflow.
*/
function mul(int256 a, int256 b) internal pure returns (int256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.5.0;
library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
/**
* @dev Returns the multiplicati//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.26;
contract DoubleMap {
struct Average {
uint total;
uint count;
}
mapping(string => mapping(string => Average)) AvgValues;
function getValuesAtIndex(string owner, string id) public view returns (uint a){
return (AvgValues[owner][id].total);
}
}pragma solidity ^0.4.26;
contract test {
uint total;
uint counter;
function calcAverage( uint _newValue) public
{
total += _newValue;
counter++;
}
function get() public view returns(uint)
{
return total / counter;
}
//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 SimpleStore {
struct Token {
uint TokenID;
string Text;
}
mapping (uint => Token) tokenz;
function setToken(uint IDD, uint _TokenID, string _Text) public {
var tok = tokenz[IDD];
tok.TokenID = _TokenID;
tok.Text = _Text;
}
function get_token_by_IDD(uint _IDD) public view returns(uint __TokenID, string __Text){
var __tok = tokenz[_IDD];
__TokenID = __tok.TokenID;
__Text = __tok.Text;
}
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
struct Token {
uint TokenID;
string Text;
}
mapping (uint => Token) tokenz;
function setToken(uint IDD, uint _TokenID, string _Text) public {
var tok = tokenz[IDD];
tok.TokenID = _TokenID;
tok.Text = _Text;
}
function get_token_by_IDD(uint _IDD) public view returns(uint __TokenID, string __Text){
var __tok = tokenz[_IDD];
__TokenID = __tok.TokenID;
__Text = __tok.Text;
}
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 actualizarPrecio(uint _precio) public soloPropietario {
precio = _precio;
emit eventoEstadoActual('Precio actualizado', msg.sender, precio, block.timestamp);
estadoActual = 'Artículo a la venta.';
}
function modificarDescripcion (string memory _descripcion) public soloPropietaripragma solidity ^0.4.18;
contract RegistroDato {
string dato;
function RegistradDato (string memory _dato) public {
dato = _dato;
}
function verDato() public view returns (string memory) {
return (dato);
}
function cambiaDato(string memory _nuevoDato) public {
dato = _nuevoDato;
}
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.25;
contract CagnotteFestival{
mapping (address => uint) organisateurs;
constructor() public {
organisateurs[msg.sender]=100;
}
function transfererOrga (address orga, uint parts) public {
require(organisateurs[msg.sender]>0);
require(orga != msg.sender);
organisateurs[orga]=parts;
organisateurs[msg.sender]=100-parts;
}
function estOrga (address orga) public view returns (bool){
return organisateurs[orga]>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;
}
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.17;
import "./ContractRegistry.sol";
/* solium-disable security/no-tx-origin*/
contract ScoreCardContract {
uint public CONTRACT_VERSION = 0;
string public CONTRACT_NAME = "ScoreCardContract";
int score = 0;
mapping(string => timestamp) players;
event PlayerScored(
string scoreUUID,
string playerName,
uint256 timeOfScore
);
constructor(address _contractRegistryAddress, string _scoreUUID) public {
ContractRegistry contractRegistry = ContractRegistry(_contractRegistryAddress);
scoreUUID = _scoreUUID;
}
function incrementScore(string _playerName) public{
players[_playerName] = block.timestamp
score = score + 1;
emit PlayerScored(scoreUUID, _playerName, players[_playerName]);
}
pragma solidity ^0.4.18;
contract SimpleStore {
address creator;
uint a = 10;
uint b = 20;
uint c;
function addition() public {
creator = msg.sender;
c = a + b;
}
function getResult() constant public returns (uint) {
return c; // should return 3
}
/**********
Standard kill() function to recover funds
**********/
function kill() public {
if (msg.sender == creator)
selfdestruct(creator); // kills this contract and sends remaining funds back to creator
}
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.5.10;
contract SimpleStore {
function set(uint _value) public {
value = _value;
}
function get() public constant returns (uint) {
return value;
}
uint value;
pragma solidity ^0.4.18;
contract A {
address constant addr = 0x777e5B07Ec41B71aCbA2e32a878f867d5B1B3f09;
mapping (string => address) private assets;
string a = "ABCDE";
function getByString() payable public returns(address){
assets[a] = addr;
return assets[a];
}
}
contract B {
address constant addr = 0x777e5B07Ec41B71aCbA2e32a878f867d5B1B3f09;
mapping (uint256 => address) private assets;
uint256 b = 1;
function getByInt() payable public returns(address){
assets[b] = addr;
return assets[b];
}
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.5.0;
contract QueueContract {
uint constant QUEUE_SIZE = 5;
struct Queue {
string[] data;
uint front;
uint back;
}
Queue q;
function newQueue() {
q.data = new string[](QUEUE_SIZE);
q.front = 0;
q.back = 1;
}
function enqueue(string hash) {
require(q.back != q.front);
q.data[q.back] = hash;
q.back = (q.back + 1) % QUEUE_SIZE;
}
function dequeue() returns (string) {
string memory hash = q.data[q.front];
q.front = (q.front + 1) % QUEUE_SIZE;
return hash;
}
pragma solidity ^0.4.25;
contract checkBug {
int128[] public firstMethod = [-1, -2, -3];
int128[] public secondMethod;
function addInt() public {
int8[3] memory arrTmp = [-1, -2, -3];
secondMethod = arrTmp;
}
}//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;