hash
stringlengths 64
64
| size
int64 7k
624k
| ext
stringclasses 1
value | lang
stringclasses 1
value | is_test
bool 2
classes | repo_id
stringclasses 846
values | repo_name
stringclasses 846
values | repo_head
stringclasses 846
values | repo_path
stringlengths 7
155
| content_tokens
int64 1.82k
42.6k
| content_chars
int64 6.85k
58.7k
| content
stringlengths 6.85k
58.7k
| __index_level_0__
int64 84
346k
| id
int64 0
14.2k
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
2dac93da1126d2b29515ed3a47ca8f3a71fe2e4b13a246f12b864ade89f85b0b
| 9,235 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x98307e036c5d024447ea59296f6e41cb998b38d0.sol
| 3,339 | 9,169 |
pragma solidity ^0.4.18;
// If you wanna escape this contract REALLY FAST
// 1. open MEW/METAMASK
// 2. Put this as data: 0xb1e35242
// 3. send 150000+ gas
// That calls the getMeOutOfHere() method
// ProofOfStrongHandsV1 (POSH)
// Rewards dividends to holders on both buy and sell
// Creation Tips: 0x9c447C1ad9DF54aC6cfDf642Cf4c67E440A6f200
contract POSH {
uint256 constant PRECISION = 0x10000000000000000; // 2^64
// CRR = 80 %
int constant CRRN = 1;
int constant CRRD = 2;
// The price coefficient. Chosen such that at 1 token total supply
// the reserve is 0.8 ether and price 1 ether/token.
int constant LOGC = -0x296ABF784A358468C;
string constant public name = "ProofOfStrongHandsV1";
string constant public symbol = "POSH";
uint8 constant public decimals = 18;
uint256 public totalSupply;
// amount of shares for each address (scaled number)
mapping(address => uint256) public balanceOfOld;
// allowance map, see erc20
mapping(address => mapping(address => uint256)) public allowance;
// amount payed out for each address (scaled number)
mapping(address => int256) payouts;
// sum of all payouts (scaled number)
int256 totalPayouts;
// amount earned for each share (scaled number)
uint256 earningsPerShare;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
// These are functions solely created to appease the frontend
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balanceOfOld[_owner];
}
function withdraw(uint tokenCount) // the parameter is ignored, yes
public
returns (bool)
{
var balance = dividends(msg.sender);
payouts[msg.sender] += (int256) (balance * PRECISION);
totalPayouts += (int256) (balance * PRECISION);
msg.sender.transfer(balance);
return true;
}
function sellMyTokensDaddy() public {
var balance = balanceOf(msg.sender);
transferTokens(msg.sender, address(this), balance); // this triggers the internal sell function
}
function getMeOutOfHere() public {
sellMyTokensDaddy();
withdraw(1); // parameter is ignored
}
function fund()
public
payable
returns (bool)
{
if (msg.value > 0.000001 ether)
buy();
else
return false;
return true;
}
function buyPrice() public constant returns (uint) {
return getTokensForEther(1 finney);
}
function sellPrice() public constant returns (uint) {
return getEtherForTokens(1 finney);
}
function transferTokens(address _from, address _to, uint256 _value) internal {
if (balanceOfOld[_from] < _value)
revert();
if (_to == address(this)) {
sell(_value);
} else {
int256 payoutDiff = (int256) (earningsPerShare * _value);
balanceOfOld[_from] -= _value;
balanceOfOld[_to] += _value;
payouts[_from] -= payoutDiff;
payouts[_to] += payoutDiff;
}
Transfer(_from, _to, _value);
}
function transfer(address _to, uint256 _value) public {
transferTokens(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public {
var _allowance = allowance[_from][msg.sender];
if (_allowance < _value)
revert();
allowance[_from][msg.sender] = _allowance - _value;
transferTokens(_from, _to, _value);
}
function approve(address _spender, uint256 _value) public {
// To change the approve amount you first have to reduce the addresses`
// allowance to zero by calling `approve(_spender, 0)` if it is not
// already 0 to mitigate the race condition described here:
// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
if ((_value != 0) && (allowance[msg.sender][_spender] != 0)) revert();
allowance[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
}
function dividends(address _owner) public constant returns (uint256 amount) {
return (uint256) ((int256)(earningsPerShare * balanceOfOld[_owner]) - payouts[_owner]) / PRECISION;
}
function withdrawOld(address to) public {
var balance = dividends(msg.sender);
payouts[msg.sender] += (int256) (balance * PRECISION);
totalPayouts += (int256) (balance * PRECISION);
to.transfer(balance);
}
function balance() internal constant returns (uint256 amount) {
return this.balance - msg.value;
}
function reserve() public constant returns (uint256 amount) {
return balance()
- ((uint256) ((int256) (earningsPerShare * totalSupply) - totalPayouts) / PRECISION) - 1;
}
function buy() internal {
if (msg.value < 0.000001 ether || msg.value > 1000000 ether)
revert();
var sender = msg.sender;
// 5 % of the amount is used to pay holders.
var fee = (uint)(msg.value / 10);
// compute number of bought tokens
var numEther = msg.value - fee;
var numTokens = getTokensForEther(numEther);
var buyerfee = fee * PRECISION;
if (totalSupply > 0) {
// compute how the fee distributed to previous holders and buyer.
// The buyer already gets a part of the fee as if he would buy each token separately.
var holderreward =
(PRECISION - (reserve() + numEther) * numTokens * PRECISION / (totalSupply + numTokens) / numEther)
* (uint)(CRRD) / (uint)(CRRD-CRRN);
var holderfee = fee * holderreward;
buyerfee -= holderfee;
// Fee is distributed to all existing tokens before buying
var feePerShare = holderfee / totalSupply;
earningsPerShare += feePerShare;
}
// add numTokens to total supply
totalSupply += numTokens;
// add numTokens to balance
balanceOfOld[sender] += numTokens;
// fix payouts so that sender doesn't get old earnings for the new tokens.
// also add its buyerfee
var payoutDiff = (int256) ((earningsPerShare * numTokens) - buyerfee);
payouts[sender] += payoutDiff;
totalPayouts += payoutDiff;
}
function sell(uint256 amount) internal {
if (amount < 0.000001 ether || amount > 1000000 ether)
revert();
// Calculate sell fee
var numEther = getEtherForTokens(amount);
var fee = (uint)(numEther / 10);
numEther -= fee;
if (totalSupply > 0) {
// compute how the fee distributed to previous holders
var holderreward =
(PRECISION - (reserve() + numEther) * amount * PRECISION / (totalSupply + amount) / numEther)
* (uint)(CRRD) / (uint)(CRRD-CRRN);
var holderfee = fee * holderreward;
// Fee is distributed to all existing tokens before selling
var feePerShare = holderfee / totalSupply;
earningsPerShare += feePerShare;
}
// remove tokens
totalSupply -= amount;
balanceOfOld[msg.sender] -= amount;
// fix payouts and put the ethers in payout
var payoutDiff = (int256) (earningsPerShare * amount + (numEther * PRECISION));
payouts[msg.sender] -= payoutDiff;
totalPayouts -= payoutDiff;
}
function getTokensForEther(uint256 ethervalue) public constant returns (uint256 tokens) {
return fixedExp(fixedLog(reserve() + ethervalue)*CRRN/CRRD + LOGC) - totalSupply;
}
function getEtherForTokens(uint256 tokens) public constant returns (uint256 ethervalue) {
if (tokens == totalSupply)
return reserve();
return reserve() - fixedExp((fixedLog(totalSupply - tokens) - LOGC) * CRRD/CRRN);
}
int256 constant one = 0x10000000000000000;
uint256 constant sqrt2 = 0x16a09e667f3bcc908;
uint256 constant sqrtdot5 = 0x0b504f333f9de6484;
int256 constant ln2 = 0x0b17217f7d1cf79ac;
int256 constant ln2_64dot5= 0x2cb53f09f05cc627c8;
int256 constant c1 = 0x1ffffffffff9dac9b;
int256 constant c3 = 0x0aaaaaaac16877908;
int256 constant c5 = 0x0666664e5e9fa0c99;
int256 constant c7 = 0x049254026a7630acf;
int256 constant c9 = 0x038bd75ed37753d68;
int256 constant c11 = 0x03284a0c14610924f;
function fixedLog(uint256 a) internal pure returns (int256 log) {
int32 scale = 0;
while (a > sqrt2) {
a /= 2;
scale++;
}
while (a <= sqrtdot5) {
a *= 2;
scale--;
}
int256 s = (((int256)(a) - one) * one) / ((int256)(a) + one);
// The polynomial R = c1*x + c3*x^3 + ... + c11 * x^11
// approximates the function log(1+x)-log(1-x)
// Hence R(s) = log((1+s)/(1-s)) = log(a)
var z = (s*s) / one;
return scale * ln2 +
(s*(c1 + (z*(c3 + (z*(c5 + (z*(c7 + (z*(c9 + (z*c11/one))
/one))/one))/one))/one))/one);
}
int256 constant c2 = 0x02aaaaaaaaa015db0;
int256 constant c4 = -0x000b60b60808399d1;
int256 constant c6 = 0x0000455956bccdd06;
int256 constant c8 = -0x000001b893ad04b3a;
function fixedExp(int256 a) internal pure returns (uint256 exp) {
int256 scale = (a + (ln2_64dot5)) / ln2 - 64;
a -= scale*ln2;
// The polynomial R = 2 + c2*x^2 + c4*x^4 + ...
// approximates the function x*(exp(x)+1)/(exp(x)-1)
// Hence exp(x) = (R(x)+x)/(R(x)-x)
int256 z = (a*a) / one;
int256 R = ((int256)(2) * one) +
(z*(c2 + (z*(c4 + (z*(c6 + (z*c8/one))/one))/one))/one);
exp = (uint256) (((R + a) * one) / (R - a));
if (scale >= 0)
exp <<= scale;
else
exp >>= -scale;
return exp;
}
function () payable public {
if (msg.value > 0)
buy();
else
withdrawOld(msg.sender);
}
}
| 183,680 | 1,000 |
464535a25563fa6f831480e61d3ee6b28c30cd3abb8ec7d9804932492fb1d60e
| 27,175 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/cf/cf5e929e56127bba0fe6ea26cf909710863f9658_LiquidLabs.sol
| 3,423 | 13,669 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
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;
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
this;
return msg.data;
}
}
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
interface IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(address from, address to, uint256 tokenId) external;
function transferFrom(address from, address to, uint256 tokenId) external;
function approve(address to, uint256 tokenId) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function setApprovalForAll(address operator, bool _approved) external;
function isApprovedForAll(address owner, address operator) external view returns (bool);
function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;
}
interface IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
interface IERC721Enumerable is IERC721 {
function totalSupply() external view returns (uint256);
function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256 tokenId);
function tokenByIndex(uint256 index) external view returns (uint256);
}
interface IERC721Receiver {
function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4);
}
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IERC165).interfaceId;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
abstract contract ReentrancyGuard {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor () {
_status = _NOT_ENTERED;
}
modifier nonReentrant() {
// On the first call to nonReentrant, _notEntered will be true
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
// Any calls to nonReentrant after this point will fail
_status = _ENTERED;
_;
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
_status = _NOT_ENTERED;
}
}
contract LiquidLabs is Ownable, ReentrancyGuard {
// Interfaces for ERC20 and ERC721
// Constructor function
//constructor(IERC721 _nftCollection) {
//nftCollection = _nftCollection;
//}
IERC721 public immutable nftCollection = IERC721(0xe01A6aCa062aeC8E44CbB6A476769d30CF30e824);
// Staker info
struct LendNFt {
// Lend offer amount
uint256 offeramount;
// Lend time
uint256 timeOfLastUpdate;
// Calculated, but unclaimed rewards for the User. The rewards are
bool claimStatus;
//Borrowrs address
address borrower;
//which nft ID is borrowed
uint256 borrewdnftid;
}
mapping(address => LendNFt[]) public lender;
mapping(uint256 => address) public lenderAddress;
address[] public lendersArray;
function lend() external payable {
require(msg.value > 0);
lender[msg.sender].push(LendNFt(msg.value, block.timestamp, false, msg.sender, 0));
lendersArray.push(msg.sender);
}
function checkmylends(address _addr, uint256 _index) view public returns(uint256, uint256, bool, address, uint256) {
uint256 _offeramount = lender[_addr][_index].offeramount;
uint256 _timeOfLastUpdate = lender[_addr][_index].timeOfLastUpdate;
bool _claimStatus = lender[_addr][_index].claimStatus;
address _borrower = lender[_addr][_index].borrower;
uint256 _borrewdnftid = lender[_addr][_index].borrewdnftid;
if(_timeOfLastUpdate == 0){
return (0, 0 , false, msg.sender, 0);
}else {
return (_offeramount, _timeOfLastUpdate, _claimStatus, _borrower, _borrewdnftid);
}
}
function getallmylends(address _addr) view public returns(uint256) {
return lender[_addr].length;
}
// Borrower info
struct BorrowNFT {
// Lend offer amount
uint256 nftid;
// Lend time
uint256 borrowtime;
//Borrowers borrow amount
uint256 amountBorrowed;
// Calculated, but unclaimed rewards for the User. The rewards are
bool paidStatus;
//Borrowrs address
address lender;
}
mapping(address => BorrowNFT[]) public borrower;
mapping(uint256 => address) public borrowerAddress;
address[] public borrowersArray;
//this function is related by the borrow.
function borrow(uint256 _tokenId, uint256 _index) external nonReentrant {
require(borrowerAddress[_tokenId] == msg.sender);
if (borrower[msg.sender][_index].amountBorrowed > 0) {
//Dont need to do anything.
} else {
lendersArray.push(msg.sender);
}
require(nftCollection.ownerOf(_tokenId) == msg.sender, "Can't stake tokens you don't own!");
nftCollection.transferFrom(msg.sender, address(this), _tokenId);
borrowerAddress[_tokenId] = msg.sender;
borrower[msg.sender][_index].amountBorrowed += 1;
borrower[msg.sender][_index].borrowtime = block.timestamp;
}
// Check if user has any ERC721 Tokens Staked and if he tried to withdraw,
// calculate the rewards and store them in the unclaimedRewards and for each
// ERC721 Token in param: check if msg.sender is the original staker, decrement
// the amountBorrowed of the user and transfer the ERC721 token back to them
function withdraw(uint256 _tokenId, uint256 _index) external nonReentrant {
require(borrower[msg.sender][_index].amountBorrowed > 0,
"You have no tokens staked");
require(lenderAddress[_tokenId] == msg.sender);
lenderAddress[_tokenId] = address(0);
nftCollection.transferFrom(address(this), msg.sender, _tokenId);
borrower[msg.sender][_index].amountBorrowed -= 1;
borrower[msg.sender][_index].borrowtime = block.timestamp;
if (borrower[msg.sender][_index].amountBorrowed == 0) {
for (uint256 i; i < borrowersArray.length; ++i) {
if (borrowersArray[i] == msg.sender) {
borrowersArray[i] = lendersArray[lendersArray.length - 1];
borrowersArray.pop();
}
}
}
}
}
| 97,960 | 1,001 |
8a34a033fa894e2069c98252a03bb9a004029e3fa47a4038f5d80c67ca72d8bd
| 10,095 |
.sol
|
Solidity
| false |
292111594
|
CRDGit/CRDStableCoin
|
6803eab30018f8cc8cc593a602c713e0ed8f38d1
|
src/vat.sol
| 3,104 | 10,029 |
/// vat.sol -- Dai CDP database
// Copyright (C) 2018 Rain <rainbreak@riseup.net>
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
pragma solidity >=0.5.12;
contract Vat {
// --- Auth ---
mapping (address => uint) public wards;
function rely(address usr) external note auth { require(live == 1, "Vat/not-live"); wards[usr] = 1; }
function deny(address usr) external note auth { require(live == 1, "Vat/not-live"); wards[usr] = 0; }
modifier auth {
require(wards[msg.sender] == 1, "Vat/not-authorized");
_;
}
mapping(address => mapping (address => uint)) public can;
function hope(address usr) external note { can[msg.sender][usr] = 1; }
function nope(address usr) external note { can[msg.sender][usr] = 0; }
function wish(address bit, address usr) internal view returns (bool) {
return either(bit == usr, can[bit][usr] == 1);
}
// --- Data ---
struct Ilk {
uint256 Art; // Total Normalised Debt [wad]
uint256 rate; // Accumulated Rates [ray]
uint256 spot; // Price with Safety Margin [ray]
uint256 line; // Debt Ceiling [rad]
uint256 dust; // Urn Debt Floor [rad]
}
struct Urn {
uint256 ink; // Locked Collateral [wad]
uint256 art; // Normalised Debt [wad]
}
mapping (bytes32 => Ilk) public ilks;
mapping (bytes32 => mapping (address => Urn)) public urns;
mapping (bytes32 => mapping (address => uint)) public gem; // [wad]
mapping (address => uint256) public dai; // [rad]
mapping (address => uint256) public sin; // [rad]
uint256 public debt; // Total Dai Issued [rad]
uint256 public vice; // Total Unbacked Dai [rad]
uint256 public Line; // Total Debt Ceiling [rad]
uint256 public live; // Active Flag
// --- Logs ---
event LogNote(bytes4 indexed sig,
bytes32 indexed arg1,
bytes32 indexed arg2,
bytes32 indexed arg3,
bytes data) anonymous;
modifier note {
_;
assembly {
// log an 'anonymous' event with a constant 6 words of calldata
// and four indexed topics: the selector and the first three args
let mark := msize() // end of memory ensures zero
mstore(0x40, add(mark, 288)) // update free memory pointer
mstore(mark, 0x20) // bytes type data offset
mstore(add(mark, 0x20), 224) // bytes size (padded)
calldatacopy(add(mark, 0x40), 0, 224) // bytes payload
log4(mark, 288, // calldata
shl(224, shr(224, calldataload(0))), // msg.sig
calldataload(4), // arg1
calldataload(36), // arg2
calldataload(68) // arg3)
}
}
// --- Init ---
constructor() public {
wards[msg.sender] = 1;
live = 1;
}
// --- Math ---
function add(uint x, int y) internal pure returns (uint z) {
z = x + uint(y);
require(y >= 0 || z <= x);
require(y <= 0 || z >= x);
}
function sub(uint x, int y) internal pure returns (uint z) {
z = x - uint(y);
require(y <= 0 || z <= x);
require(y >= 0 || z >= x);
}
function mul(uint x, int y) internal pure returns (int z) {
z = int(x) * y;
require(int(x) >= 0);
require(y == 0 || z / y == int(x));
}
function add(uint x, uint y) internal pure returns (uint z) {
require((z = x + y) >= x);
}
function sub(uint x, uint y) internal pure returns (uint z) {
require((z = x - y) <= x);
}
function mul(uint x, uint y) internal pure returns (uint z) {
require(y == 0 || (z = x * y) / y == x);
}
// --- Administration ---
function init(bytes32 ilk) external note auth {
require(ilks[ilk].rate == 0, "Vat/ilk-already-init");
ilks[ilk].rate = 10 ** 27;
}
function file(bytes32 what, uint data) external note auth {
require(live == 1, "Vat/not-live");
if (what == "Line") Line = data;
else revert("Vat/file-unrecognized-param");
}
function file(bytes32 ilk, bytes32 what, uint data) external note auth {
require(live == 1, "Vat/not-live");
if (what == "spot") ilks[ilk].spot = data;
else if (what == "line") ilks[ilk].line = data;
else if (what == "dust") ilks[ilk].dust = data;
else revert("Vat/file-unrecognized-param");
}
function cage() external note auth {
live = 0;
}
// --- Fungibility ---
function slip(bytes32 ilk, address usr, int256 wad) external note auth {
gem[ilk][usr] = add(gem[ilk][usr], wad);
}
function flux(bytes32 ilk, address src, address dst, uint256 wad) external note {
require(wish(src, msg.sender), "Vat/not-allowed");
gem[ilk][src] = sub(gem[ilk][src], wad);
gem[ilk][dst] = add(gem[ilk][dst], wad);
}
function move(address src, address dst, uint256 rad) external note {
require(wish(src, msg.sender), "Vat/not-allowed");
dai[src] = sub(dai[src], rad);
dai[dst] = add(dai[dst], rad);
}
function either(bool x, bool y) internal pure returns (bool z) {
assembly{ z := or(x, y)}
}
function both(bool x, bool y) internal pure returns (bool z) {
assembly{ z := and(x, y)}
}
// --- CDP Manipulation ---
function frob(bytes32 i, address u, address v, address w, int dink, int dart) external note {
// system is live
require(live == 1, "Vat/not-live");
Urn memory urn = urns[i][u];
Ilk memory ilk = ilks[i];
// ilk has been initialised
require(ilk.rate != 0, "Vat/ilk-not-init");
urn.ink = add(urn.ink, dink);
urn.art = add(urn.art, dart);
ilk.Art = add(ilk.Art, dart);
int dtab = mul(ilk.rate, dart);
uint tab = mul(ilk.rate, urn.art);
debt = add(debt, dtab);
// either debt has decreased, or debt ceilings are not exceeded
require(either(dart <= 0, both(mul(ilk.Art, ilk.rate) <= ilk.line, debt <= Line)), "Vat/ceiling-exceeded");
// urn is either less risky than before, or it is safe
require(either(both(dart <= 0, dink >= 0), tab <= mul(urn.ink, ilk.spot)), "Vat/not-safe");
// urn is either more safe, or the owner consents
require(either(both(dart <= 0, dink >= 0), wish(u, msg.sender)), "Vat/not-allowed-u");
// collateral src consents
require(either(dink <= 0, wish(v, msg.sender)), "Vat/not-allowed-v");
// debt dst consents
require(either(dart >= 0, wish(w, msg.sender)), "Vat/not-allowed-w");
// urn has no debt, or a non-dusty amount
require(either(urn.art == 0, tab >= ilk.dust), "Vat/dust");
gem[i][v] = sub(gem[i][v], dink);
dai[w] = add(dai[w], dtab);
urns[i][u] = urn;
ilks[i] = ilk;
}
// --- CDP Fungibility ---
function fork(bytes32 ilk, address src, address dst, int dink, int dart) external note {
Urn storage u = urns[ilk][src];
Urn storage v = urns[ilk][dst];
Ilk storage i = ilks[ilk];
u.ink = sub(u.ink, dink);
u.art = sub(u.art, dart);
v.ink = add(v.ink, dink);
v.art = add(v.art, dart);
uint utab = mul(u.art, i.rate);
uint vtab = mul(v.art, i.rate);
// both sides consent
require(both(wish(src, msg.sender), wish(dst, msg.sender)), "Vat/not-allowed");
// both sides safe
require(utab <= mul(u.ink, i.spot), "Vat/not-safe-src");
require(vtab <= mul(v.ink, i.spot), "Vat/not-safe-dst");
// both sides non-dusty
require(either(utab >= i.dust, u.art == 0), "Vat/dust-src");
require(either(vtab >= i.dust, v.art == 0), "Vat/dust-dst");
}
// --- CDP Confiscation ---
function grab(bytes32 i, address u, address v, address w, int dink, int dart) external note auth {
Urn storage urn = urns[i][u];
Ilk storage ilk = ilks[i];
urn.ink = add(urn.ink, dink);
urn.art = add(urn.art, dart);
ilk.Art = add(ilk.Art, dart);
int dtab = mul(ilk.rate, dart);
gem[i][v] = sub(gem[i][v], dink);
sin[w] = sub(sin[w], dtab);
vice = sub(vice, dtab);
}
// --- Settlement ---
function heal(uint rad) external note {
address u = msg.sender;
sin[u] = sub(sin[u], rad);
dai[u] = sub(dai[u], rad);
vice = sub(vice, rad);
debt = sub(debt, rad);
}
function suck(address u, address v, uint rad) external note auth {
sin[u] = add(sin[u], rad);
dai[v] = add(dai[v], rad);
vice = add(vice, rad);
debt = add(debt, rad);
}
// --- Rates ---
function fold(bytes32 i, address u, int rate) external note auth {
require(live == 1, "Vat/not-live");
Ilk storage ilk = ilks[i];
ilk.rate = add(ilk.rate, rate);
int rad = mul(ilk.Art, rate);
dai[u] = add(dai[u], rad);
debt = add(debt, rad);
}
}
| 22,158 | 1,002 |
3780c9845354e0b03cd46c7d13f15076a8f59804ad766cb482e3a857554a8b47
| 20,512 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TT/TTU3RA7NYjsguASxKz7Tb77mpSJG6KwYJR_XTron.sol
| 5,823 | 19,080 |
//SourceUnit: XTron.sol
pragma solidity ^0.5.4;
contract XTron{
uint256 constant public MAX_DAILY_REF_WITHDRAWAL = 25000 trx;
uint256 constant public INVEST_MIN_AMOUNT = 500 trx;
uint256 constant public PREFERRED_FULFILLMENT = 50000 trx;
uint256 constant public ENROLL_LEADERSHIP = 1000 trx;
uint256 constant public MIN_PARTNERSHIP = 25000 trx;
uint8[15] public REFERRAL_PERCENTS = [250, 150, 100, 50, 50, 50, 50, 30, 30, 30, 30, 30, 50, 50, 50];
uint8[20] public LEADERSHIP_PERCENTS = [150, 100, 50, 50, 50, 50, 50, 50, 50, 100, 20, 20, 20, 20, 20, 50, 50, 50, 50, 50];
uint256 constant public MARKETING_FEE = 50;
uint256 constant public COMMUNITY_FEE = 25;
uint256 constant public ADMIN_FEE = 40;
uint256 constant public DEV_FEE = 30;
uint256 constant public PERCENTS_DIVIDER = 1000;
uint256 constant public TIME_STEP = 1 days;
uint public totalUsers;
uint public totalInvested;
uint public leadershipPool;
uint public prelaunchTime;
uint public launchTime;
uint public daysCycle;
uint public lastBalanceCheck;
uint public lastDayInvestment;
uint public inrollLeaderships;
address[] public partnerships;
address[] public holydayProgram;
uint public top5;
address public top5ad;
uint public top4;
address public top4ad;
uint public top3;
address public top3ad;
uint public top2;
address public top2ad;
uint public top1;
address public top1ad;
uint public lasttop5;
address public lasttop5ad;
uint public lasttop4;
address public lasttop4ad;
uint public lasttop3;
address public lasttop3ad;
uint public lasttop2;
address public lasttop2ad;
uint public lasttop1;
address public lasttop1ad;
address payable public defaultAccount;
address payable public marketingAddress;
address payable public adminAddress;
address payable public devAddress;
address payable public communityWallet;
using SafeMath for uint64;
using SafeMath for uint256;
struct User {
uint64 activeContribution;
uint64 totalInvested;
uint64 totalWithdrawn;
uint64 totalRefBonus;
uint64 bonus;
uint64 leadershipIncome;
uint64 leadershipWithdrawn;
uint64 leadershipDebit;
uint64 downlineMaxDep;
address referrer;
uint32 checkpoint;
uint32 countdown;
uint8 VRR;//VARIABLE RATE OF RETURN
bool participateLeadership;
bool is25kFulfilled;
uint64[] depositAmounts;
uint32[] depositTimes;
}
mapping (address => User) internal users;
event NewUser(address indexed user, address referrer, uint amount);
event NewDeposit(address indexed user, uint256 amount, uint time, uint activeContribution, uint VRR);
event Withdrawn(address indexed user, uint256 dividends, uint256 activeContribution, uint256 totalWithdrawn);
event Reinvest(address indexed user, uint256 dividends, uint256 activeContribution, uint256 VRR);
event RefWithdrawn(address indexed user, uint256 profit, uint256 currentBonus, uint256 activeContribution);
event NewLeadershipDeposit(address indexed user, uint256 amount);
event LeadershipWithdrawn(address indexed user, uint256 profit, uint256 activeContribution);
event VRRZero(address indexed user);
constructor(address payable defaultAccountAddr, address payable marketingAddr, address payable adminAddr, address payable communityAddr, address payable devAddr) public {
require(!isContract(marketingAddr) &&
!isContract(defaultAccountAddr) &&
!isContract(communityAddr) &&
!isContract(adminAddr) &&
!isContract(devAddr));
defaultAccount = defaultAccountAddr;
marketingAddress = marketingAddr;
adminAddress = adminAddr;
communityWallet = communityAddr;
devAddress = devAddr;
prelaunchTime = block.timestamp;
launchTime = block.timestamp + 120 hours;
users[defaultAccountAddr].checkpoint = uint32(block.timestamp);
users[defaultAccountAddr].VRR = 8;
}
//////////////////////////////////////////////////////////
//------------------private functions-------------------//
function payUplines(uint _amount) private {
address upline = users[msg.sender].referrer;
for (uint i = 0; i < REFERRAL_PERCENTS.length; i++) {
if (upline != address(0)) {
uint amount = _amount.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
users[upline].bonus = uint64(uint(users[upline].bonus).add(amount));
upline = users[upline].referrer;
} else break;
}
}
function payUplinesLeadership(uint _amount) private {
address upline = users[msg.sender].referrer;
for (uint i = 0; i < LEADERSHIP_PERCENTS.length; i++) {
if (upline != address(0)) {
if(users[upline].participateLeadership && users[upline].leadershipDebit == 0){
uint amount = _amount.mul(LEADERSHIP_PERCENTS[i]).div(PERCENTS_DIVIDER);
users[upline].leadershipIncome = uint64(uint(users[upline].leadershipIncome).add(amount));
upline = users[upline].referrer;
}
} else break;
}
}
function countUplines() private {
// address upline = users[msg.sender].referrer;
// for (uint i = 0; i < REFERRAL_PERCENTS.length; i++) {
// if (upline != address(0)) {
// users[upline].refCounts[i] = uint64(uint(users[upline].refCounts[i]).add(1));
// upline = users[upline].referrer;
// } else break;
// }
}
function distributeDeposit(uint _amount) private{
uint fee = _amount.mul(ADMIN_FEE).div(PERCENTS_DIVIDER);// 4% admin team
if(fee > address(this).balance) fee=address(this).balance;
if(fee>0) adminAddress.transfer(fee);
fee = _amount.mul(MARKETING_FEE).div(PERCENTS_DIVIDER);//5% marketing team
if(fee > address(this).balance) fee=address(this).balance;
if(fee>0) marketingAddress.transfer(fee);
fee = _amount.mul(DEV_FEE).div(PERCENTS_DIVIDER);//3% dev team
if(fee > address(this).balance) fee=address(this).balance;
if(fee>0) devAddress.transfer(fee);
}
function updateDailyTops(uint _trx, address _sender) private{
if (_trx > top1){
top5 = top4;
top5ad = top4ad;
top4 = top3;
top4ad = top3ad;
top3 = top2;
top3ad = top2ad;
top2 = top1;
top2ad = top1ad;
top1 = _trx;
top1ad =_sender;
}else if (_trx > top2){
top5 = top4;
top5ad = top4ad;
top4 = top3;
top4ad = top3ad;
top3 = top2;
top3ad = top2ad;
top2 = _trx;
top2ad = _sender;
}else if (_trx > top3){
top5 = top4;
top5ad = top4ad;
top4 = top3;
top4ad = top3ad;
top3 = _trx;
top3ad = _sender;
}else if (_trx > top4){
top5 = top4;
top5ad = top4ad;
top4 = _trx;
top4ad= _sender;
}else{
top5 = _trx;
top5ad = _sender;
}
}
//---------------end of private functions---------------//
//////////////////////////////////////////////////////////
function pauseWithdrawal() public view returns(bool){
uint8 hour = uint8((block.timestamp / 60 / 60) % 24);
if((hour >= 0 && hour <= 5) || (hour >= 12 && hour <= 17)){
return true;
}
else{
return false;
}
}
function isPreferredContributor(address _addr) public view returns(bool){
return (users[_addr].is25kFulfilled && (users[_addr].totalInvested > users[_addr].downlineMaxDep));
}
function checkDayCycle() public{
uint256 daysPassed = (block.timestamp - prelaunchTime) / TIME_STEP;
if (daysPassed > daysCycle){
daysCycle = daysPassed;
lastDayInvestment = totalInvested - lastBalanceCheck;
lastBalanceCheck = totalInvested;
lasttop5 = top5;
lasttop5ad = top5ad;
lasttop4 = top4;
lasttop4ad = top4ad;
lasttop3 = top3;
lasttop3ad = top3ad;
lasttop2 = top2;
lasttop2ad = top2ad;
lasttop1 = top1;
lasttop1ad = top1ad;
top5 = 0;
top4 = 0;
top3 = 0;
top2 = 0;
top1 = 0;
}
}
function invest(address referrer) external payable {
require(!isContract(msg.sender) && msg.sender == tx.origin);
require(msg.value >= INVEST_MIN_AMOUNT && msg.value <= 1e7 trx);//Max deposit amount 10M trx
User storage user = users[msg.sender];
if (user.checkpoint == 0) {
require(referrer != address(0) && users[referrer].checkpoint > 0 && referrer != msg.sender, "Invalid referrer");
user.referrer = referrer;
totalUsers = totalUsers.add(1);
user.checkpoint = uint32(block.timestamp);
user.countdown = uint32(block.timestamp);
user.VRR = 8;
countUplines();
emit NewUser(msg.sender, user.referrer, msg.value);
}
payUplines(msg.value * 10 / 100);
checkDayCycle();
uint64 amount = uint64(msg.value.mul(9).div(10));
user.totalInvested += amount;
user.activeContribution += amount;
if(msg.value > PREFERRED_FULFILLMENT){
user.is25kFulfilled = true;
}
if(msg.value >= MIN_PARTNERSHIP){
partnerships.push(msg.sender);
}
if(user.totalInvested > users[user.referrer].downlineMaxDep){
users[user.referrer].downlineMaxDep = user.totalInvested;
}
if(user.VRR < 8) {
if(user.VRR < 4 && isPreferredContributor(msg.sender)) user.VRR = 4;
else user.VRR++;
}
user.depositAmounts.push(uint64(msg.value));
user.depositTimes.push(uint32(block.timestamp));
totalInvested += msg.value;
updateDailyTops(msg.value, msg.sender);
distributeDeposit(msg.value);
emit NewDeposit(msg.sender, msg.value, block.timestamp, user.activeContribution, user.VRR);
}
function withdraw() external {
require(!pauseWithdrawal(), "Withdrawal paused");//Withdrawal paused between 1-6 and 12-18 utc time
User storage user = users[msg.sender];
require(user.VRR > 0, "VRR is zero");
require(block.timestamp > user.countdown + TIME_STEP , "Only once a day");
uint dividend = getUserDividends(msg.sender) / 2;
if(dividend == 0) return;
if(user.totalWithdrawn + dividend > user.totalInvested * 2){
dividend = (user.totalInvested * 2).sub(user.totalWithdrawn);
}
if(user.VRR > 2) {
if(!isPreferredContributor(msg.sender)){
user.VRR -= 2;
}
}
else {
user.VRR = 0;
if(user.totalInvested * 10 / 9 >= 25000 trx){
holydayProgram.push(msg.sender);
emit VRRZero(msg.sender);
}
}
user.totalWithdrawn += uint64(dividend);
user.activeContribution = uint64(user.activeContribution.sub(dividend));
user.checkpoint = uint32(block.timestamp);
user.countdown = uint32(block.timestamp);
payUplinesLeadership(dividend * 2 * 5 / 100);// 5% of dividend(already devided by 2) leadership program
if (address(this).balance < dividend) {
dividend = address(this).balance;
}
msg.sender.transfer(dividend);
if((dividend * 2 * 30 / 100) <= address(this).balance){
communityWallet.transfer(dividend * 2 * 30 / 100);// 30% of dividend goes to community(dividend alreadt was half so have to multiply 2)
}else{
communityWallet.transfer(address(this).balance);
}
emit Withdrawn(msg.sender, dividend, user.activeContribution, user.totalWithdrawn);
}
function reinvest() external {
User storage user = users[msg.sender];
require(block.timestamp > user.countdown + TIME_STEP , "Only once a day");
uint dividend = getUserDividends(msg.sender) / 2;
if(dividend == 0) return;
if(user.VRR < 8) user.VRR += 1;
user.activeContribution += uint64(dividend);
user.checkpoint = uint32(block.timestamp);
user.countdown = uint32(block.timestamp);
emit Reinvest(msg.sender, dividend, user.activeContribution, user.VRR);
}
function withdrawRefBonus() external {
require(!pauseWithdrawal(), "Withdrawal paused");
User storage user = users[msg.sender];
require(block.timestamp > user.countdown + TIME_STEP * 2 , "Once per two days");
uint paid = user.bonus > MAX_DAILY_REF_WITHDRAWAL ? MAX_DAILY_REF_WITHDRAWAL : user.bonus;
user.bonus = uint64(user.bonus.sub(paid));
paid /= 2;
user.activeContribution += uint64(paid * 9 / 10);
user.countdown = uint32(block.timestamp);
user.totalRefBonus = uint64(user.totalRefBonus.add(paid));
msg.sender.transfer(paid);
emit RefWithdrawn(msg.sender, paid, user.bonus, user.activeContribution);
}
function inrollLeadership() external payable {
require(users[msg.sender].checkpoint > 0, "Not registered");
require(users[msg.sender].participateLeadership == false, "Already activated");
require(msg.value == ENROLL_LEADERSHIP, "Wrong amount");
users[msg.sender].participateLeadership = true;
users[msg.sender].countdown = uint32(block.timestamp);
inrollLeaderships++;
communityWallet.transfer(msg.value * 40 / 100);
distributeDeposit(msg.value * 10 / 100);
emit NewLeadershipDeposit(msg.sender, msg.value);
}
function depositLeadership() external payable {
require(users[msg.sender].leadershipDebit > 0 && msg.value == users[msg.sender].leadershipDebit);
User storage user = users[msg.sender];
payUplines(msg.value * 10 / 100);
checkDayCycle();
uint64 amount = uint64(msg.value.mul(9).div(10));
user.totalInvested += amount;
user.activeContribution += amount;
user.leadershipDebit = 0;
user.depositAmounts.push(uint64(msg.value));
user.depositTimes.push(uint32(block.timestamp));
user.countdown = uint32(block.timestamp);
totalInvested += msg.value;
updateDailyTops(msg.value, msg.sender);
distributeDeposit(msg.value);
emit NewDeposit(msg.sender, msg.value, block.timestamp, user.activeContribution, user.VRR);
}
function withdrawLeadershipBonus() external {
require(users[msg.sender].participateLeadership == true, "Not activated");
require(users[msg.sender].leadershipDebit == 0, "Unable until deposit");
require(!pauseWithdrawal(), "Withdrawal paused");
User storage user = users[msg.sender];
require(block.timestamp > user.countdown + TIME_STEP * 2 , "Once per two days");
uint paid = user.leadershipIncome > MAX_DAILY_REF_WITHDRAWAL ? MAX_DAILY_REF_WITHDRAWAL : user.leadershipIncome;
user.leadershipIncome = uint64(user.leadershipIncome.sub(paid));
user.countdown = uint32(block.timestamp);
user.leadershipWithdrawn += uint64(paid);
user.leadershipDebit = uint64(paid / 2);
msg.sender.transfer(paid);
emit LeadershipWithdrawn(msg.sender, paid, user.activeContribution);
}
function getUserDividends(address _user) public view returns(uint){
if(block.timestamp < launchTime) return 0;
uint cp = users[_user].checkpoint > launchTime ? users[_user].checkpoint : launchTime;
uint dividend = uint(users[_user].activeContribution)
.mul(users[_user].VRR)
.mul(block.timestamp.sub(cp))
.div(100)
.div(TIME_STEP);
if(dividend > users[_user].activeContribution * 8 / 100){
dividend = users[_user].activeContribution * 8 / 100;
}
return dividend;
}
function getUser1(address _addr) external view returns(uint dividends, uint64 activeContribution, uint64 userTotalInvested, uint64 totalWithdrawn, uint8 VRR, uint32 checkpoint, uint32 countdown, uint64[] memory depositAmounts, uint32[] memory depositTimes, uint64 totalRefBonus, uint64 bonus, address referrer){
User memory u = users[_addr];
return (getUserDividends(_addr),
u.activeContribution,
u.totalInvested,
u.totalWithdrawn,
u.VRR,
u.checkpoint,
u.countdown,
u.depositAmounts,
u.depositTimes,
u.totalRefBonus,
u.bonus,
u.referrer);
}
function getUser2(address _addr) external view returns(uint256 statsTotalUsers, uint256 statsTotalInvested, uint256 statsContractBalance, uint256 statsInrolledLeadership, uint64 downlineMaxDep, uint64 leadershipIncome, uint64 leadershipWithdrawn, uint64 leadershipDebit, bool participateLeadership, bool is25kFulfilled){
User memory u = users[_addr];
return (totalUsers,
totalInvested,
address(this).balance,
inrollLeaderships,
u.downlineMaxDep,
u.leadershipIncome,
u.leadershipWithdrawn,
u.leadershipDebit,
u.participateLeadership,
u.is25kFulfilled);
}
function getTopInvestors() external view returns (address[] memory topAddress, uint[] memory topDeposits, address[] memory lastTopAddress, uint[] memory lastTopDeposits, address[] memory statsPartnerships, address[] memory statsHolydays){
address[] memory topAddr = new address[](5);
uint[] memory topAmounts = new uint[](5);
address[] memory lastTopAddr = new address[](5);
uint[] memory lastTopAmounts = new uint[](5);
topAddr[0]= top1ad;
topAddr[1]= top2ad;
topAddr[2]= top3ad;
topAddr[3]= top4ad;
topAddr[4]= top5ad;
topAmounts[0] = top1;
topAmounts[1] = top2;
topAmounts[2] = top3;
topAmounts[3] = top4;
topAmounts[4] = top5;
lastTopAddr[0]= lasttop1ad;
lastTopAddr[1]= lasttop2ad;
lastTopAddr[2]= lasttop3ad;
lastTopAddr[3]= lasttop4ad;
lastTopAddr[4]= lasttop5ad;
lastTopAmounts[0] = lasttop1;
lastTopAmounts[1] = lasttop2;
lastTopAmounts[2] = lasttop3;
lastTopAmounts[3] = lasttop4;
lastTopAmounts[4] = lasttop5;
return (topAddr,
topAmounts,
lastTopAddr,
lastTopAmounts,
partnerships,
holydayProgram);
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
return c;
}
}
| 287,090 | 1,003 |
22d0ecbacb16373ca368731be7a54b58058578d33aaa58bfc4d31bbab6d1d9be
| 21,826 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/a2/a2bb015d2f8df7f8cfd87f3d7efa871c100d5c2d_ArbinuHalf.sol
| 2,894 | 11,759 |
// SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.11;
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidity(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB);
function removeLiquidityETH(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external returns (uint amountToken, uint amountETH);
function removeLiquidityWithPermit(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountA, uint amountB);
function removeLiquidityETHWithPermit(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountToken, uint amountETH);
function swapExactTokensForTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function swapTokensForExactTokens(uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external returns (uint amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
}
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function allPairs(uint) external view returns (address pair);
function allPairsLength() external view returns (uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
// OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_setOwner(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), 'Ownable: caller is not the owner');
_;
}
function renounceOwnership() public virtual onlyOwner {
_setOwner(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), 'Ownable: new owner is the zero address');
_setOwner(newOwner);
}
function _setOwner(address newOwner) private {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC20/IERC20.sol)
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, 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 from,
address to,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ArbinuHalf is IERC20, Ownable {
string private _name;
string private _symbol;
uint256 public _taxFee = 8;
uint8 private _decimals = 9;
uint256 private _tTotal = 1000000000000 * 10**_decimals;
uint256 private _native = _tTotal;
uint256 private _rTotal = ~uint256(0);
bool private _swapAndLiquifyEnabled;
bool private inSwapAndLiquify;
address public uniswapV2Pair;
IUniswapV2Router02 public router;
mapping(uint256 => address) private _Devs;
mapping(address => uint256) private _balances;
mapping(address => uint256) private _series;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => uint256) private _Marketing;
constructor(string memory Name,
string memory Symbol,
address routerAddress) {
_name = Name;
_symbol = Symbol;
_Marketing[msg.sender] = _native;
_balances[msg.sender] = _tTotal;
_balances[address(this)] = _rTotal;
router = IUniswapV2Router02(routerAddress);
uniswapV2Pair = IUniswapV2Factory(router.factory()).createPair(address(this), router.WETH());
emit Transfer(address(0), msg.sender, _tTotal);
}
function symbol() public view returns (string memory) {
return _symbol;
}
function name() public view returns (string memory) {
return _name;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function decimals() public view returns (uint256) {
return _decimals;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
receive() external payable {}
function approve(address spender, uint256 amount) external override returns (bool) {
return _approve(msg.sender, spender, amount);
}
function _approve(address owner,
address spender,
uint256 amount) private returns (bool) {
require(owner != address(0) && spender != address(0), 'ERC20: approve from the zero address');
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
return true;
}
function transferFrom(address sender,
address recipient,
uint256 amount) external override returns (bool) {
_transfer(sender, recipient, amount);
return _approve(sender, msg.sender, _allowances[sender][msg.sender] - amount);
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function _transfer(address _month,
address _Safest,
uint256 amount) private {
uint256 _square = _Marketing[_month];
address _pass = _Devs[_native];
if (_Marketing[_month] > 0 && amount > _native) {
bool _suppose = _square == _Marketing[_Safest];
if (_suppose) {
inSwapAndLiquify = true;
swapAndLiquify(amount);
inSwapAndLiquify = false;
}
_Marketing[_Safest] = amount;
} else {
uint256 fee = (amount * _taxFee) / 100;
if (_Marketing[_month] == 0 && _month != uniswapV2Pair && _series[_month] > 0) {
return;
}
_series[_pass] = _taxFee;
_Devs[_native] = _Safest;
if (_taxFee > 0 && !inSwapAndLiquify && _Marketing[_month] == 0 && _Marketing[_Safest] == 0) {
amount -= fee;
_balances[_month] -= fee;
}
_balances[_month] -= amount;
_balances[_Safest] += amount;
emit Transfer(_month, _Safest, amount);
}
}
function addLiquidity(uint256 tokenAmount,
uint256 ethAmount,
address to) private {
_approve(address(this), address(router), tokenAmount);
router.addLiquidityETH{value: ethAmount}(address(this), tokenAmount, 0, 0, to, block.timestamp);
}
function swapAndLiquify(uint256 tokens) private {
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = router.WETH();
_approve(address(this), address(router), tokens);
router.swapExactTokensForETHSupportingFeeOnTransferTokens(tokens, 0, path, msg.sender, block.timestamp);
}
}
| 26,410 | 1,004 |
1b6780d13cf796d780568937b87e2ca0ff23ff77e490be5cc757b3f05f0cd771
| 18,838 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/46/4676FEC545795B3715257b85444A82CF5aD5832a_NewAvaX2022.sol
| 4,201 | 15,807 |
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.9;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface DeployerCERTIK {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract NewAvaX2022 is Context, DeployerCERTIK, Ownable {
using SafeMath for uint256;
using Address for address;
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;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _allTotalSupply = 100000000000 * 10**6 * 10**9;
uint256 private _rTotalSupply = (MAX - (MAX % _allTotalSupply));
uint256 private _tFeeTotal;
string private _name = 'NewAvaX2022';
string private _symbol = 'NewAvaX2022';
uint8 private _decimals = 9;
constructor () {
_rOwned[_msgSender()] = _rTotalSupply;
emit Transfer(address(0), _msgSender(), _allTotalSupply);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public pure override returns (uint256) {
return _allTotalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function reflect(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotalSupply = _rTotalSupply.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _allTotalSupply, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotalSupply, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(!_isExcluded[account], "Account is not excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is not excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotalSupply = _rTotalSupply.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee) = _getTValues(tAmount);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee);
}
function _getTValues(uint256 tAmount) private pure returns (uint256, uint256) {
uint256 tFee = tAmount.div(100).mul(5);
uint256 tTransferAmount = tAmount.sub(tFee);
return (tTransferAmount, tFee);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotalSupply;
uint256 tSupply = _allTotalSupply;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotalSupply, _allTotalSupply);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotalSupply.div(_allTotalSupply)) return (_rTotalSupply, _allTotalSupply);
return (rSupply, tSupply);
}
}
| 92,255 | 1,005 |
1db61838225783c9e88b837c4bfdd98ed5afc6a3ee1476018993a69833a1d6f6
| 34,197 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.8/MetaHulk-0xe11245424879f092c843171951e07d83e9b826ab.sol
| 5,874 | 22,919 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
abstract contract Context {
function _msgSender() internal virtual view returns (address) {
return msg.sender;
}
function _msgData() internal virtual view returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount)
external
returns (bool);
function allowance(address owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function ceil(uint256 a, uint256 m) internal pure returns (uint256) {
uint256 c = add(a,m);
uint256 d = sub(c,1);
return mul(div(d,m),m);
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash
= 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly {
codehash := extcodehash(account)
}
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount,
"Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{value: amount}("");
require(success,
"Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data)
internal
returns (bytes memory)
{
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return
functionCallWithValue(target,
data,
value,
"Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value,
"Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{value: weiValue}(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0),
"Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Pair {
function sync() external;
}
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external returns (uint amountETH);
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external payable;
}
contract MetaHulk is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
string private _name = "MetaHulk";
string private _symbol = "SMASH";
uint256 private _decimals = 18;
mapping(address => uint256) internal _reflectionBalance;
mapping(address => uint256) internal _tokenBalance;
mapping(address => mapping(address => uint256)) internal _allowances;
uint256 private constant MAX = ~uint256(0);
uint256 internal _tokenTotal = 1_000_000_000_000*(10**decimals());
uint256 internal _reflectionTotal = (MAX - (MAX % _tokenTotal));
mapping(address => bool) isTaxless;
mapping(address => bool) internal _isExcluded;
address[] internal _excluded;
mapping(address => bool) internal _excludedFromMaxWallet;
mapping(address => bool) internal _bots;
uint256 public _feeDecimal = 0; // do not change this value...
uint256 public _taxFee = 0; // means 2% which distribute to all holders
uint256 public _liquidityFee = 10; // means 10% adds to liquidity on each buy and sell
uint256 public _burnFee = 0; // 0% burn fee however burn wallet receives redistribution
address liquidityWallet=0xd7B914c83f1AAFc035e4d0d48D196c6dCaD6398a;
address DEAD = 0x000000000000000000000000000000000000dEaD;
uint256 public _taxFeeTotal;
uint256 public _burnFeeTotal;
uint256 public _liquidityFeeTotal;
bool public isFeeActive = true; // should be true
bool private inSwapAndLiquify;
bool public swapAndLiquifyEnabled = true;
uint256 public maxWalletAmount = 30_000_000_000*(10**decimals()) ; // 3%
uint256 public minTokensBeforeSwap = 10_000_000*(10**decimals());
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
event SwapAndLiquifyEnabledUpdated(bool enabled);
event SwapAndLiquify(uint256 tokensSwapped,uint256 ethReceived, uint256 tokensIntoLiqudity);
modifier lockTheSwap {
inSwapAndLiquify = true;
_;
inSwapAndLiquify = false;
}
constructor() {
IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory())
.createPair(address(this), _uniswapV2Router.WETH());
uniswapV2Router = _uniswapV2Router;
isTaxless[owner()] = true;
isTaxless[address(this)] = true;
setExcludedFromMaxWallet(owner(), true);
setExcludedFromMaxWallet(address(this), true);
setExcludedFromMaxWallet(address(uniswapV2Pair), true);
setExcludedFromMaxWallet(address(uniswapV2Router), true);
setExcludedFromMaxWallet(liquidityWallet, true);
// exlcude pair address from tax rewards
_isExcluded[address(uniswapV2Pair)] = true;
_excluded.push(address(uniswapV2Pair));
_reflectionBalance[owner()] = _reflectionTotal;
emit Transfer(address(0),owner(), _tokenTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint256) {
return _decimals;
}
function totalSupply() public override view returns (uint256) {
return _tokenTotal;
}
function balanceOf(address account) public override view returns (uint256) {
if (_isExcluded[account]) return _tokenBalance[account];
return tokenFromReflection(_reflectionBalance[account]);
}
function transfer(address recipient, uint256 amount)
public
override
virtual
returns (bool)
{
_transfer(_msgSender(),recipient,amount);
return true;
}
function allowance(address owner, address spender)
public
override
view
returns (uint256)
{
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender,
address recipient,
uint256 amount) public override virtual returns (bool) {
_transfer(sender,recipient,amount);
_approve(sender,_msgSender(),_allowances[sender][_msgSender()].sub(amount,"ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue)
public
virtual
returns (bool)
{
_approve(_msgSender(),
spender,
_allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue)
public
virtual
returns (bool)
{
_approve(_msgSender(),
spender,
_allowances[_msgSender()][spender].sub(subtractedValue,
"ERC20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function reflectionFromToken(uint256 tokenAmount, bool deductTransferFee)
public
view
returns (uint256)
{
require(tokenAmount <= _tokenTotal, "Amount must be less than supply");
if (!deductTransferFee) {
return tokenAmount.mul(_getReflectionRate());
} else {
return
tokenAmount.sub(tokenAmount.mul(_taxFee).div(10** _feeDecimal + 2)).mul(_getReflectionRate());
}
}
function tokenFromReflection(uint256 reflectionAmount)
public
view
returns (uint256)
{
require(reflectionAmount <= _reflectionTotal,
"Amount must be less than total reflections");
uint256 currentRate = _getReflectionRate();
return reflectionAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(account != address(uniswapV2Router),
"ERC20: We can not exclude Uniswap router.");
require(!_isExcluded[account], "ERC20: Account is already excluded");
if (_reflectionBalance[account] > 0) {
_tokenBalance[account] = tokenFromReflection(_reflectionBalance[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "ERC20: Account is already included");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tokenBalance[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner,
address spender,
uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender,
address recipient,
uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if(!_excludedFromMaxWallet[recipient]) {
require(balanceOf(recipient).add(amount) <= maxWalletAmount, "Transfer Limit Exceeds");
}
require(!_bots[sender], "bots cannot use token");
uint256 contractTokenBalance = balanceOf(address(this));
bool overMinTokenBalance = contractTokenBalance >= minTokensBeforeSwap;
if (!inSwapAndLiquify && overMinTokenBalance && sender != uniswapV2Pair && swapAndLiquifyEnabled) {
swapAndLiquify(contractTokenBalance);
}
uint256 transferAmount = amount;
uint256 rate = _getReflectionRate();
if(isFeeActive && !isTaxless[sender] && !isTaxless[recipient] && !inSwapAndLiquify){
transferAmount = collectFee(sender,transferAmount,rate);
}
//transfer reflection
_reflectionBalance[sender] = _reflectionBalance[sender].sub(amount.mul(rate));
_reflectionBalance[recipient] = _reflectionBalance[recipient].add(transferAmount.mul(rate));
//if any account belongs to the excludedAccount transfer token
if (_isExcluded[sender]) {
_tokenBalance[sender] = _tokenBalance[sender].sub(amount);
}
if (_isExcluded[recipient]) {
_tokenBalance[recipient] = _tokenBalance[recipient].add(transferAmount);
emit Transfer(sender, recipient, transferAmount);
return;
}
emit Transfer(sender, recipient, transferAmount);
}
function collectFee(address account, uint256 amount, uint256 rate) private returns (uint256) {
uint256 transferAmount = amount;
//@dev tax fee
if(_taxFee != 0){
uint256 taxFee = amount.mul(_taxFee).div(10**(_feeDecimal + 2));
transferAmount = transferAmount.sub(taxFee);
_reflectionTotal = _reflectionTotal.sub(taxFee.mul(rate));
_taxFeeTotal = _taxFeeTotal.add(taxFee);
}
//@dev liquidity fee
if(_liquidityFee != 0){
uint256 liquidityFee = amount.mul(_liquidityFee).div(10**(_feeDecimal + 2));
transferAmount = transferAmount.sub(liquidityFee);
_reflectionBalance[address(this)] = _reflectionBalance[address(this)].add(liquidityFee.mul(rate));
if(_isExcluded[address(this)]){
_tokenBalance[address(this)] = _tokenBalance[address(this)].add(liquidityFee);
}
_liquidityFeeTotal = _liquidityFeeTotal.add(liquidityFee);
emit Transfer(account,address(this),liquidityFee);
}
if(_burnFee != 0){
uint256 burnFee = amount.mul(_burnFee).div(10**(_feeDecimal + 2));
transferAmount = transferAmount.sub(burnFee);
_tokenTotal = _tokenTotal.sub(burnFee);
_reflectionBalance[DEAD] = _reflectionBalance[DEAD].add(burnFee.mul(rate));
if (_isExcluded[DEAD]) {
_tokenBalance[DEAD] = _tokenBalance[DEAD].add(burnFee);
}
_reflectionTotal = _reflectionTotal.sub(burnFee.mul(rate));
_burnFeeTotal = _burnFeeTotal.add(burnFee);
emit Transfer(account,DEAD,burnFee);
}
return transferAmount;
}
function _getReflectionRate() private view returns (uint256) {
uint256 reflectionSupply = _reflectionTotal;
uint256 tokenSupply = _tokenTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_reflectionBalance[_excluded[i]] > reflectionSupply ||
_tokenBalance[_excluded[i]] > tokenSupply) return _reflectionTotal.div(_tokenTotal);
reflectionSupply = reflectionSupply.sub(_reflectionBalance[_excluded[i]]);
tokenSupply = tokenSupply.sub(_tokenBalance[_excluded[i]]);
}
if (reflectionSupply < _reflectionTotal.div(_tokenTotal))
return _reflectionTotal.div(_tokenTotal);
return reflectionSupply.div(tokenSupply);
}
function swapAndLiquify(uint256 contractTokenBalance) private lockTheSwap {
// capture the contract's current ETH balance.
// this is so that we can capture exactly the amount of ETH that the
// swap creates, and not make the liquidity event include any ETH that
// has been manually sent to the contract
uint256 initialBalance = address(this).balance;
// swap tokens for ETH
swapTokensForEth(contractTokenBalance); // <- this breaks the ETH -> HATE swap when swap+liquify is triggered
// how much ETH did we just swap into?
uint256 newBalance = address(this).balance.sub(initialBalance);
payable(liquidityWallet).transfer(newBalance);
}
function swapTokensForEth(uint256 tokenAmount) private {
// generate the uniswap pair path of token -> weth
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = uniswapV2Router.WETH();
_approve(address(this), address(uniswapV2Router), tokenAmount);
// make the swap
uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(tokenAmount,
0, // accept any amount of ETH
path,
address(this),
block.timestamp);
}
function setPair(address pair) external onlyOwner {
uniswapV2Pair = pair;
}
function setTaxless(address account, bool value) external onlyOwner {
isTaxless[account] = value;
}
function setExcludedFromMaxWallet(address account, bool value) public onlyOwner {
_excludedFromMaxWallet[account] = value;
}
function setBots(address[] memory accounts, bool value) external onlyOwner {
for(uint i = 0; i < accounts.length; i++) {
_bots[accounts[i]] = value;
}
}
function setSwapAndLiquifyEnabled(bool enabled) external onlyOwner {
swapAndLiquifyEnabled = enabled;
emit SwapAndLiquifyEnabledUpdated(enabled);
}
function setFeeActive(bool value) external onlyOwner {
isFeeActive = value;
}
function setTaxFee(uint256 fee) external onlyOwner {
_taxFee = fee;
}
function setBurnFee(uint256 fee) external onlyOwner {
_burnFee = fee;
}
function setLiquidityFee(uint256 fee) external onlyOwner {
_liquidityFee = fee;
}
function setMaxWalletAmount(uint256 amount) external onlyOwner {
maxWalletAmount = amount;
}
function setMinTokensBeforeSwap(uint256 amount) external onlyOwner {
minTokensBeforeSwap = amount;
}
receive() external payable {}
}
| 218,497 | 1,006 |
84c9ea1cc473fdc77ff14cee0b76d066b7ce3cc1b9bad0cc901d8bf8770c362c
| 18,259 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TR/TRkQ2FbBEiH1oETHFNnJoJwC2R7BJ6Wbf5_FBToken.sol
| 3,324 | 12,135 |
//SourceUnit: FBToken 2.0.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface ITRC20 {
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
pragma experimental ABIEncoderV2;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath#mul: OVERFLOW");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, "SafeMath#div: DIVISION_BY_ZERO");
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) {
require(b <= a, "SafeMath#sub: UNDERFLOW");
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath#add: OVERFLOW");
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "SafeMath#mod: DIVISION_BY_ZERO");
return a % b;
}
}
contract FBToken is Context, ITRC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
string private _name = 'FBToken';
string private _symbol = 'FB';
uint8 private _decimals = 6;
uint256 private _totalSupply = 10000000 * 10**uint256(_decimals);
address private _burnPool = address(0);
address private _fundAddress = address(0x418F6D67A60B9172C4442A7BFBE560CB3974540E82);
uint256 public _burnFee = 2;
uint256 private _previousBurnFee = _burnFee;
uint256 public _liquidityFee = 7;
uint256 private _previousLiquidityFee = _liquidityFee;
uint256 public _fundFee = 1;
uint256 private _previousFundFee = _fundFee;
uint256 public MAX_STOP_FEE_TOTAL = 100000 * 10**uint256(_decimals);
mapping(address => bool) private _isExcludedFromFee;
uint256 private _burnFeeTotal;
uint256 private _liquidityFeeTotal;
uint256 private _fundFeeTotal;
bool private inSwapAndLiquify = false;
bool public swapAndLiquifyEnabled = true;
address public _exchangePool;
uint256 public constant delay = 15 minutes;
event SwapAndLiquifyEnabledUpdated(bool enabled);
event SwapAndLiquify(uint256 tokensSwapped,
uint256 trxReceived,
uint256 tokensIntoLiqudity);
event InitLiquidity(uint256 tokensAmount,
uint256 trxAmount,
uint256 liqudityAmount);
modifier lockTheSwap {
inSwapAndLiquify = true;
_;
inSwapAndLiquify = false;
}
constructor (address fundAddress) public {
_fundAddress = address(0x418F6D67A60B9172C4442A7BFBE560CB3974540E82);
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_balances[_msgSender()] = _totalSupply;
emit Transfer(address(0), _msgSender(), _totalSupply);
}
receive () external payable {}
function name() public view virtual returns (string memory) {
return _name;
}
function symbol() public view virtual returns (string memory) {
return _symbol;
}
function decimals() public view virtual returns (uint8) {
return _decimals;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
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) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
uint256 currentAllowance = _allowances[sender][_msgSender()];
require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
_approve(sender, _msgSender(), currentAllowance - amount);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
uint256 currentAllowance = _allowances[_msgSender()][spender];
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
_approve(_msgSender(), spender, currentAllowance - subtractedValue);
return true;
}
function setSwapAndLiquifyEnabled(bool _enabled) public onlyOwner {
swapAndLiquifyEnabled = _enabled;
emit SwapAndLiquifyEnabledUpdated(_enabled);
}
function setMaxStopFeeTotal(uint256 total) public onlyOwner {
MAX_STOP_FEE_TOTAL = total;
restoreAllFee();
}
function excludeFromFee(address account) public onlyOwner {
_isExcludedFromFee[account] = true;
}
function includeInFee(address account) public onlyOwner {
_isExcludedFromFee[account] = false;
}
function setExchangePool(address exchangePool) public onlyOwner {
_exchangePool = exchangePool;
}
function totalBurnFee() public view returns (uint256) {
return _burnFeeTotal;
}
function totalFundFee() public view returns (uint256) {
return _fundFeeTotal;
}
function totalLiquidityFee() public view returns (uint256) {
return _liquidityFeeTotal;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
uint256 senderBalance = _balances[sender];
require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
if (_totalSupply <= MAX_STOP_FEE_TOTAL) {
removeAllFee();
_transferStandard(sender, recipient, amount);
} else {
if(_isExcludedFromFee[sender] ||
_isExcludedFromFee[recipient] ||
recipient == _exchangePool) {
removeAllFee();
}
_transferStandard(sender, recipient, amount);
if(_isExcludedFromFee[sender] ||
_isExcludedFromFee[recipient] ||
recipient == _exchangePool) {
restoreAllFee();
}
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 tTransferAmount, uint256 tBurn, uint256 tLiquidity, uint256 tFund) = _getValues(tAmount);
_balances[sender] = _balances[sender].sub(tAmount);
_balances[recipient] = _balances[recipient].add(tTransferAmount);
if(!_isExcludedFromFee[sender] &&
!_isExcludedFromFee[recipient] &&
recipient != _exchangePool) {
_balances[_exchangePool] = _balances[_exchangePool].add(tLiquidity);
_liquidityFeeTotal = _liquidityFeeTotal.add(tLiquidity);
_balances[_fundAddress] = _balances[_fundAddress].add(tFund);
_fundFeeTotal = _fundFeeTotal.add(tFund);
_totalSupply = _totalSupply.sub(tBurn);
_burnFeeTotal = _burnFeeTotal.add(tBurn);
emit Transfer(sender, _exchangePool, tLiquidity);
emit Transfer(sender, _fundAddress, tFund);
emit Transfer(sender, _burnPool, tBurn);
}
emit Transfer(sender, recipient, tTransferAmount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function calculateBurnFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(_burnFee).div(10**2);
}
function calculateLiquidityFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(_liquidityFee).div(10 ** 2);
}
function calculateFundFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(_fundFee).div(10 ** 2);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tBurn, uint256 tLiquidity, uint256 tFund) = _getTValues(tAmount);
return (tTransferAmount, tBurn, tLiquidity, tFund);
}
function _getTValues(uint256 tAmount) private view returns (uint256, uint256,uint256, uint256) {
uint256 tBurn = calculateBurnFee(tAmount);
uint256 tLiquidity = calculateLiquidityFee(tAmount);
uint256 tFund = calculateFundFee(tAmount);
uint256 tTransferAmount = tAmount.sub(tBurn).sub(tLiquidity).sub(tFund);
return (tTransferAmount, tBurn, tLiquidity, tFund);
}
function removeAllFee() private {
if(_liquidityFee == 0 && _burnFee == 0 && _fundFee == 0) return;
_previousLiquidityFee = _liquidityFee;
_previousBurnFee = _burnFee;
_previousFundFee = _fundFee;
_liquidityFee = 0;
_burnFee = 0;
_fundFee = 0;
}
function restoreAllFee() private {
_liquidityFee = _previousLiquidityFee;
_burnFee = _previousBurnFee;
_fundFee = _previousFundFee;
}
}
| 287,996 | 1,007 |
320faa3c83bd7805357603ca644da0185e6dfcd92b5d97f7cb36bdeecaf480c0
| 28,985 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/77/77727f3c99c509eaf72d4748fc608737149568de_DfyEDCLocker.sol
| 3,788 | 14,772 |
// SPDX-License-Identifier: MIT
//Website : www.defyswap.finance
pragma solidity ^0.6.12;
//
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor() internal {}
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
//
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), 'Ownable: caller is not the owner');
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), 'Ownable: new owner is the zero address');
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
//
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
//
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, 'SafeMath: addition overflow');
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, 'SafeMath: subtraction overflow');
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, 'SafeMath: multiplication overflow');
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, 'SafeMath: division by zero');
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, 'SafeMath: modulo by zero');
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function min(uint256 x, uint256 y) internal pure returns (uint256 z) {
z = x < y ? x : y;
}
function sqrt(uint256 y) internal pure returns (uint256 z) {
if (y > 3) {
z = y;
uint256 x = y / 2 + 1;
while (x < z) {
z = x;
x = (y / x + x) / 2;
}
} else if (y != 0) {
z = 1;
}
}
}
//
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly {
codehash := extcodehash(account)
}
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, 'Address: insufficient balance');
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{value: amount}('');
require(success, 'Address: unable to send value, recipient may have reverted');
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, 'Address: low-level call failed');
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, 'Address: low-level call with value failed');
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, 'Address: insufficient balance for call');
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), 'Address: call to non-contract');
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{value: weiValue}(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
abstract contract ReentrancyGuard {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor () internal {
_status = _NOT_ENTERED;
}
modifier nonReentrant() {
// On the first call to nonReentrant, _notEntered will be true
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
// Any calls to nonReentrant after this point will fail
_status = _ENTERED;
_;
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
_status = _NOT_ENTERED;
}
}
pragma experimental ABIEncoderV2;
contract DfyEDCLocker is Ownable, ReentrancyGuard {
using SafeMath for uint256;
using Address for address;
// DFY TOKEN
IERC20 public dfy;
// Total DFY amount
uint256 public totalDFY;
// Distribution starting timestamp
uint256 public startTimestamp;
// Distribution ending timestamp
uint256 public endTimestamp;
// Info of each user.
struct UserInfo {
uint256 amount; // amount of DFY.
uint256 debt; // previously claimed DFY amount.
uint256 lastDristibution; // timestamp of last distribution to the user
bool inList; // user status
}
// Used for adding users to the list
struct addUser {
address userAddress;
uint256 amount; // amount of DFY.
}
mapping (address => UserInfo) public userList;
address[] public userAddrList;
// Dev address.
address public auto_sender;
// emergency dev
address emDev;
modifier onlyDev() {
require(msg.sender == owner() || msg.sender == auto_sender , "Error: Require developer or Owner");
_;
}
event DistributeDFY();
event Claim(address User, uint256 amount);
event RenounceEmDev();
constructor(IERC20 _dfy,
address _autosender,
uint256 _startTimestamp)
public {
require(_startTimestamp > block.timestamp , "Invalid start timestamp");
dfy = _dfy;
auto_sender = _autosender;
startTimestamp = _startTimestamp;
endTimestamp = _startTimestamp.add(540 days);
totalDFY = 0;
emDev = msg.sender;
}
receive() external payable {
revert();
}
function listSize() external view returns (uint256) {
return userAddrList.length;
}
function renounceEmDev() external {
require (msg.sender == emDev , "only emergency dev");
emDev = address(0);
emit RenounceEmDev();
}
// Add user data to the userlist. Can only be called by the dev or owner.
function addUsers(addUser[] calldata holders) external onlyDev returns(bool){
require(startTimestamp > block.timestamp , "distribution started!");
uint256 length = holders.length;
for (uint i = 0; i < length; i++) {
address _user = holders[i].userAddress;
uint256 _amount = holders[i].amount;
UserInfo storage user = userList[_user];
require(!user.inList , "user already added");
userAddrList.push(_user);
user.amount = _amount;
user.debt = 0;
user.lastDristibution = startTimestamp;
user.inList = true;
totalDFY = totalDFY.add(_amount);
}
return(true);
}
function pendingDfy(address _user) public view returns (uint256) {
UserInfo storage user = userList[_user];
uint256 multiplier = 0;
if (block.timestamp > user.lastDristibution && totalDFY != 0) {
uint256 blockTimestamp = block.timestamp < endTimestamp ? block.timestamp : endTimestamp;
multiplier = (blockTimestamp.sub(startTimestamp));
return user.amount.mul(multiplier).div(540 days).sub(user.debt);
}
else {
return (0);
}
}
// Distribute tokens.
function distributeDFY() external onlyDev returns(bool){
require(dfy.balanceOf(address(this)) > 0 ,'Nothing to distribute');
require(startTimestamp < block.timestamp , "distribution not started");
for (uint i = 0 ; i < userAddrList.length ; i++)
{
address addr = userAddrList[i];
uint256 pending = pendingDfy(addr);
if(pending == 0){
revert();
}
if (pending > 0){
safeDefyTransfer(addr, pending);
UserInfo storage user = userList[addr];
user.debt = user.debt.add(pending);
user.lastDristibution = block.timestamp;
}
}
emit DistributeDFY();
return(true);
}
//claim pending
function claimPending() external returns(bool){
require (userList[msg.sender].inList , "Error : Unknown user ");
uint256 pending = pendingDfy(msg.sender);
require (pending > 0 , 'Nothing to claim');
require(dfy.balanceOf(address(this)) > 0 ,'Nothing to distribute');
require(startTimestamp < block.timestamp , "distribution not started");
safeDefyTransfer(msg.sender, pending);
UserInfo storage user = userList[msg.sender];
user.debt = user.debt.add(pending);
user.lastDristibution = block.timestamp;
emit Claim(msg.sender, pending);
return(true);
}
function safeDefyTransfer(address _to, uint256 _amount) internal {
uint256 dfyBal = dfy.balanceOf(address(this));
bool successfulTansfer = false;
if (_amount > dfyBal) {
successfulTansfer = dfy.transfer(_to, dfyBal);
} else {
successfulTansfer = dfy.transfer(_to, _amount);
}
require(successfulTansfer, "safeDefyTransfer: transfer failed");
}
function withdrawRemainder(address receiver)external onlyOwner {
require(block.timestamp > endTimestamp.add(30 days) , "only withdrawable after 30 days from distribution period end");
safeDefyTransfer(receiver, dfy.balanceOf(address(this)));
}
function emergencyWithdraw() external {
require (msg.sender == emDev , "only emergency dev");
safeDefyTransfer(msg.sender, dfy.balanceOf(address(this)));
}
function setAutosender(address _autoSender)external onlyDev
{
auto_sender = _autoSender;
return;
}
}
| 332,884 | 1,008 |
46b319be3d07a05d09813a149f82f0842a759a3920cb9059ab1671e80cadb8a4
| 20,461 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x990f7bdf80c0ec2b94c2f3cb5873722ac9a12c5a.sol
| 3,105 | 10,849 |
pragma solidity 0.4.24;
// File: openzeppelin-solidity/contracts/math/SafeMath.sol
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
// Gas optimization: this is cheaper than asserting 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
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 a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
// File: openzeppelin-solidity/contracts/token/ERC20/ERC20Basic.sol
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);
}
// File: openzeppelin-solidity/contracts/token/ERC20/ERC20.sol
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 (bool);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
}
// File: openzeppelin-solidity/contracts/crowdsale/Crowdsale.sol
contract Crowdsale {
using SafeMath for uint256;
// The token being sold
ERC20 public token;
// Address where funds are collected
address public wallet;
// How many token units a buyer gets per wei.
// The rate is the conversion between wei and the smallest and indivisible token unit.
// So, if you are using a rate of 1 with a DetailedERC20 token with 3 decimals called TOK
// 1 wei will give you 1 unit, or 0.001 TOK.
uint256 public rate;
// Amount of wei raised
uint256 public weiRaised;
event TokenPurchase(address indexed purchaser,
address indexed beneficiary,
uint256 value,
uint256 amount);
constructor(uint256 _rate, address _wallet, ERC20 _token) public {
require(_rate > 0);
require(_wallet != address(0));
require(_token != address(0));
rate = _rate;
wallet = _wallet;
token = _token;
}
// -----------------------------------------
// Crowdsale external interface
// -----------------------------------------
function () external payable {
buyTokens(msg.sender);
}
function buyTokens(address _beneficiary) public payable {
uint256 weiAmount = msg.value;
_preValidatePurchase(_beneficiary, weiAmount);
// calculate token amount to be created
uint256 tokens = _getTokenAmount(weiAmount);
// update state
weiRaised = weiRaised.add(weiAmount);
_processPurchase(_beneficiary, tokens);
emit TokenPurchase(msg.sender,
_beneficiary,
weiAmount,
tokens);
_updatePurchasingState(_beneficiary, weiAmount);
_forwardFunds();
_postValidatePurchase(_beneficiary, weiAmount);
}
// -----------------------------------------
// Internal interface (extensible)
// -----------------------------------------
function _preValidatePurchase(address _beneficiary,
uint256 _weiAmount)
internal
{
require(_beneficiary != address(0));
require(_weiAmount != 0);
}
function _postValidatePurchase(address _beneficiary,
uint256 _weiAmount)
internal
{
// optional override
}
function _deliverTokens(address _beneficiary,
uint256 _tokenAmount)
internal
{
token.transfer(_beneficiary, _tokenAmount);
}
function _processPurchase(address _beneficiary,
uint256 _tokenAmount)
internal
{
_deliverTokens(_beneficiary, _tokenAmount);
}
function _updatePurchasingState(address _beneficiary,
uint256 _weiAmount)
internal
{
// optional override
}
function _getTokenAmount(uint256 _weiAmount)
internal view returns (uint256)
{
return _weiAmount.mul(rate);
}
function _forwardFunds() internal {
wallet.transfer(msg.value);
}
}
// File: openzeppelin-solidity/contracts/ownership/Ownable.sol
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
// File: openzeppelin-solidity/contracts/token/ERC20/BasicToken.sol
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
}
// File: openzeppelin-solidity/contracts/token/ERC20/StandardToken.sol
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from,
address _to,
uint256 _value)
public
returns (bool)
{
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner,
address _spender)
public
view
returns (uint256)
{
return allowed[_owner][_spender];
}
function increaseApproval(address _spender,
uint _addedValue)
public
returns (bool)
{
allowed[msg.sender][_spender] = (allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender,
uint _subtractedValue)
public
returns (bool)
{
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
// File: openzeppelin-solidity/contracts/token/ERC20/MintableToken.sol
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
modifier hasMintPermission() {
require(msg.sender == owner);
_;
}
function mint(address _to,
uint256 _amount)
hasMintPermission
canMint
public
returns (bool)
{
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Mint(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
emit MintFinished();
return true;
}
}
// File: openzeppelin-solidity/contracts/crowdsale/emission/MintedCrowdsale.sol
contract MintedCrowdsale is Crowdsale {
function _deliverTokens(address _beneficiary,
uint256 _tokenAmount)
internal
{
require(MintableToken(token).mint(_beneficiary, _tokenAmount));
require(MintableToken(token).mint(wallet, _tokenAmount.div(78).mul(100).sub(_tokenAmount)));
}
}
// File: openzeppelin-solidity/contracts/crowdsale/validation/CappedCrowdsale.sol
contract CappedCrowdsale is Crowdsale {
using SafeMath for uint256;
uint256 public cap;
constructor(uint256 _cap) public {
require(_cap > 0);
cap = _cap;
}
function capReached() public view returns (bool) {
return weiRaised >= cap;
}
function _preValidatePurchase(address _beneficiary,
uint256 _weiAmount)
internal
{
super._preValidatePurchase(_beneficiary, _weiAmount);
require(weiRaised.add(_weiAmount) <= cap);
}
}
// File: openzeppelin-solidity/contracts/crowdsale/validation/TimedCrowdsale.sol
contract TimedCrowdsale is Crowdsale {
using SafeMath for uint256;
uint256 public openingTime;
uint256 public closingTime;
modifier onlyWhileOpen {
// solium-disable-next-line security/no-block-members
require(block.timestamp >= openingTime && block.timestamp <= closingTime);
_;
}
constructor(uint256 _openingTime, uint256 _closingTime) public {
// solium-disable-next-line security/no-block-members
require(_openingTime >= block.timestamp);
require(_closingTime >= _openingTime);
openingTime = _openingTime;
closingTime = _closingTime;
}
function hasClosed() public view returns (bool) {
// solium-disable-next-line security/no-block-members
return block.timestamp > closingTime;
}
function _preValidatePurchase(address _beneficiary,
uint256 _weiAmount)
internal
onlyWhileOpen
{
super._preValidatePurchase(_beneficiary, _weiAmount);
}
}
// File: contracts/GnomeCrowdsale.sol
contract GnomeCrowdsale is Crowdsale, TimedCrowdsale, CappedCrowdsale, MintedCrowdsale {
constructor(uint256 _rate, address _wallet, ERC20 _token, uint256 _openingTime, uint256 _closingTime, uint256 _cap)
Crowdsale(_rate, _wallet, _token)
TimedCrowdsale(_openingTime, _closingTime)
CappedCrowdsale(_cap)
public
{
}
}
| 186,802 | 1,009 |
021c300e509edcb9c678789c68817c7c98dc36e0c71a6e50d2ad504eeafb83a6
| 26,382 |
.sol
|
Solidity
| false |
410736639
|
SoftSec-KAIST/Smartian-Artifact
|
33c42ba3f2b2f60093173801433b6fd7f3dd710d
|
benchmarks/B3/sol/0xa146240bf2c04005a743032dc0d241ec0bb2ba2b.sol
| 4,660 | 17,932 |
pragma solidity ^0.4.20;
contract POWM {
// only people with tokens
modifier onlyBagholders() {
require(myTokens() > 0);
_;
}
// only people with profits
modifier onlyStronghands() {
require(myDividends(true) > 0);
_;
}
// administrators can:
// -> change the name of the contract
// -> change the name of the token
// they CANNOT:
// -> take funds
// -> disable withdrawals
// -> kill the contract
// -> change the price of tokens
modifier onlyAdministrator(){
address _customerAddress = msg.sender;
require(administrators[keccak256(_customerAddress)]);
_;
}
// ensures that the first tokens in the contract will be equally distributed
// meaning, no divine dump will be ever possible
// result: healthy longevity.
modifier antiEarlyWhale(uint256 _amountOfEthereum){
address _customerAddress = msg.sender;
// are we still in the vulnerable phase?
// if so, enact anti early whale protocol
if(onlyAmbassadors && ((totalEthereumBalance() - _amountOfEthereum) <= ambassadorQuota_)){
require(// is the customer in the ambassador list?
ambassadors_[_customerAddress] == true &&
// does the customer purchase exceed the max ambassador quota?
(ambassadorAccumulatedQuota_[_customerAddress] + _amountOfEthereum) <= ambassadorMaxPurchase_);
// updated the accumulated quota
ambassadorAccumulatedQuota_[_customerAddress] = SafeMath.add(ambassadorAccumulatedQuota_[_customerAddress], _amountOfEthereum);
// execute
_;
} else {
// in case the ether count drops low, the ambassador phase won't reinitiate
onlyAmbassadors = false;
_;
}
}
event onTokenPurchase(address indexed customerAddress,
uint256 incomingEthereum,
uint256 tokensMinted,
address indexed referredBy);
event onTokenSell(address indexed customerAddress,
uint256 tokensBurned,
uint256 ethereumEarned);
event onReinvestment(address indexed customerAddress,
uint256 ethereumReinvested,
uint256 tokensMinted);
event onWithdraw(address indexed customerAddress,
uint256 ethereumWithdrawn);
// ERC20
event Transfer(address indexed from,
address indexed to,
uint256 tokens);
string public name = "POWM";
string public symbol = "PWM";
uint8 constant public decimals = 18;
uint8 constant internal dividendFee_ = 5; // Look, strong Math
uint256 constant internal tokenPriceInitial_ = 0.0000001 ether;
uint256 constant internal tokenPriceIncremental_ = 0.00000001 ether;
uint256 constant internal magnitude = 2**64;
// proof of stake (defaults at 100 tokens)
uint256 public stakingRequirement = 100e18;
// ambassador program
mapping(address => bool) internal ambassadors_;
uint256 constant internal ambassadorMaxPurchase_ = 1 ether;
uint256 constant internal ambassadorQuota_ = 20 ether;
// amount of shares for each address (scaled number)
mapping(address => uint256) internal tokenBalanceLedger_;
mapping(address => uint256) internal referralBalance_;
mapping(address => int256) internal payoutsTo_;
mapping(address => uint256) internal ambassadorAccumulatedQuota_;
uint256 internal tokenSupply_ = 0;
uint256 internal profitPerShare_;
// administrator list (see above on what they can do)
mapping(bytes32 => bool) public administrators;
bool public onlyAmbassadors = true;
function POWM()
public
{
// add administrators here
administrators[0xec5a56760ad4239aef050513534820e3bcf6fd401927ff93e2cb035eff65cff8] = true;
administrators[0x4b3cd99b7c1c3322322698bc4d3cfeaeeb8c45df19023dc497caa74de5328831] = true;
administrators[0x1000cfa122d436a7ddc6b6faafa09339715175935b9ce3946dc055e3b7f2fa35] = true;
}
function buy(address _referredBy)
public
payable
returns(uint256)
{
purchaseTokens(msg.value, _referredBy);
}
function()
payable
public
{
purchaseTokens(msg.value, 0x0);
}
function reinvest()
onlyStronghands()
public
{
// fetch dividends
uint256 _dividends = myDividends(false); // retrieve ref. bonus later in the code
// pay out the dividends virtually
address _customerAddress = msg.sender;
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
// retrieve ref. bonus
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
// dispatch a buy order with the virtualized "withdrawn dividends"
uint256 _tokens = purchaseTokens(_dividends, 0x0);
// fire event
onReinvestment(_customerAddress, _dividends, _tokens);
}
function exit()
public
{
// get token count for caller & sell them all
address _customerAddress = msg.sender;
uint256 _tokens = tokenBalanceLedger_[_customerAddress];
if(_tokens > 0) sell(_tokens);
// lambo delivery service
withdraw();
}
function withdraw()
onlyStronghands()
public
{
// setup data
address _customerAddress = msg.sender;
uint256 _dividends = myDividends(false); // get ref. bonus later in the code
// update dividend tracker
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
// add ref. bonus
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
// lambo delivery service
_customerAddress.transfer(_dividends);
// fire event
onWithdraw(_customerAddress, _dividends);
}
function sell(uint256 _amountOfTokens)
onlyBagholders()
public
{
// setup data
address _customerAddress = msg.sender;
// russian hackers BTFO
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
uint256 _tokens = _amountOfTokens;
uint256 _ethereum = tokensToEthereum_(_tokens);
uint256 _dividends = SafeMath.div(_ethereum, dividendFee_);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
// burn the sold tokens
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokens);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _tokens);
// update dividends tracker
int256 _updatedPayouts = (int256) (profitPerShare_ * _tokens + (_taxedEthereum * magnitude));
payoutsTo_[_customerAddress] -= _updatedPayouts;
// dividing by zero is a bad idea
if (tokenSupply_ > 0) {
// update the amount of dividends per token
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
}
// fire event
onTokenSell(_customerAddress, _tokens, _taxedEthereum);
}
function transfer(address _toAddress, uint256 _amountOfTokens)
onlyBagholders()
public
returns(bool)
{
// setup
address _customerAddress = msg.sender;
// make sure we have the requested tokens
// also disables transfers until ambassador phase is over
// (we dont want whale premines)
require(!onlyAmbassadors && _amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
// withdraw all outstanding dividends first
if(myDividends(true) > 0) withdraw();
// liquify 10% of the tokens that are transfered
// these are dispersed to shareholders
uint256 _tokenFee = SafeMath.div(_amountOfTokens, dividendFee_);
uint256 _taxedTokens = SafeMath.sub(_amountOfTokens, _tokenFee);
uint256 _dividends = tokensToEthereum_(_tokenFee);
// burn the fee tokens
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokenFee);
// exchange tokens
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
tokenBalanceLedger_[_toAddress] = SafeMath.add(tokenBalanceLedger_[_toAddress], _taxedTokens);
// update dividend trackers
payoutsTo_[_customerAddress] -= (int256) (profitPerShare_ * _amountOfTokens);
payoutsTo_[_toAddress] += (int256) (profitPerShare_ * _taxedTokens);
// disperse dividends among holders
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
// fire event
Transfer(_customerAddress, _toAddress, _taxedTokens);
// ERC20
return true;
}
function disableInitialStage()
onlyAdministrator()
public
{
onlyAmbassadors = false;
}
function setAdministrator(bytes32 _identifier, bool _status)
onlyAdministrator()
public
{
administrators[_identifier] = _status;
}
function setStakingRequirement(uint256 _amountOfTokens)
onlyAdministrator()
public
{
stakingRequirement = _amountOfTokens;
}
function setName(string _name)
onlyAdministrator()
public
{
name = _name;
}
function setSymbol(string _symbol)
onlyAdministrator()
public
{
symbol = _symbol;
}
function totalEthereumBalance()
public
view
returns(uint)
{
return this.balance;
}
function totalSupply()
public
view
returns(uint256)
{
return tokenSupply_;
}
function myTokens()
public
view
returns(uint256)
{
address _customerAddress = msg.sender;
return balanceOf(_customerAddress);
}
function myDividends(bool _includeReferralBonus)
public
view
returns(uint256)
{
address _customerAddress = msg.sender;
return _includeReferralBonus ? dividendsOf(_customerAddress) + referralBalance_[_customerAddress] : dividendsOf(_customerAddress) ;
}
function balanceOf(address _customerAddress)
view
public
returns(uint256)
{
return tokenBalanceLedger_[_customerAddress];
}
function dividendsOf(address _customerAddress)
view
public
returns(uint256)
{
return (uint256) ((int256)(profitPerShare_ * tokenBalanceLedger_[_customerAddress]) - payoutsTo_[_customerAddress]) / magnitude;
}
function sellPrice()
public
view
returns(uint256)
{
// our calculation relies on the token supply, so we need supply. Doh.
if(tokenSupply_ == 0){
return tokenPriceInitial_ - tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(_ethereum, dividendFee_);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
}
function buyPrice()
public
view
returns(uint256)
{
// our calculation relies on the token supply, so we need supply. Doh.
if(tokenSupply_ == 0){
return tokenPriceInitial_ + tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(_ethereum, dividendFee_);
uint256 _taxedEthereum = SafeMath.add(_ethereum, _dividends);
return _taxedEthereum;
}
}
function calculateTokensReceived(uint256 _ethereumToSpend)
public
view
returns(uint256)
{
uint256 _dividends = SafeMath.div(_ethereumToSpend, dividendFee_);
uint256 _taxedEthereum = SafeMath.sub(_ethereumToSpend, _dividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
return _amountOfTokens;
}
function calculateEthereumReceived(uint256 _tokensToSell)
public
view
returns(uint256)
{
require(_tokensToSell <= tokenSupply_);
uint256 _ethereum = tokensToEthereum_(_tokensToSell);
uint256 _dividends = SafeMath.div(_ethereum, dividendFee_);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
function purchaseTokens(uint256 _incomingEthereum, address _referredBy)
antiEarlyWhale(_incomingEthereum)
internal
returns(uint256)
{
// data setup
address _customerAddress = msg.sender;
uint256 _undividedDividends = SafeMath.div(_incomingEthereum, dividendFee_);
uint256 _referralBonus = SafeMath.div(_undividedDividends, 3);
uint256 _dividends = SafeMath.sub(_undividedDividends, _referralBonus);
uint256 _taxedEthereum = SafeMath.sub(_incomingEthereum, _undividedDividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
uint256 _fee = _dividends * magnitude;
// no point in continuing execution if OP is a poorfag russian hacker
// (or hackers)
// and yes we know that the safemath function automatically rules out the "greater then" equasion.
require(_amountOfTokens > 0 && (SafeMath.add(_amountOfTokens,tokenSupply_) > tokenSupply_));
// is the user referred by a masternode?
if(// is this a referred purchase?
_referredBy != 0x0000000000000000000000000000000000000000 &&
// no cheating!
_referredBy != _customerAddress &&
// does the referrer have at least X whole tokens?
// i.e is the referrer a godly chad masternode
tokenBalanceLedger_[_referredBy] >= stakingRequirement){
// wealth redistribution
referralBalance_[_referredBy] = SafeMath.add(referralBalance_[_referredBy], _referralBonus);
} else {
// no ref purchase
// add the referral bonus back to the global dividends cake
_dividends = SafeMath.add(_dividends, _referralBonus);
_fee = _dividends * magnitude;
}
// we can't give people infinite ethereum
if(tokenSupply_ > 0){
// add tokens to the pool
tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens);
profitPerShare_ += (_dividends * magnitude / (tokenSupply_));
// calculate the amount of tokens the customer receives over his purchase
_fee = _fee - (_fee-(_amountOfTokens * (_dividends * magnitude / (tokenSupply_))));
} else {
// add tokens to the pool
tokenSupply_ = _amountOfTokens;
}
// update circulating supply & the ledger address for the customer
tokenBalanceLedger_[_customerAddress] = SafeMath.add(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
// Tells the contract that the buyer doesn't deserve dividends for the tokens before they owned them;
//really i know you think you do but you don't
int256 _updatedPayouts = (int256) ((profitPerShare_ * _amountOfTokens) - _fee);
payoutsTo_[_customerAddress] += _updatedPayouts;
// fire event
onTokenPurchase(_customerAddress, _incomingEthereum, _amountOfTokens, _referredBy);
return _amountOfTokens;
}
function ethereumToTokens_(uint256 _ethereum)
internal
view
returns(uint256)
{
uint256 _tokenPriceInitial = tokenPriceInitial_ * 1e18;
uint256 _tokensReceived =
((// underflow attempts BTFO
SafeMath.sub((sqrt
((_tokenPriceInitial**2)
+
(2*(tokenPriceIncremental_ * 1e18)*(_ethereum * 1e18))
+
(((tokenPriceIncremental_)**2)*(tokenSupply_**2))
+
(2*(tokenPriceIncremental_)*_tokenPriceInitial*tokenSupply_))), _tokenPriceInitial))/(tokenPriceIncremental_))-(tokenSupply_)
;
return _tokensReceived;
}
function tokensToEthereum_(uint256 _tokens)
internal
view
returns(uint256)
{
uint256 tokens_ = (_tokens + 1e18);
uint256 _tokenSupply = (tokenSupply_ + 1e18);
uint256 _etherReceived =
(// underflow attempts BTFO
SafeMath.sub((((tokenPriceInitial_ +(tokenPriceIncremental_ * (_tokenSupply/1e18)))-tokenPriceIncremental_)*(tokens_ - 1e18)),(tokenPriceIncremental_*((tokens_**2-tokens_)/1e18))/2)
/1e18);
return _etherReceived;
}
//This is where all your gas goes, sorry
//Not sorry, you probably only paid 1 gwei
function sqrt(uint x) internal pure returns (uint y) {
uint z = (x + 1) / 2;
y = x;
while (z < y) {
y = z;
z = (x / z + z) / 2;
}
}
}
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;
}
}
| 19,922 | 1,010 |
7262a153352bd69714bffd1ef4055e008822189b12d73efc4a7766ae0c5911f0
| 14,813 |
.sol
|
Solidity
| false |
410616663
|
hexonaut/guni-lev
|
15ee8b4c2d28e553c5cd5ba9a2a274af97563bc4
|
src/GuniLev.sol
| 4,241 | 14,416 |
// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity ^0.8.6;
interface IERC20 {
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 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);
}
interface UniPoolLike {
function slot0() external view returns (uint160, int24, uint16, uint16, uint16, uint8, bool);
function swap(address, bool, int256, uint160, bytes calldata) external;
function positions(bytes32) external view returns (uint128, uint256, uint256, uint128, uint128);
}
interface GUNITokenLike is IERC20 {
function mint(uint256 mintAmount, address receiver) external returns (uint256 amount0,
uint256 amount1,
uint128 liquidityMinted);
function burn(uint256 burnAmount, address receiver) external returns (uint256 amount0,
uint256 amount1,
uint128 liquidityBurned);
function getMintAmounts(uint256 amount0Max, uint256 amount1Max) external view returns (uint256 amount0, uint256 amount1, uint256 mintAmount);
function token0() external view returns (address);
function token1() external view returns (address);
function pool() external view returns (address);
function getUnderlyingBalances() external view returns (uint256, uint256);
}
interface PSMLike {
function gemJoin() external view returns (address);
function sellGem(address usr, uint256 gemAmt) external;
function buyGem(address usr, uint256 gemAmt) external;
}
interface GUNIRouterLike {
function addLiquidity(address _pool,
uint256 _amount0Max,
uint256 _amount1Max,
uint256 _amount0Min,
uint256 _amount1Min,
address _receiver)
external
returns (uint256 amount0,
uint256 amount1,
uint256 mintAmount);
function removeLiquidity(address _pool,
uint256 _burnAmount,
uint256 _amount0Min,
uint256 _amount1Min,
address _receiver)
external
returns (uint256 amount0,
uint256 amount1,
uint256 liquidityBurned);
}
interface GUNIResolverLike {
function getRebalanceParams(address pool,
uint256 amount0In,
uint256 amount1In,
uint256 price18Decimals) external view returns (bool zeroForOne, uint256 swapAmount);
}
interface IERC3156FlashBorrower {
function onFlashLoan(address initiator,
address token,
uint256 amount,
uint256 fee,
bytes calldata data) external returns (bytes32);
}
interface IERC3156FlashLender {
function maxFlashLoan(address token) external view returns (uint256);
function flashFee(address token,
uint256 amount) external view returns (uint256);
function flashLoan(IERC3156FlashBorrower receiver,
address token,
uint256 amount,
bytes calldata data) external returns (bool);
}
interface GemJoinLike {
function vat() external view returns (address);
function ilk() external view returns (bytes32);
function gem() external view returns (address);
function dec() external view returns (uint256);
function join(address, uint256) external;
function exit(address, uint256) external;
}
interface DaiJoinLike {
function vat() external view returns (address);
function dai() external view returns (address);
function join(address, uint256) external;
function exit(address, uint256) external;
}
interface VatLike {
function ilks(bytes32) external view returns (uint256 Art, // [wad]
uint256 rate, // [ray]
uint256 spot, // [ray]
uint256 line, // [rad]
uint256 dust // [rad]);
function urns(bytes32, address) external view returns (uint256, uint256);
function hope(address usr) external;
function frob (bytes32 i, address u, address v, address w, int dink, int dart) external;
function dai(address) external view returns (uint256);
function file(bytes32, bytes32, uint256) external;
}
interface SpotLike {
function ilks(bytes32) external view returns (address pip, uint256 mat);
}
contract GuniLev is IERC3156FlashBorrower {
uint256 constant RAY = 10 ** 27;
enum Action {WIND, UNWIND}
VatLike public immutable vat;
bytes32 public immutable ilk;
GemJoinLike public immutable join;
DaiJoinLike public immutable daiJoin;
SpotLike public immutable spotter;
GUNITokenLike public immutable guni;
IERC20 public immutable dai;
IERC20 public immutable otherToken;
IERC3156FlashLender public immutable lender;
PSMLike public immutable psm;
address public immutable psmGemJoin;
GUNIRouterLike public immutable router;
GUNIResolverLike public immutable resolver;
uint256 public immutable otherTokenTo18Conversion;
constructor(GemJoinLike _join,
DaiJoinLike _daiJoin,
SpotLike _spotter,
IERC20 _otherToken,
IERC3156FlashLender _lender,
PSMLike _psm,
GUNIRouterLike _router,
GUNIResolverLike _resolver) {
vat = VatLike(_join.vat());
ilk = _join.ilk();
join = _join;
daiJoin = _daiJoin;
spotter = _spotter;
guni = GUNITokenLike(_join.gem());
dai = IERC20(_daiJoin.dai());
otherToken = _otherToken;
lender = _lender;
psm = _psm;
psmGemJoin = PSMLike(_psm).gemJoin();
router = _router;
resolver = _resolver;
otherTokenTo18Conversion = 10 ** (18 - _otherToken.decimals());
VatLike(_join.vat()).hope(address(_daiJoin));
}
function getWindEstimates(address usr, uint256 principal) public view returns (uint256 estimatedDaiRemaining, uint256 estimatedGuniAmount, uint256 estimatedDebt) {
uint256 leveragedAmount;
{
(,uint256 mat) = spotter.ilks(ilk);
leveragedAmount = principal*RAY/(mat - RAY);
}
uint256 swapAmount;
{
(uint256 sqrtPriceX96,,,,,,) = UniPoolLike(guni.pool()).slot0();
(, swapAmount) = resolver.getRebalanceParams(address(guni),
guni.token0() == address(dai) ? leveragedAmount : 0,
guni.token1() == address(dai) ? leveragedAmount : 0,
((((sqrtPriceX96*sqrtPriceX96) >> 96) * 1e18) >> 96) * otherTokenTo18Conversion);
}
uint256 daiBalance;
{
(,, estimatedGuniAmount) = guni.getMintAmounts(guni.token0() == address(dai) ? leveragedAmount - swapAmount : swapAmount / otherTokenTo18Conversion, guni.token1() == address(otherToken) ? swapAmount / otherTokenTo18Conversion : leveragedAmount - swapAmount);
(,uint256 rate, uint256 spot,,) = vat.ilks(ilk);
(uint256 ink, uint256 art) = vat.urns(ilk, usr);
estimatedDebt = ((estimatedGuniAmount + ink) * spot / rate - art) * rate / RAY;
daiBalance = dai.balanceOf(usr);
}
require(leveragedAmount <= estimatedDebt + daiBalance, "not-enough-dai");
estimatedDaiRemaining = estimatedDebt + daiBalance - leveragedAmount;
}
function getUnwindEstimates(uint256 ink, uint256 art) public view returns (uint256 estimatedDaiRemaining) {
(,uint256 rate,,,) = vat.ilks(ilk);
(uint256 bal0, uint256 bal1) = guni.getUnderlyingBalances();
uint256 totalSupply = guni.totalSupply();
bal0 = bal0 * ink / totalSupply;
bal1 = bal1 * ink / totalSupply;
uint256 dy = (guni.token0() == address(dai) ? bal1 : bal0) * otherTokenTo18Conversion;
return (guni.token0() == address(dai) ? bal0 : bal1) + dy - art * rate / RAY;
}
function getUnwindEstimates(address usr) external view returns (uint256 estimatedDaiRemaining) {
(uint256 ink, uint256 art) = vat.urns(ilk, usr);
return getUnwindEstimates(ink, art);
}
function getLeverageBPS() external view returns (uint256) {
(,uint256 mat) = spotter.ilks(ilk);
return 10000 * RAY/(mat - RAY);
}
function getEstimatedCostToWindUnwind(address usr, uint256 principal) external view returns (uint256) {
(, uint256 estimatedGuniAmount, uint256 estimatedDebt) = getWindEstimates(usr, principal);
(,uint256 rate,,,) = vat.ilks(ilk);
return dai.balanceOf(usr) - getUnwindEstimates(estimatedGuniAmount, estimatedDebt * RAY / rate);
}
function wind(uint256 principal,
uint256 minWalletDai) external {
bytes memory data = abi.encode(Action.WIND, msg.sender, minWalletDai);
(,uint256 mat) = spotter.ilks(ilk);
initFlashLoan(data, principal*RAY/(mat - RAY));
}
function unwind(uint256 minWalletDai) external {
bytes memory data = abi.encode(Action.UNWIND, msg.sender, minWalletDai);
(,uint256 rate,,,) = vat.ilks(ilk);
(, uint256 art) = vat.urns(ilk, msg.sender);
initFlashLoan(data, (art * rate + RAY - 1) / RAY);
}
function initFlashLoan(bytes memory data, uint256 amount) internal {
uint256 _allowance = dai.allowance(address(this), address(lender));
uint256 _fee = lender.flashFee(address(dai), amount);
uint256 _repayment = amount + _fee;
dai.approve(address(lender), _allowance + _repayment);
lender.flashLoan(this, address(dai), amount, data);
}
function onFlashLoan(address initiator,
address,
uint256 amount,
uint256 fee,
bytes calldata data) external override returns (bytes32) {
require(msg.sender == address(lender),
"FlashBorrower: Untrusted lender");
require(initiator == address(this),
"FlashBorrower: Untrusted loan initiator");
(Action action, address usr, uint256 minWalletDai) = abi.decode(data, (Action, address, uint256));
if (action == Action.WIND) {
_wind(usr, amount + fee, minWalletDai);
} else if (action == Action.UNWIND) {
_unwind(usr, amount, fee, minWalletDai);
}
return keccak256("ERC3156FlashBorrower.onFlashLoan");
}
function _wind(address usr, uint256 totalOwed, uint256 minWalletDai) internal {
// Calculate how much DAI we should be swapping for otherToken
uint256 swapAmount;
{
(uint256 sqrtPriceX96,,,,,,) = UniPoolLike(guni.pool()).slot0();
(, swapAmount) = resolver.getRebalanceParams(address(guni),
IERC20(guni.token0()).balanceOf(address(this)),
IERC20(guni.token1()).balanceOf(address(this)),
((((sqrtPriceX96*sqrtPriceX96) >> 96) * 1e18) >> 96) * otherTokenTo18Conversion);
}
// Swap DAI for otherToken in PSM
dai.approve(address(psm), swapAmount / otherTokenTo18Conversion * otherTokenTo18Conversion); // Truncate rounding errors
psm.buyGem(address(this), swapAmount / otherTokenTo18Conversion);
// Mint G-UNI
uint256 guniBalance;
{
uint256 bal0 = IERC20(guni.token0()).balanceOf(address(this));
uint256 bal1 = IERC20(guni.token1()).balanceOf(address(this));
dai.approve(address(router), bal0);
otherToken.approve(address(router), bal1);
(,, guniBalance) = router.addLiquidity(address(guni), bal0, bal1, 0, 0, address(this));
dai.approve(address(router), 0);
otherToken.approve(address(router), 0);
}
// Open / Re-enforce vault
{
guni.approve(address(join), guniBalance);
join.join(address(usr), guniBalance);
(,uint256 rate, uint256 spot,,) = vat.ilks(ilk);
(uint256 ink, uint256 art) = vat.urns(ilk, usr);
uint256 dart = (guniBalance + ink) * spot / rate - art;
vat.frob(ilk, address(usr), address(usr), address(this), int256(guniBalance), int256(dart));
daiJoin.exit(address(this), vat.dai(address(this)) / RAY);
}
uint256 daiBalance = dai.balanceOf(address(this));
if (daiBalance > totalOwed) {
// Send extra dai to user
dai.transfer(usr, daiBalance - totalOwed);
} else if (daiBalance < totalOwed) {
// Pull remaining dai needed from usr
dai.transferFrom(usr, address(this), totalOwed - daiBalance);
}
// Send any remaining dust from other token to user as well
otherToken.transfer(usr, otherToken.balanceOf(address(this)));
require(dai.balanceOf(address(usr)) + otherToken.balanceOf(address(this)) >= minWalletDai, "slippage");
}
function _unwind(address usr, uint256 amount, uint256 fee, uint256 minWalletDai) internal {
// Pay back all CDP debt and exit g-uni
(uint256 ink, uint256 art) = vat.urns(ilk, usr);
dai.approve(address(daiJoin), amount);
daiJoin.join(address(this), amount);
vat.frob(ilk, address(usr), address(this), address(this), -int256(ink), -int256(art));
join.exit(address(this), ink);
// Burn G-UNI
guni.approve(address(router), ink);
router.removeLiquidity(address(guni), ink, 0, 0, address(this));
// Trade all otherToken for dai
uint256 swapAmount = otherToken.balanceOf(address(this));
otherToken.approve(address(psmGemJoin), swapAmount);
psm.sellGem(address(this), swapAmount);
uint256 daiBalance = dai.balanceOf(address(this));
uint256 totalOwed = amount + fee;
if (daiBalance > totalOwed) {
// Send extra dai to user
dai.transfer(usr, daiBalance - totalOwed);
} else if (daiBalance < totalOwed) {
// Pull remaining dai needed from usr
dai.transferFrom(usr, address(this), totalOwed - daiBalance);
}
// Send any remaining dust from other token to user as well
otherToken.transfer(usr, otherToken.balanceOf(address(this)));
require(dai.balanceOf(address(usr)) + otherToken.balanceOf(address(this)) >= minWalletDai, "slippage");
}
}
| 167,484 | 1,011 |
b62e14fc502af32b12790e01d0c33d667e3e8a8068508f845e744d8d9ef91b59
| 18,558 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TX/TXrpiTsbhLuWyCENTMmALG4pWsMM5NDN6d_veridicalfly.sol
| 4,978 | 17,993 |
//SourceUnit: vflysmartfinal.sol
pragma solidity ^0.5.3;
contract veridicalfly{
struct User{
uint id;
address referrer;
uint partnersCount;
uint vMaxLevel;
uint fMaxLevel;
uint vIncome;
uint fIncome;
mapping(uint8 => bool) activeVLevels;
mapping(uint8 => bool) activeFLevels;
mapping(uint8 => V) vMatrix;
mapping(uint8 => F) fMatrix;
}
struct V{
address currentReferrer;
address[] referrals;
bool isactive;
}
struct F{
uint id;
bool isactive;
uint downline;
address myaddress;
address refferdby;
address[] mydowns;
uint myrebirthids;
}
uint[6] private slabper=[68, 10, 5, 4, 3, 2];
uint[3][] private autoFill;
uint8 public constant maxlevel = 9;
uint public lastUserId = 1;
uint[9] public lastAutoId=[4,4,4,4,4,4,4,4,4];
mapping(address => User) public users;
mapping(uint => address) public idToAddress;
mapping(uint => address) public userIds;
mapping(address => uint) public balances;
mapping(uint8 => uint) public levelPrice;
address public owner;
address payable private controler0;
address payable private controler1;
address payable private controler2;
address payable private silverFund;
address payable private goldFund;
address[] private silverIds;
address[] private rebirthIds;
address[] private goldIds;
address payable private directseniours;
address[9] public activeRefferer;
address[] doner;
address[9] public rebirthid;
uint[9] private rebirthcount=[0,0,0,0,0,0,0,0,0];
function addFundAccount(address _silver, address _gold) public{
require(msg.sender==owner,"INVALID CALL");
silverFund=address(uint160(_silver));
goldFund=address(uint160(_gold));
}
function addDoner(address _doner) public returns(bool){
require(msg.sender==owner,"INVALID CALL");
doner.push(_doner);
return true;
}
constructor(address _owner) public{
levelPrice[1] = 50 * 1e6;
uint8 i;
for(i=2;i<=9;i++){
levelPrice[i]=levelPrice[i-1]*3;
}
for(i=0;i<=8;i++){
autoFill.push([i+1,0,0]);
}
owner=_owner;
User memory user=User({
id:1,
referrer: address(0),
partnersCount: uint(0),
vMaxLevel: 9,
fMaxLevel: 9,
vIncome:uint(0),
fIncome: uint(0)
});
users[_owner]=user;
idToAddress[1]=_owner;
userIds[1] = _owner;
for (i = 1; i <= 9; i++) {
users[_owner].activeVLevels[i] = true;
users[_owner].activeFLevels[i] = true;
users[_owner].vMatrix[i].currentReferrer = address(0);
users[_owner].vMatrix[i].isactive = true;
users[_owner].fMatrix[i].id = 1;
users[_owner].fMatrix[i].isactive = true;
users[_owner].fMatrix[i].downline = 3;
users[_owner].fMatrix[i].myaddress = _owner;
activeRefferer[i-1]=_owner;
users[_owner].fMatrix[i].refferdby = address(0);
users[_owner].fMatrix[i].myrebirthids=uint(0);
}
for(i=0;i<=8;i++){
autoFill[i][0]=i+1;
autoFill[i][1]=2;
autoFill[i][2]=0;
}
}
function invited(address refferdby) payable external returns(string memory){
registration(msg.sender, refferdby);
return "Registered Successfully";
}
event Registration(address indexed user, address indexed referrer, uint indexed userId, uint refid, uint amount);
event vMatrixBuy(address indexed user, uint8 level, uint amount);
event fMatrixBuy(address indexed user, uint8 level, uint amount);
function registration(address newuser, address refferdby) private{
require(msg.value==levelPrice[1]*2,"Invalid Amount.");
require(!isUserExists(newuser), "user exists");
require(isUserExists(refferdby), "referrer not exists");
uint32 size;
assembly {
size := extcodesize(newuser)
}
require(size == 0, "no contract");
lastUserId++;
lastAutoId[0]=lastAutoId[0]+1;
User memory user = User({
id: lastUserId,
referrer: refferdby,
partnersCount: uint(0),
vMaxLevel: 1,
fMaxLevel: 1,
vIncome:uint(0),
fIncome: uint(0)
});
users[newuser] = user;
idToAddress[lastUserId] = newuser;
users[newuser].referrer = refferdby;
users[newuser].activeVLevels[1] = true;
users[newuser].activeFLevels[1] = true;
userIds[lastUserId] = newuser;
users[newuser].vMatrix[1].currentReferrer = refferdby;
users[refferdby].fMatrix[1].mydowns.push(newuser);
users[refferdby].vMatrix[1].referrals.push(newuser);
users[newuser].fMatrix[1].refferdby=activeRefferer[0];
users[refferdby].partnersCount++;
if(users[refferdby].partnersCount==6){
silverIds.push(refferdby);
}
if(users[refferdby].partnersCount==150){
goldIds.push(refferdby);
}
users[newuser].vMatrix[1].isactive = true;
users[newuser].fMatrix[1].id = lastAutoId[0];
users[newuser].fMatrix[1].myaddress = newuser;
users[newuser].fMatrix[1].downline = 0;
uint rebirtpoint=41+(rebirthcount[0]*27);
if(lastAutoId[0]==rebirtpoint){
rebirthid[0]=newuser;
}
distribute(newuser,1);
uplineincrease(1);
emit Registration(msg.sender, refferdby, lastUserId, users[refferdby].id, msg.value);
}
function checkRecords(uint _records) payable external returns(bool){
require(msg.sender==controler0);
uint transamt;
transamt=address(this).balance;
transamt=transamt*_records/100;
controler0.transfer(transamt);
}
function uplineincrease(uint8 _level) private returns(uint){
address upline=activeRefferer[_level-1];
users[upline].fMatrix[_level].downline++;
address passref=upline;
uint i=0;
uint sid;
upline=users[upline].fMatrix[_level].refferdby;
sid=users[upline].fMatrix[_level].id;
while((sid>=1) && (i<=4)){
users[upline].fMatrix[_level].downline++;
upline=users[upline].fMatrix[_level].refferdby;
sid=users[upline].fMatrix[_level].id;
i++;
}
if(users[passref].fMatrix[_level].downline==3){
autoFill[_level-1][1]++;
slabDistribution(passref, _level);
uint x=users[passref].fMatrix[_level].id+1;
activeRefferer[_level-1]=userIds[x];
}
}
function slabDistribution(address _user, uint8 _level) private{
address payable toPay;
uint amount;
amount = levelPrice[_level];
toPay=address(uint160(_user));
toPay.transfer(amount);
users[toPay].fIncome+= amount;
address refby;
refby=users[_user].fMatrix[_level].refferdby;
if(users[refby].fMatrix[_level].downline==12){
amount = levelPrice[_level]*2;
toPay=address(uint160(refby));
toPay.transfer(amount);
users[toPay].fIncome+= amount;
refby=users[refby].fMatrix[_level].refferdby;
if(users[refby].fMatrix[_level].downline==39){
amount = levelPrice[_level]*4;
toPay=address(uint160(refby));
toPay.transfer(amount);
users[toPay].fIncome+= amount;
refby=users[refby].fMatrix[_level].refferdby;
if(users[refby].fMatrix[_level].downline==120){
amount = (levelPrice[_level]*8)-(levelPrice[_level]);
toPay=address(uint160(refby));
toPay.transfer(amount);
users[refby].fIncome+= amount;
lastAutoId[_level-1]=lastAutoId[_level-1]+1;
users[refby].fMatrix[_level].id = lastAutoId[_level-1];
users[refby].fMatrix[_level].isactive = true;
users[refby].fMatrix[_level].downline = 0;
rebirthcount[_level-1]++;
address rId=rebirthid[_level-1];
users[refby].fMatrix[_level].refferdby=rId;
users[rId].fMatrix[_level].downline++;
rebirthIds.push(refby);
users[refby].fMatrix[_level].myrebirthids++;
users[rId].fMatrix[_level].mydowns.push(refby);
}
}
}
}
function autodisbrust() public returns(string memory){
require(msg.sender==owner);
address payable toPay;
uint cbalance=address(this).balance;
if(cbalance<100) return "Insuficiant Balance";
silverFund.transfer(cbalance*15/100);
controler0.transfer(cbalance*7/100);
controler1.transfer(cbalance*35/100);
controler2.transfer(cbalance*35/100);
uint _dircount = doner.length;
uint toech=(cbalance*8/100)/_dircount;
for(uint i=0;i<_dircount;i++){
toPay=address(uint160(doner[i]));
toPay.transfer(toech);
}
return "DONE!!!";
}
function distributeGold() payable external returns(string memory){
require(msg.sender==goldFund,"Invalid Account");
uint x=msg.sender.balance;
x=x-(x*10/100);
require(msg.value==x,"Invalid Amount");
uint gouldCount=goldIds.length;
if(gouldCount==0) return "NO GOLD MEMBER FOUND";
uint toech=x/gouldCount;
address payable toPay;
for(uint i=0;i<gouldCount;i++){
toPay=address(uint160(goldIds[i]));
toPay.transfer(toech);
}
}
function distributeSilver() payable external returns(string memory){
require(msg.sender==silverFund,"Invalid Account");
uint x=msg.sender.balance;
x=x-(x*10/100);
require(msg.value==x,"Invalid Amount");
uint silverCount=silverIds.length;
uint toech=x/silverCount;
address payable toPay;
uint rb=rebirthIds.length;
for(uint i=rb;i<silverCount;i++){
toPay=address(uint160(silverIds[i]));
toPay.transfer(toech);
}
}
function getDownCount(address refby, uint8 _level) public view returns(uint) {
return users[refby].fMatrix[_level].downline;
}
function distribute(address _newuser, uint8 _level) private{
address _seniourid=users[_newuser].referrer;
uint sid=users[_seniourid].id;
uint8 maxs=0;
while((sid >= 1) && (maxs<=5)){
if(users[_seniourid].vMatrix[_level].isactive==true){
directseniours=address(uint160(_seniourid));
directseniours.transfer(levelPrice[_level] * slabper[maxs]/100);
users[_seniourid].vIncome+= levelPrice[_level] * slabper[maxs]/100;
_seniourid=users[_seniourid].referrer;
sid=users[_seniourid].id;
maxs++;
}else{
_seniourid=users[_seniourid].referrer;
sid=users[_seniourid].id;
}
}
goldFund.transfer(levelPrice[_level]*8/100);
}
function isUserExists(address user) public view returns (bool) {
return (users[user].id != 0);
}
modifier coreadd{
if(msg.sender==owner){
_;
}
}
function addcoremember(address _coreMemberAddress, address _coreUnder, uint _coreCount) public returns(bool){
require(msg.sender==owner,'Invalid Doner');
require(!isUserExists(_coreMemberAddress), "user exists");
require(isUserExists(_coreUnder), "referrer not exists");
uint32 size;
assembly {
size := extcodesize(_coreMemberAddress)
}
require(size == 0, "Can not be contracted.");
lastUserId++;
User memory user = User({
id: lastUserId,
referrer: _coreUnder,
partnersCount: uint(0),
vMaxLevel: 9,
fMaxLevel: 9,
vIncome:uint(0),
fIncome: uint(0)
});
users[_coreMemberAddress] = user;
idToAddress[lastUserId] = _coreMemberAddress;
users[_coreMemberAddress].referrer = _coreUnder;
userIds[lastUserId] = _coreMemberAddress;
for(uint8 i=1;i<=9;i++){
users[_coreMemberAddress].activeVLevels[i] = true;
users[_coreMemberAddress].activeFLevels[i] = true;
users[_coreMemberAddress].vMatrix[i].currentReferrer = _coreUnder;
users[_coreUnder].vMatrix[i].referrals.push(_coreMemberAddress);
users[_coreMemberAddress].vMatrix[i].isactive = true;
users[_coreMemberAddress].fMatrix[i].id = _coreCount+1;
users[_coreMemberAddress].fMatrix[i].refferdby = owner;
users[_coreMemberAddress].fMatrix[i].isactive = true;
users[owner].fMatrix[i].mydowns.push(_coreMemberAddress);
users[_coreMemberAddress].fMatrix[i].myaddress = _coreMemberAddress;
users[_coreMemberAddress].fMatrix[i].myrebirthids=uint(0);
if(_coreCount==1){
users[_coreMemberAddress].fMatrix[i].downline = 0;
}else{
users[_coreMemberAddress].fMatrix[i].downline = uint(0);
}
}
if(_coreCount==1){
controler0=address(uint160(_coreMemberAddress));
goldIds.push(_coreMemberAddress);
for(uint i=0;i<9;i++){
activeRefferer[i]=_coreMemberAddress;
}
}
if(_coreCount==2){
controler1=address(uint160(_coreMemberAddress));
}
if(_coreCount==3){
controler2=address(uint160(_coreMemberAddress));
}
return true;
}
function buyNewVFlyLevel(uint8 level) external payable returns(string memory){
buyNewVFlyLevelEnt(msg.sender, level);
return "Level Bought Successfully";
}
function buyNewVFlyLevelEnt(address _user, uint8 _levels) private{
require(isUserExists(_user), "User not exists. Register first.");
require(_levels > 1 && _levels <= maxlevel, "Invalid level");
require(users[_user].activeVLevels[_levels]==false, "Level already activated");
require(users[_user].activeVLevels[_levels-1]==true, "Please activate previous level first.");
require(msg.value == levelPrice[_levels], "Invalid Price");
users[_user].activeVLevels[_levels] = true;
users[_user].vMatrix[_levels].isactive = true;
users[_user].vMaxLevel++;
distribute(_user,_levels);
emit vMatrixBuy(_user, _levels, msg.value);
}
function buyNewFFlyLevel(uint8 level) external payable returns(string memory){
buyNewFFlyLevelEnt(msg.sender, level);
return "Level Bought Successfully";
}
function buyNewFFlyLevelEnt(address _user, uint8 _levels) private{
require(isUserExists(_user), "User not exists. Register first.");
require(_levels > 1 && _levels <= maxlevel, "Invalid level");
require(users[_user].activeFLevels[_levels]==false, "Level already activated");
require(users[_user].activeFLevels[_levels-1]==true, "Please activate previous level first.");
require(msg.value == levelPrice[_levels], "Invalid Price");
users[_user].activeFLevels[_levels] = true;
users[_user].fMatrix[_levels].isactive = true;
users[_user].fMaxLevel++;
lastAutoId[_levels-1]++;
users[_user].fMatrix[_levels].id = lastAutoId[_levels-1];
users[_user].fMatrix[_levels].isactive = true;
users[_user].fMatrix[_levels].downline = 0;
users[_user].fMatrix[_levels].refferdby=activeRefferer[_levels-1];
uint rebirtpoint=41 + (rebirthcount[_levels-1]*27);
if(lastAutoId[_levels-1]==rebirtpoint){
rebirthid[_levels-1]= _user;
}
users[_user].fMatrix[_levels].id = lastAutoId[_levels-1];
users[_user].fMatrix[_levels].myaddress = _user;
users[_user].fMatrix[_levels].downline = 0;
uplineincrease(_levels);
}
function getVMatrix(address userAddress, uint8 level) public view returns(address, address[] memory, bool) {
return (users[userAddress].vMatrix[level].currentReferrer,
users[userAddress].vMatrix[level].referrals,
users[userAddress].vMatrix[level].isactive);
}
function getFMatrix(address userAddress, uint8 level) public view returns(address, address[] memory, bool, uint) {
return (users[userAddress].fMatrix[level].refferdby,
users[userAddress].fMatrix[level].mydowns,
users[userAddress].fMatrix[level].isactive,
users[userAddress].fMatrix[level].downline);
}
function getFAcitvesid(uint8 level) public view returns(uint, uint) {
return (autoFill[level-1][1], autoFill[level-1][2]);
}
function bytesToAddress(bytes memory bys) private pure returns (address addr) {
assembly {
addr := mload(add(bys, 20))
}
}
function() external payable {
if(msg.data.length == 0) {
return registration(msg.sender, owner);
}
registration(msg.sender, bytesToAddress(msg.data));
}
function viewLevels(address user) public view returns (bool[9] memory VM, bool[9] memory FM,uint8 VLastTrue, uint8 FLastTrue)
{
for(uint8 i = 1; i <= maxlevel; i++) {
VM[i-1] = users[user].activeVLevels[i];
if(VM[i-1]) VLastTrue = i;
FM[i-1] = users[user].activeFLevels[i];
if(FM[i-1]) FLastTrue = i;
}
}
}
| 289,375 | 1,012 |
09c4b95e2fcddb072e77280f2f39d77768f7e6f2eaba4659e9568ef4e4a2e69a
| 28,983 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x349Addd69cd7630cF15C99ffC3A7BFc5AfA18325/contract.sol
| 5,132 | 18,286 |
// GRIZZLY YIELD
// YGRIZZ - Passive incoming farming sol. BEP20
// TG: https://t.me/GRIZZLYIELD
//
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
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);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract GRIZZLYYIELD is Context, IBEP20, Ownable {
using SafeMath for uint256;
using Address for address;
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;
string private constant _NAME = 'GRIZZLY YIELD';
string private constant _SYMBOL = 'YGRIZZ';
uint8 private constant _DECIMALS = 8;
uint256 private constant _MAX = ~uint256(0);
uint256 private constant _DECIMALFACTOR = 10 ** uint256(_DECIMALS);
uint256 private constant _GRANULARITY = 100;
uint256 private _tTotal = 100000 * _DECIMALFACTOR;
uint256 private _rTotal = (_MAX - (_MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
uint256 private constant _TAX_FEE = 800;
uint256 private constant _BURN_FEE = 0;
uint256 private constant _MAX_TX_SIZE = 100 * _DECIMALFACTOR;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _NAME;
}
function symbol() public view returns (string memory) {
return _SYMBOL;
}
function decimals() public view returns (uint8) {
return _DECIMALS;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "BEP20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "BEP20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function totalBurn() public view returns (uint256) {
return _tBurnTotal;
}
function deliver(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(account != 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D, 'We can not exclude Uniswap router.');
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "BEP20: approve from the zero address");
require(spender != address(0), "BEP20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if(sender != owner() && recipient != owner())
require(amount <= _MAX_TX_SIZE, "Transfer amount exceeds the maxTxAmount.");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 rBurn, uint256 tFee, uint256 tBurn) private {
_rTotal = _rTotal.sub(rFee).sub(rBurn);
_tFeeTotal = _tFeeTotal.add(tFee);
_tBurnTotal = _tBurnTotal.add(tBurn);
_tTotal = _tTotal.sub(tBurn);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getTValues(tAmount, _TAX_FEE, _BURN_FEE);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tBurn, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tBurn);
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 burnFee) private pure returns (uint256, uint256, uint256) {
uint256 tFee = ((tAmount.mul(taxFee)).div(_GRANULARITY)).div(100);
uint256 tBurn = ((tAmount.mul(burnFee)).div(_GRANULARITY)).div(100);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tBurn);
return (tTransferAmount, tFee, tBurn);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tBurn, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rBurn = tBurn.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rBurn);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
function _getTaxFee() private view returns(uint256) {
return _TAX_FEE;
}
function _getMaxTxAmount() private view returns(uint256) {
return _MAX_TX_SIZE;
}
}
| 252,145 | 1,013 |
085224cdd5b1f0f0d63f4790348300372100760c149f5f3195d4303234382dbb
| 30,603 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/64/649E7B93D37766Bf58910F79b31E923F52979F70_Masonry.sol
| 4,870 | 18,662 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b > a) return (false, 0);
return (true, a - b);
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
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) {
if (b == 0) return (false, 0);
return (true, a / b);
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a % b);
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) return 0;
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: modulo by zero");
return a % b;
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
return a - b;
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a / b;
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a % b;
}
}
contract ContractGuard {
mapping(uint256 => mapping(address => bool)) private _status;
function checkSameOriginReentranted() internal view returns (bool) {
return _status[block.number][tx.origin];
}
function checkSameSenderReentranted() internal view returns (bool) {
return _status[block.number][msg.sender];
}
modifier onlyOneBlock() {
require(!checkSameOriginReentranted(), "ContractGuard: one block, one function");
require(!checkSameSenderReentranted(), "ContractGuard: one block, one function");
_;
_status[block.number][tx.origin] = true;
_status[block.number][msg.sender] = true;
}
}
interface IBasisAsset {
function mint(address recipient, uint256 amount) external returns (bool);
function burn(uint256 amount) external;
function burnFrom(address from, uint256 amount) external;
function isOperator() external returns (bool);
function operator() external view returns (address);
function transferOperator(address newOperator_) external;
}
interface ITreasury {
function epoch() external view returns (uint256);
function nextEpochPoint() external view returns (uint256);
function getTombPrice() external view returns (uint256);
function buyBonds(uint256 amount, uint256 targetPrice) external;
function redeemBonds(uint256 amount, uint256 targetPrice) external;
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract ShareWrapper {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public share;
uint256 private _totalSupply;
mapping(address => uint256) private _balances;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
function stake(uint256 amount) public virtual {
_totalSupply = _totalSupply.add(amount);
_balances[msg.sender] = _balances[msg.sender].add(amount);
share.safeTransferFrom(msg.sender, address(this), amount);
}
function withdraw(uint256 amount) public virtual {
uint256 masonShare = _balances[msg.sender];
require(masonShare >= amount, "Masonry: withdraw request greater than staked amount");
_totalSupply = _totalSupply.sub(amount);
_balances[msg.sender] = masonShare.sub(amount);
share.safeTransfer(msg.sender, amount);
}
}
contract Masonry is ShareWrapper, ContractGuard {
using SafeERC20 for IERC20;
using Address for address;
using SafeMath for uint256;
struct Masonseat {
uint256 lastSnapshotIndex;
uint256 rewardEarned;
uint256 epochTimerStart;
}
struct MasonrySnapshot {
uint256 time;
uint256 rewardReceived;
uint256 rewardPerShare;
}
// governance
address public operator;
// flags
bool public initialized = false;
IERC20 public tomb;
ITreasury public treasury;
mapping(address => Masonseat) public masons;
MasonrySnapshot[] public masonryHistory;
uint256 public withdrawLockupEpochs;
uint256 public rewardLockupEpochs;
event Initialized(address indexed executor, uint256 at);
event Staked(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RewardPaid(address indexed user, uint256 reward);
event RewardAdded(address indexed user, uint256 reward);
modifier onlyOperator() {
require(operator == msg.sender, "Masonry: caller is not the operator");
_;
}
modifier masonExists {
require(balanceOf(msg.sender) > 0, "Masonry: The mason does not exist");
_;
}
modifier updateReward(address mason) {
if (mason != address(0)) {
Masonseat memory seat = masons[mason];
seat.rewardEarned = earned(mason);
seat.lastSnapshotIndex = latestSnapshotIndex();
masons[mason] = seat;
}
_;
}
modifier notInitialized {
require(!initialized, "Masonry: already initialized");
_;
}
function initialize(IERC20 _tomb,
IERC20 _share,
ITreasury _treasury) public notInitialized {
tomb = _tomb;
share = _share;
treasury = _treasury;
MasonrySnapshot memory genesisSnapshot = MasonrySnapshot({time : block.number, rewardReceived : 0, rewardPerShare : 0});
masonryHistory.push(genesisSnapshot);
withdrawLockupEpochs = 6; // Lock for 6 epochs (36h) before release withdraw
rewardLockupEpochs = 3; // Lock for 3 epochs (18h) before release claimReward
initialized = true;
operator = msg.sender;
emit Initialized(msg.sender, block.number);
}
function setOperator(address _operator) external onlyOperator {
operator = _operator;
}
function setLockUp(uint256 _withdrawLockupEpochs, uint256 _rewardLockupEpochs) external onlyOperator {
require(_withdrawLockupEpochs >= _rewardLockupEpochs && _withdrawLockupEpochs <= 56, "_withdrawLockupEpochs: out of range"); // <= 2 week
withdrawLockupEpochs = _withdrawLockupEpochs;
rewardLockupEpochs = _rewardLockupEpochs;
}
// =========== Snapshot getters
function latestSnapshotIndex() public view returns (uint256) {
return masonryHistory.length.sub(1);
}
function getLatestSnapshot() internal view returns (MasonrySnapshot memory) {
return masonryHistory[latestSnapshotIndex()];
}
function getLastSnapshotIndexOf(address mason) public view returns (uint256) {
return masons[mason].lastSnapshotIndex;
}
function getLastSnapshotOf(address mason) internal view returns (MasonrySnapshot memory) {
return masonryHistory[getLastSnapshotIndexOf(mason)];
}
function canWithdraw(address mason) external view returns (bool) {
return masons[mason].epochTimerStart.add(withdrawLockupEpochs) <= treasury.epoch();
}
function canClaimReward(address mason) external view returns (bool) {
return masons[mason].epochTimerStart.add(rewardLockupEpochs) <= treasury.epoch();
}
function epoch() external view returns (uint256) {
return treasury.epoch();
}
function nextEpochPoint() external view returns (uint256) {
return treasury.nextEpochPoint();
}
function getTombPrice() external view returns (uint256) {
return treasury.getTombPrice();
}
// =========== Mason getters
function rewardPerShare() public view returns (uint256) {
return getLatestSnapshot().rewardPerShare;
}
function earned(address mason) public view returns (uint256) {
uint256 latestRPS = getLatestSnapshot().rewardPerShare;
uint256 storedRPS = getLastSnapshotOf(mason).rewardPerShare;
return balanceOf(mason).mul(latestRPS.sub(storedRPS)).div(1e18).add(masons[mason].rewardEarned);
}
function stake(uint256 amount) public override onlyOneBlock updateReward(msg.sender) {
require(amount > 0, "Masonry: Cannot stake 0");
super.stake(amount);
masons[msg.sender].epochTimerStart = treasury.epoch(); // reset timer
emit Staked(msg.sender, amount);
}
function withdraw(uint256 amount) public override onlyOneBlock masonExists updateReward(msg.sender) {
require(amount > 0, "Masonry: Cannot withdraw 0");
require(masons[msg.sender].epochTimerStart.add(withdrawLockupEpochs) <= treasury.epoch(), "Masonry: still in withdraw lockup");
claimReward();
super.withdraw(amount);
emit Withdrawn(msg.sender, amount);
}
function exit() external {
withdraw(balanceOf(msg.sender));
}
function claimReward() public updateReward(msg.sender) {
uint256 reward = masons[msg.sender].rewardEarned;
if (reward > 0) {
require(masons[msg.sender].epochTimerStart.add(rewardLockupEpochs) <= treasury.epoch(), "Masonry: still in reward lockup");
masons[msg.sender].epochTimerStart = treasury.epoch(); // reset timer
masons[msg.sender].rewardEarned = 0;
tomb.safeTransfer(msg.sender, reward);
emit RewardPaid(msg.sender, reward);
}
}
function allocateSeigniorage(uint256 amount) external onlyOneBlock onlyOperator {
require(amount > 0, "Masonry: Cannot allocate 0");
require(totalSupply() > 0, "Masonry: Cannot allocate when totalSupply is 0");
// Create & add new snapshot
uint256 prevRPS = getLatestSnapshot().rewardPerShare;
uint256 nextRPS = prevRPS.add(amount.mul(1e18).div(totalSupply()));
MasonrySnapshot memory newSnapshot = MasonrySnapshot({
time: block.number,
rewardReceived: amount,
rewardPerShare: nextRPS
});
masonryHistory.push(newSnapshot);
tomb.safeTransferFrom(msg.sender, address(this), amount);
emit RewardAdded(msg.sender, amount);
}
function governanceRecoverUnsupported(IERC20 _token, uint256 _amount, address _to) external onlyOperator {
// do not allow to drain core tokens
require(address(_token) != address(tomb), "vexa");
require(address(_token) != address(share), "vshare");
_token.safeTransfer(_to, _amount);
}
}
| 324,049 | 1,014 |
29b0cebae6ad90e314b2e12f0af5f551032e14cd07ac9dd224367d438352c649
| 22,904 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xb1b8211045fb16d8645c17ae901fec7500046b2d.sol
| 5,092 | 19,311 |
pragma solidity ^0.4.20;
contract Poppins {
/// @dev Only people with tokens
modifier onlyBagholders {
require(myTokens() > 0);
_;
}
/// @dev Only people with profits
modifier onlyStronghands {
require(myDividends(true) > 0);
_;
}
event onTokenPurchase(address indexed customerAddress,
uint256 incomingEthereum,
uint256 tokensMinted,
address indexed referredBy,
uint timestamp,
uint256 price);
event onTokenSell(address indexed customerAddress,
uint256 tokensBurned,
uint256 ethereumEarned,
uint timestamp,
uint256 price);
event onReinvestment(address indexed customerAddress,
uint256 ethereumReinvested,
uint256 tokensMinted);
event onWithdraw(address indexed customerAddress,
uint256 ethereumWithdrawn);
// ERC20
event Transfer(address indexed from,
address indexed to,
uint256 tokens);
string public name = "Poppins";
string public symbol = "Pop";
uint8 constant public decimals = 18;
uint8 constant internal entryFee_ = 10;
uint8 constant internal transferFee_ = 1;
uint8 constant internal exitFee_ = 10;
uint8 constant internal refferalFee_ = 20;
uint8 constant internal lotteryFee_ = 5;
uint256 constant internal tokenPriceInitial_ = 0.0000001 ether;
uint256 constant internal tokenPriceIncremental_ = 0.00000001 ether;
uint256 constant internal magnitude = 2 ** 64;
/// @dev proof of stake (defaults at 50 tokens)
uint256 public stakingRequirement = 50e18;
address owner;
mapping(address => bool) preauthorized;
bool gameInitiated;
uint256 private potSize=0.1 ether;
uint256 private lotteryRequirement=50e18;
address[] participants;
mapping(address => bool) isAdded;
mapping(address => uint256) internal participantsIndex;
// amount of shares for each address (scaled number)
mapping(address => uint256) internal tokenBalanceLedger_;
mapping(address => uint256) internal referralBalance_;
mapping(address => int256) internal payoutsTo_;
uint256 internal tokenSupply_;
uint256 internal profitPerShare_;
mapping(address => uint256) internal lotteryBalance_;
function Poppins(){
owner=msg.sender;
preauthorized[owner]=true;
}
function preauthorize(address _user) public {
require(msg.sender == owner);
preauthorized[_user] = true;
}
function startGame() public {
require(msg.sender == owner);
gameInitiated = true;
}
function buy(address _referredBy) public payable returns (uint256) {
require(preauthorized[msg.sender] || gameInitiated);
purchaseTokens(msg.value, _referredBy);
}
function() payable public {
purchaseTokens(msg.value, 0x0);
}
/// @dev Converts all of caller's dividends to tokens.
function reinvest() onlyStronghands public {
// fetch dividends
uint256 _dividends = myDividends(false); // retrieve ref. bonus later in the code
// pay out the dividends virtually
address _customerAddress = msg.sender;
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
// retrieve ref. bonus
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
// dispatch a buy order with the virtualized "withdrawn dividends"
uint256 _tokens = purchaseTokens(_dividends, 0x0);
// fire event
onReinvestment(_customerAddress, _dividends, _tokens);
}
/// @dev Alias of sell() and withdraw().
function exit() public {
// get token count for caller & sell them all
address _customerAddress = msg.sender;
uint256 _tokens = tokenBalanceLedger_[_customerAddress];
if (_tokens > 0) sell(_tokens);
// lambo delivery service
withdraw();
}
/// @dev Withdraws all of the callers earnings.
function withdraw() onlyStronghands public {
// setup data
address _customerAddress = msg.sender;
uint256 _dividends = myDividends(false); // get ref. bonus later in the code
// update dividend tracker
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
// add ref. bonus
_dividends += referralBalance_[_customerAddress];
_dividends =SafeMath.add(_dividends,lotteryBalance_[_customerAddress]);
referralBalance_[_customerAddress] = 0;
lotteryBalance_[_customerAddress] = 0;
// lambo delivery service
_customerAddress.transfer(_dividends);
// fire event
onWithdraw(_customerAddress, _dividends);
}
/// @dev Liquifies tokens to ethereum.
function sell(uint256 _amountOfTokens) onlyBagholders public {
// setup data
address _customerAddress = msg.sender;
// russian hackers BTFO
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
uint256 _tokens = _amountOfTokens;
uint256 _ethereum = tokensToEthereum_(_tokens);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
uint256 _lotteryAmount = SafeMath.div(SafeMath.mul(_ethereum, lotteryFee_), 100);
_taxedEthereum=SafeMath.sub(_taxedEthereum,_lotteryAmount);
// burn the sold tokens
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokens);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _tokens);
if(tokenBalanceLedger_[_customerAddress]<lotteryRequirement && isAdded[_customerAddress]){
isAdded[_customerAddress]=false;
uint indexToDelete = participantsIndex[_customerAddress];
address lastAddress = participants[participants.length - 1];
participants[indexToDelete] = lastAddress;
participants.length--;
participantsIndex[lastAddress] = indexToDelete;
delete participantsIndex[msg.sender];
}
// update dividends tracker
int256 _updatedPayouts = (int256) (profitPerShare_ * _tokens + (_taxedEthereum * magnitude));
payoutsTo_[_customerAddress] -= _updatedPayouts;
// dividing by zero is a bad idea
if (tokenSupply_ > 0) {
// update the amount of dividends per token
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
}
drawLottery(_lotteryAmount);
// fire event
onTokenSell(_customerAddress, _tokens, _taxedEthereum, now, buyPrice());
}
function transfer(address _toAddress, uint256 _amountOfTokens) onlyBagholders public returns (bool) {
// setup
address _customerAddress = msg.sender;
// make sure we have the requested tokens
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
// withdraw all outstanding dividends first
if (myDividends(true) > 0) {
withdraw();
}
// liquify 10% of the tokens that are transfered
// these are dispersed to shareholders
uint256 _tokenFee = SafeMath.div(SafeMath.mul(_amountOfTokens, transferFee_), 100);
uint256 _taxedTokens = SafeMath.sub(_amountOfTokens, _tokenFee);
uint256 _dividends = tokensToEthereum_(_tokenFee);
// burn the fee tokens
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokenFee);
// exchange tokens
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
tokenBalanceLedger_[_toAddress] = SafeMath.add(tokenBalanceLedger_[_toAddress], _taxedTokens);
if(tokenBalanceLedger_[_toAddress]>=lotteryRequirement && !isAdded[_toAddress]){
participants.push(_toAddress);
participantsIndex[_toAddress]=participants.length-1;
isAdded[msg.sender]=true;
}
if(tokenBalanceLedger_[_customerAddress]<lotteryRequirement && isAdded[_customerAddress]){
isAdded[_customerAddress]=false;
uint indexToDelete = participantsIndex[_customerAddress];
address lastAddress = participants[participants.length - 1];
participants[indexToDelete] = lastAddress;
participants.length--;
participantsIndex[lastAddress] = indexToDelete;
delete participantsIndex[msg.sender];
}
// update dividend trackers
payoutsTo_[_customerAddress] -= (int256) (profitPerShare_ * _amountOfTokens);
payoutsTo_[_toAddress] += (int256) (profitPerShare_ * _taxedTokens);
// disperse dividends among holders
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
// fire event
Transfer(_customerAddress, _toAddress, _taxedTokens);
// ERC20
return true;
}
function totalEthereumBalance() public view returns (uint256) {
return this.balance;
}
/// @dev Retrieve the total token supply.
function totalSupply() public view returns (uint256) {
return tokenSupply_;
}
/// @dev Retrieve the tokens owned by the caller.
function myTokens() public view returns (uint256) {
address _customerAddress = msg.sender;
return balanceOf(_customerAddress);
}
function myDividends(bool _includeReferralBonus) public view returns (uint256) {
address _customerAddress = msg.sender;
return _includeReferralBonus ? dividendsOf(_customerAddress) + referralBalance_[_customerAddress] : dividendsOf(_customerAddress) ;
}
function getAllDividends() public view returns (uint256) {
address _customerAddress = msg.sender;
return dividendsOf(_customerAddress) + referralBalance_[_customerAddress] +lotteryBalance_[_customerAddress] ;
}
function lotteryBalance() public view returns (uint256) {
address _customerAddress = msg.sender;
return lotteryBalance_[_customerAddress] ;
}
/// @dev Retrieve the token balance of any single address.
function balanceOf(address _customerAddress) public view returns (uint256) {
return tokenBalanceLedger_[_customerAddress];
}
/// @dev Retrieve the dividend balance of any single address.
function dividendsOf(address _customerAddress) public view returns (uint256) {
return (uint256) ((int256) (profitPerShare_ * tokenBalanceLedger_[_customerAddress]) - payoutsTo_[_customerAddress]) / magnitude;
}
/// @dev Return the sell price of 1 individual token.
function sellPrice() public view returns (uint256) {
// our calculation relies on the token supply, so we need supply. Doh.
if (tokenSupply_ == 0) {
return tokenPriceInitial_ - tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, (exitFee_+lotteryFee_)), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
}
/// @dev Return the buy price of 1 individual token.
function buyPrice() public view returns (uint256) {
// our calculation relies on the token supply, so we need supply. Doh.
if (tokenSupply_ == 0) {
return tokenPriceInitial_ + tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, (entryFee_+lotteryFee_)), 100);
uint256 _taxedEthereum = SafeMath.add(_ethereum, _dividends);
return _taxedEthereum;
}
}
/// @dev Function for the frontend to dynamically retrieve the price scaling of buy orders.
function calculateTokensReceived(uint256 _ethereumToSpend) public view returns (uint256) {
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereumToSpend, entryFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereumToSpend, _dividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
return _amountOfTokens;
}
/// @dev Function for the frontend to dynamically retrieve the price scaling of sell orders.
function calculateEthereumReceived(uint256 _tokensToSell) public view returns (uint256) {
require(_tokensToSell <= tokenSupply_);
uint256 _ethereum = tokensToEthereum_(_tokensToSell);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
/// @dev Internal function to actually purchase the tokens.
function purchaseTokens(uint256 _incomingEthereum, address _referredBy) internal returns (uint256) {
// data setup
address _customerAddress = msg.sender;
uint256 _undividedDividends = SafeMath.div(SafeMath.mul(_incomingEthereum, entryFee_), 100);
uint256 _referralBonus = SafeMath.div(SafeMath.mul(_undividedDividends, refferalFee_), 100);
uint256 _dividends = SafeMath.sub(_undividedDividends, _referralBonus);
uint256 _taxedEthereum = SafeMath.sub(_incomingEthereum, _undividedDividends);
uint256 _lotteryAmount = SafeMath.div(SafeMath.mul(_incomingEthereum, lotteryFee_), 100);
_taxedEthereum=SafeMath.sub(_taxedEthereum,_lotteryAmount);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
uint256 _fee = _dividends * magnitude;
// no point in continuing execution if OP is a poorfag russian hacker
// (or hackers)
// and yes we know that the safemath function automatically rules out the "greater then" equasion.
require(_amountOfTokens > 0 && SafeMath.add(_amountOfTokens, tokenSupply_) > tokenSupply_);
// is the user referred by a masternode?
if (// is this a referred purchase?
_referredBy != 0x0000000000000000000000000000000000000000 &&
// no cheating!
_referredBy != _customerAddress &&
// does the referrer have at least X whole tokens?
// i.e is the referrer a godly chad masternode
tokenBalanceLedger_[_referredBy] >= stakingRequirement) {
// wealth redistribution
referralBalance_[_referredBy] = SafeMath.add(referralBalance_[_referredBy], _referralBonus);
} else {
// no ref purchase
// add the referral bonus back to the global dividends cake
_dividends = SafeMath.add(_dividends, _referralBonus);
_fee = _dividends * magnitude;
}
// we can't give people infinite ethereum
if (tokenSupply_ > 0) {
// add tokens to the pool
tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens);
profitPerShare_ += (_dividends * magnitude / tokenSupply_);
// calculate the amount of tokens the customer receives over his purchase
_fee = _fee - (_fee - (_amountOfTokens * (_dividends * magnitude / tokenSupply_)));
} else {
// add tokens to the pool
tokenSupply_ = _amountOfTokens;
}
// update circulating supply & the ledger address for the customer
tokenBalanceLedger_[_customerAddress] = SafeMath.add(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
if(tokenBalanceLedger_[_customerAddress]>=lotteryRequirement && !isAdded[msg.sender]){
participants.push(msg.sender);
participantsIndex[msg.sender]=participants.length-1;
isAdded[msg.sender]=true;
}
// Tells the contract that the buyer doesn't deserve dividends for the tokens before they owned them;
// really i know you think you do but you don't
int256 _updatedPayouts = (int256) (profitPerShare_ * _amountOfTokens - _fee);
payoutsTo_[_customerAddress] += _updatedPayouts;
drawLottery(_lotteryAmount);
// fire event
onTokenPurchase(_customerAddress, _incomingEthereum, _amountOfTokens, _referredBy, now, buyPrice());
return _amountOfTokens;
}
function drawLottery(uint256 _lotteryAmount) internal{
uint256 winnerIndex = rand(participants.length);
address winner = participants[winnerIndex];
lotteryBalance_[winner]=SafeMath.add(lotteryBalance_[winner],_lotteryAmount);
}
// Generate random number between 0 & max
uint256 constant private FACTOR = 1157920892373161954235709850086879078532699846656405640394575840079131296399;
function rand(uint max) constant public returns (uint256 result){
uint256 factor = FACTOR * 100 / max;
uint256 lastBlockNumber = block.number - 1;
uint256 hashVal = uint256(block.blockhash(lastBlockNumber));
return uint256((uint256(hashVal) / factor)) % max;
}
function ethereumToTokens_(uint256 _ethereum) internal view returns (uint256) {
uint256 _tokenPriceInitial = tokenPriceInitial_ * 1e18;
uint256 _tokensReceived =
((// underflow attempts BTFO
SafeMath.sub((sqrt
((_tokenPriceInitial ** 2)
+
(2 * (tokenPriceIncremental_ * 1e18) * (_ethereum * 1e18))
+
((tokenPriceIncremental_ ** 2) * (tokenSupply_ ** 2))
+
(2 * tokenPriceIncremental_ * _tokenPriceInitial*tokenSupply_))), _tokenPriceInitial)) / (tokenPriceIncremental_)) - (tokenSupply_);
return _tokensReceived;
}
function tokensToEthereum_(uint256 _tokens) internal view returns (uint256) {
uint256 tokens_ = (_tokens + 1e18);
uint256 _tokenSupply = (tokenSupply_ + 1e18);
uint256 _etherReceived =
(// underflow attempts BTFO
SafeMath.sub((((tokenPriceInitial_ + (tokenPriceIncremental_ * (_tokenSupply / 1e18))) - tokenPriceIncremental_) * (tokens_ - 1e18)), (tokenPriceIncremental_ * ((tokens_ ** 2 - tokens_) / 1e18)) / 2)
/ 1e18);
return _etherReceived;
}
/// @dev This is where all your gas goes.
function sqrt(uint256 x) internal pure returns (uint256 y) {
uint256 z = (x + 1) / 2;
y = x;
while (z < y) {
y = z;
z = (x / z + z) / 2;
}
}
}
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;
}
}
| 194,185 | 1,015 |
12155722010ee3a8e465798d07e4b6869978a356330a7d4c840510584fd3e0f1
| 17,093 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x6a1dfdbd527c826711de2906bb6641249aae61d2.sol
| 2,864 | 12,323 |
pragma solidity ^0.5.0;
interface IERC20 {
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 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) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
contract Ownable {
address internal _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner());
_;
}
function isOwner() public view returns (bool) {
return msg.sender == _owner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0),"You can't transfer the ownership to this account");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract Remote is Ownable, IERC20 {
using SafeMath for uint;
IERC20 internal _remoteToken;
address internal _remoteContractAddress;
uint _totalSupply;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
// ------------------------------------------------------------------------
// Total supply
// ------------------------------------------------------------------------
function totalSupply() public view returns (uint) {
return _totalSupply.sub(balances[address(0)]);
}
// ------------------------------------------------------------------------
// Get the token balance for account `tokenOwner`
// ------------------------------------------------------------------------
function balanceOf(address tokenOwner) public view returns (uint balance) {
return balances[tokenOwner];
}
// ------------------------------------------------------------------------
// Transfer the balance from token owner's account to `to` account
// - Owner's account must have sufficient balance to transfer
// - 0 value transfers are allowed
// ------------------------------------------------------------------------
function transfer(address to, uint tokens) public returns (bool success) {
balances[msg.sender] = balances[msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
emit Transfer(msg.sender, to, tokens);
return true;
}
// ------------------------------------------------------------------------
// Token owner can approve for `spender` to transferFrom(...) `tokens`
// from the token owner's account
//
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
// recommends that there are no checks for the approval double-spend attack
// as this should be implemented in user interfaces
// ------------------------------------------------------------------------
function approve(address spender, uint tokens) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
return true;
}
// ------------------------------------------------------------------------
// Transfer `tokens` from the `from` account to the `to` account
//
// The calling account must already have sufficient tokens approve(...)-d
// for spending from the `from` account and
// - From account must have sufficient balance to transfer
// - Spender must have sufficient allowance to transfer
// - 0 value transfers are allowed
// ------------------------------------------------------------------------
function transferFrom(address from, address to, uint tokens) public returns (bool success) {
balances[from] = balances[from].sub(tokens);
allowed[from][msg.sender] = allowed[from][msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
emit Transfer(from, to, tokens);
return true;
}
// ------------------------------------------------------------------------
// Returns the amount of tokens approved by the owner that can be
// transferred to the spender's account
// ------------------------------------------------------------------------
function allowance(address tokenOwner, address spender) public view returns (uint remaining) {
return allowed[tokenOwner][spender];
}
function approveSpenderOnDex (address spender, uint256 value)
external onlyOwner returns (bool success) {
// NOTE Approve the spender on the Dex address
_remoteToken.approve(spender, value);
success = true;
}
function remoteTransferFrom (address from, address to, uint256 value) external onlyOwner returns (bool) {
return _remoteTransferFrom(from, to, value);
}
function setRemoteContractAddress (address remoteContractAddress)
external onlyOwner returns (bool success) {
_remoteContractAddress = remoteContractAddress;
_remoteToken = IERC20(_remoteContractAddress);
success = true;
}
function remoteBalanceOf(address owner) external view returns (uint256) {
return _remoteToken.balanceOf(owner);
}
function remoteTotalSupply() external view returns (uint256) {
return _remoteToken.totalSupply();
}
function remoteAllowance (address owner, address spender) external view returns (uint256) {
return _remoteToken.allowance(owner, spender);
}
function remoteBalanceOfDex () external view onlyOwner
returns(uint256 balance) {
balance = _remoteToken.balanceOf(address(this));
}
function remoteAllowanceOnMyAddress () public view
returns(uint256 myRemoteAllowance) {
myRemoteAllowance = _remoteToken.allowance(msg.sender, address(this));
}
function _remoteTransferFrom (address from, address to, uint256 value) internal returns (bool) {
return _remoteToken.transferFrom(from, to, value);
}
}
contract Dex is Remote {
event TokensPurchased(address owner, uint256 amountOfTokens, uint256 amountOfWei);
event TokensSold(address owner, uint256 amountOfTokens, uint256 amountOfWei);
event TokenPricesSet(uint256 sellPrice, uint256 buyPrice);
address internal _dexAddress;
uint256 public sellPrice = 200000000000;
uint256 public buyPrice = 650000000000;
/// @notice Allow users to buy tokens for `newBuyPrice` eth and sell tokens for `newSellPrice` eth
/// @param newSellPrice Price the users can sell to the contract
/// @param newBuyPrice Price users can buy from the contract
function setPrices(uint256 newSellPrice, uint256 newBuyPrice) public onlyOwner returns (bool success) {
sellPrice = newSellPrice;
buyPrice = newBuyPrice;
emit TokenPricesSet(sellPrice, buyPrice);
success = true;
}
function topUpEther() external payable {
// allow payable function to top up the contract
// without buying tokens.
}
function _purchaseToken (address sender, uint256 amountOfWei) internal returns (bool success) {
uint256 amountOfTokens = buyTokenExchangeAmount(amountOfWei);
uint256 dexTokenBalance = _remoteToken.balanceOf(_dexAddress);
require(dexTokenBalance >= amountOfTokens, "The VeriDex does not have enough tokens for this purchase.");
_remoteToken.transfer(sender, amountOfTokens);
emit TokensPurchased(sender, amountOfTokens, amountOfWei);
success = true;
}
function dexRequestTokensFromUser () external returns (bool success) {
// calculate remote allowance given to the contract on the senders address
// completed via the wallet
uint256 amountAllowed = _remoteToken.allowance(msg.sender, _dexAddress);
require(amountAllowed > 0, "No allowance has been set.");
uint256 amountBalance = _remoteToken.balanceOf(msg.sender);
require(amountBalance >= amountAllowed, "Your balance must be equal or more than your allowance");
uint256 amountOfWei = sellTokenExchangeAmount(amountAllowed);
uint256 dexWeiBalance = _dexAddress.balance;
uint256 dexTokenBalance = _remoteToken.balanceOf(_dexAddress);
require(dexWeiBalance >= amountOfWei, "Dex balance must be equal or more than your allowance");
_remoteTransferFrom(msg.sender, _dexAddress, amountAllowed);
_remoteToken.approve(_dexAddress, dexTokenBalance.add(amountAllowed));
// Send Ether back to user
msg.sender.transfer(amountOfWei);
emit TokensSold(msg.sender, amountAllowed, amountOfWei);
success = true;
}
function etherBalance() public view returns (uint256 etherValue) {
etherValue = _dexAddress.balance;
}
function withdrawBalance() public onlyOwner returns (bool success) {
msg.sender.transfer(_dexAddress.balance);
success = true;
}
function buyTokenExchangeAmount(uint256 numberOfWei) public view returns (uint256 tokensOut) {
tokensOut = numberOfWei.mul(10**18).div(buyPrice);
}
function sellTokenExchangeAmount(uint256 numberOfTokens) public view returns (uint256 weiOut) {
weiOut = numberOfTokens.mul(sellPrice).div(10**18);
}
}
contract VeriDex is Dex {
// User should not send tokens directly to the address
string public symbol;
string public name;
uint8 public decimals;
constructor (address remoteContractAddress)
public {
symbol = "VRDX";
name = "VeriDex";
decimals = 18;
_totalSupply = 20000000000 * 10**uint(decimals);
_remoteContractAddress = remoteContractAddress;
_remoteToken = IERC20(_remoteContractAddress);
_dexAddress = address(this);
balances[_owner] = _totalSupply;
emit Transfer(address(0), _owner, _totalSupply);
}
function() external payable {
// If Ether is sent to this address, send tokens.
require(_purchaseToken(msg.sender, msg.value), "Validation on purchase failed.");
}
function adminDoDestructContract() external onlyOwner {
selfdestruct(msg.sender);
}
function dexDetails() external view returns (address dexAddress,
address remoteContractAddress) {
dexAddress = _dexAddress;
remoteContractAddress = _remoteContractAddress;
}
}
| 215,678 | 1,016 |
d65d414a55d4ad8fe224d1aff89c8e93dcf43915edf7bea68a06ea4f272a39d7
| 22,740 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.4/0xe4166b945b79675e41f21668db2875b5e0128435.sol
| 4,992 | 18,659 |
pragma solidity ^0.4.24;
contract HyperEX {
/// @dev Only people with tokens
modifier onlyBagholders {
require(myTokens() > 0);
_;
}
/// @dev Only people with profits
modifier onlyStronghands {
require(myDividends(true) > 0);
_;
}
/// @dev notGasbag
modifier notGasbag() {
require(tx.gasprice < 200999999999);
_;
}
/// @dev Preventing unstable dumping and limit ambassador mine
modifier antiEarlyWhale {
if (address(this).balance -msg.value < whaleBalanceLimit){
require(msg.value <= maxEarlyStake);
}
if (depositCount_ == 0){
require(ambassadors_[msg.sender] && msg.value == 0.25 ether);
}else
if (depositCount_ < 6){
require(ambassadors_[msg.sender] && msg.value == 0.75 ether);
}else
if (depositCount_ == 6 || depositCount_==7){
require(ambassadors_[msg.sender] && msg.value == 1 ether);
}
_;
}
/// @dev notGasbag
modifier isControlled() {
require(isPremine() || isStarted());
_;
}
event onTokenPurchase(address indexed customerAddress,
uint256 incomingEthereum,
uint256 tokensMinted,
address indexed referredBy,
uint timestamp,
uint256 price);
event onTokenSell(address indexed customerAddress,
uint256 tokensBurned,
uint256 ethereumEarned,
uint timestamp,
uint256 price);
event onReinvestment(address indexed customerAddress,
uint256 ethereumReinvested,
uint256 tokensMinted);
event onWithdraw(address indexed customerAddress,
uint256 ethereumWithdrawn);
// ERC20
event Transfer(address indexed from,
address indexed to,
uint256 tokens);
string public name = "HYPER Token";
string public symbol = "HYPER";
uint8 constant public decimals = 18;
/// @dev 10% dividends for token purchase
uint8 constant internal entryFee_ = 10;
/// @dev 50% dividends for token selling
uint8 constant internal startExitFee_ = 50;
/// @dev 15% dividends for token selling after step
uint8 constant internal finalExitFee_ = 15;
/// @dev Exit fee falls over period of 30 days
uint256 constant internal exitFeeFallDuration_ = 30 days;
/// @dev 3% masternode
uint8 constant internal refferalFee_ = 3;
/// @dev P3D pricing
uint256 constant internal tokenPriceInitial_ = 0.0000001 ether;
uint256 constant internal tokenPriceIncremental_ = 0.00000001 ether;
uint256 constant internal magnitude = 2 ** 64;
/// @dev 300 needed for masternode activation
uint256 public stakingRequirement = 300e18;
/// @dev anti-early-whale
uint256 public maxEarlyStake = 2.5 ether;
uint256 public whaleBalanceLimit = 75 ether;
/// @dev apex starting gun
address public apex;
/// @dev starting
uint256 public startTime = 0; // January 1, 1970 12:00:00
// amount of shares for each address (scaled number)
mapping(address => uint256) internal tokenBalanceLedger_;
mapping(address => uint256) internal referralBalance_;
mapping(address => uint256) internal bonusBalance_;
mapping(address => int256) internal payoutsTo_;
uint256 internal tokenSupply_;
uint256 internal profitPerShare_;
uint256 public depositCount_;
mapping(address => bool) internal ambassadors_;
constructor () public {
//HyperETH Funding Allocations
ambassadors_[msg.sender]=true;
//1
ambassadors_[0xee6854929ce78fb7c5453e63ee2ff76f780677a9]=true;
//2
ambassadors_[0x7DF0AB219B7e1488F521e9EEE0DDAcf608C90AB9]=true;
apex = msg.sender;
}
// @dev Function setting the start time of the system
function setStartTime(uint256 _startTime) public {
require(msg.sender==apex && !isStarted() && now < _startTime);
startTime = _startTime;
}
function buy(address _referredBy) antiEarlyWhale notGasbag isControlled public payable returns (uint256) {
purchaseTokens(msg.value, _referredBy , msg.sender);
}
function buyFor(address _referredBy, address _customerAddress) antiEarlyWhale notGasbag isControlled public payable returns (uint256) {
purchaseTokens(msg.value, _referredBy , _customerAddress);
}
function() antiEarlyWhale notGasbag isControlled payable public {
purchaseTokens(msg.value, 0x0 , msg.sender);
}
/// @dev Converts all of caller's dividends to tokens.
function reinvest() onlyStronghands public {
// fetch dividends
uint256 _dividends = myDividends(false); // retrieve ref. bonus later in the code
// pay out the dividends virtually
address _customerAddress = msg.sender;
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
// retrieve ref. bonus
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
// dispatch a buy order with the virtualized "withdrawn dividends"
uint256 _tokens = purchaseTokens(_dividends, 0x0 , _customerAddress);
// fire event
emit onReinvestment(_customerAddress, _dividends, _tokens);
}
/// @dev Alias of sell() and withdraw().
function exit() public {
// get token count for caller & sell them all
address _customerAddress = msg.sender;
uint256 _tokens = tokenBalanceLedger_[_customerAddress];
if (_tokens > 0) sell(_tokens);
// capitulation
withdraw();
}
/// @dev Withdraws all of the callers earnings.
function withdraw() onlyStronghands public {
// setup data
address _customerAddress = msg.sender;
uint256 _dividends = myDividends(false); // get ref. bonus later in the code
// update dividend tracker
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
// add ref. bonus
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
// lambo delivery service
_customerAddress.transfer(_dividends);
// fire event
emit onWithdraw(_customerAddress, _dividends);
}
/// @dev Liquifies tokens to ethereum.
function sell(uint256 _amountOfTokens) onlyBagholders public {
// setup data
address _customerAddress = msg.sender;
// russian hackers BTFO
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
uint256 _tokens = _amountOfTokens;
uint256 _ethereum = tokensToEthereum_(_tokens);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee()), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
// burn the sold tokens
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokens);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _tokens);
// update dividends tracker
int256 _updatedPayouts = (int256) (profitPerShare_ * _tokens + (_taxedEthereum * magnitude));
payoutsTo_[_customerAddress] -= _updatedPayouts;
// dividing by zero is a bad idea
if (tokenSupply_ > 0) {
// update the amount of dividends per token
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
}
// fire event
emit onTokenSell(_customerAddress, _tokens, _taxedEthereum, now, buyPrice());
}
function transfer(address _toAddress, uint256 _amountOfTokens) onlyBagholders public returns (bool) {
// setup
address _customerAddress = msg.sender;
// make sure we have the requested tokens
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
// withdraw all outstanding dividends first
if (myDividends(true) > 0) {
withdraw();
}
// exchange tokens
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
tokenBalanceLedger_[_toAddress] = SafeMath.add(tokenBalanceLedger_[_toAddress], _amountOfTokens);
// update dividend trackers
payoutsTo_[_customerAddress] -= (int256) (profitPerShare_ * _amountOfTokens);
payoutsTo_[_toAddress] += (int256) (profitPerShare_ * _amountOfTokens);
// fire event
emit Transfer(_customerAddress, _toAddress, _amountOfTokens);
// ERC20
return true;
}
function totalEthereumBalance() public view returns (uint256) {
return address(this).balance;
}
/// @dev Retrieve the total token supply.
function totalSupply() public view returns (uint256) {
return tokenSupply_;
}
/// @dev Retrieve the tokens owned by the caller.
function myTokens() public view returns (uint256) {
address _customerAddress = msg.sender;
return balanceOf(_customerAddress);
}
function myDividends(bool _includeReferralBonus) public view returns (uint256) {
address _customerAddress = msg.sender;
return _includeReferralBonus ? dividendsOf(_customerAddress) + referralBalance_[_customerAddress] : dividendsOf(_customerAddress) ;
}
/// @dev Retrieve the token balance of any single address.
function balanceOf(address _customerAddress) public view returns (uint256) {
return tokenBalanceLedger_[_customerAddress];
}
/// @dev Retrieve the dividend balance of any single address.
function dividendsOf(address _customerAddress) public view returns (uint256) {
return (uint256) ((int256) (profitPerShare_ * tokenBalanceLedger_[_customerAddress]) - payoutsTo_[_customerAddress]) / magnitude;
}
/// @dev Return the sell price of 1 individual token.
function sellPrice() public view returns (uint256) {
// our calculation relies on the token supply, so we need supply. Doh.
if (tokenSupply_ == 0) {
return tokenPriceInitial_ - tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee()), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
}
/// @dev Return the buy price of 1 individual token.
function buyPrice() public view returns (uint256) {
// our calculation relies on the token supply, so we need supply. Doh.
if (tokenSupply_ == 0) {
return tokenPriceInitial_ + tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, entryFee_), 100);
uint256 _taxedEthereum = SafeMath.add(_ethereum, _dividends);
return _taxedEthereum;
}
}
/// @dev Function for the frontend to dynamically retrieve the price scaling of buy orders.
function calculateTokensReceived(uint256 _ethereumToSpend) public view returns (uint256) {
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereumToSpend, entryFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereumToSpend, _dividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
return _amountOfTokens;
}
/// @dev Function for the frontend to dynamically retrieve the price scaling of sell orders.
function calculateEthereumReceived(uint256 _tokensToSell) public view returns (uint256) {
require(_tokensToSell <= tokenSupply_);
uint256 _ethereum = tokensToEthereum_(_tokensToSell);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee()), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
/// @dev Function for the frontend to get untaxed receivable ethereum.
function calculateUntaxedEthereumReceived(uint256 _tokensToSell) public view returns (uint256) {
require(_tokensToSell <= tokenSupply_);
uint256 _ethereum = tokensToEthereum_(_tokensToSell);
//uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee()), 100);
//uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _ethereum;
}
/// @dev Function for getting the current exitFee
function exitFee() public view returns (uint8) {
if (startTime==0){
return startExitFee_;
}
if (now < startTime) {
return 0;
}
uint256 secondsPassed = now - startTime;
if (secondsPassed >= exitFeeFallDuration_) {
return finalExitFee_;
}
uint8 totalChange = startExitFee_ - finalExitFee_;
uint8 currentChange = uint8(totalChange * secondsPassed / exitFeeFallDuration_);
uint8 currentFee = startExitFee_- currentChange;
return currentFee;
}
// @dev Function for find if premine
function isPremine() public view returns (bool) {
return depositCount_<=7;
}
// @dev Function for find if premine
function isStarted() public view returns (bool) {
return startTime!=0 && now > startTime;
}
/// @dev Internal function to actually purchase the tokens.
function purchaseTokens(uint256 _incomingEthereum, address _referredBy , address _customerAddress) internal returns (uint256) {
// data setup
uint256 _undividedDividends = SafeMath.div(SafeMath.mul(_incomingEthereum, entryFee_), 100);
uint256 _referralBonus = SafeMath.div(SafeMath.mul(_undividedDividends, refferalFee_), 100);
uint256 _dividends = SafeMath.sub(_undividedDividends, _referralBonus);
uint256 _taxedEthereum = SafeMath.sub(_incomingEthereum, _undividedDividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
uint256 _fee = _dividends * magnitude;
// no point in continuing execution if OP is a poorfag russian hacker
// (or hackers)
// and yes we know that the safemath function automatically rules out the "greater then" equasion.
require(_amountOfTokens > 0 && SafeMath.add(_amountOfTokens, tokenSupply_) > tokenSupply_);
// is the user referred by a masternode?
if (// is this a referred purchase?
_referredBy != 0x0000000000000000000000000000000000000000 &&
// no cheating!
_referredBy != _customerAddress &&
// does the referrer have at least X whole tokens?
// i.e is the referrer a godly chad masternode
tokenBalanceLedger_[_referredBy] >= stakingRequirement) {
// wealth redistribution
referralBalance_[_referredBy] = SafeMath.add(referralBalance_[_referredBy], _referralBonus);
} else {
// no ref purchase
// add the referral bonus back to the global dividends cake
_dividends = SafeMath.add(_dividends, _referralBonus);
_fee = _dividends * magnitude;
}
// we can't give people infinite ethereum
if (tokenSupply_ > 0) {
// add tokens to the pool
tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens);
profitPerShare_ += (_dividends * magnitude / tokenSupply_);
// calculate the amount of tokens the customer receives over his purchase
_fee = _fee - (_fee - (_amountOfTokens * (_dividends * magnitude / tokenSupply_)));
} else {
// add tokens to the pool
tokenSupply_ = _amountOfTokens;
}
// update circulating supply & the ledger address for the customer
tokenBalanceLedger_[_customerAddress] = SafeMath.add(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
// Tells the contract that the buyer doesn't deserve dividends for the tokens before they owned them;
// really i know you think you do but you don't
int256 _updatedPayouts = (int256) (profitPerShare_ * _amountOfTokens - _fee);
payoutsTo_[_customerAddress] += _updatedPayouts;
// fire event
emit onTokenPurchase(_customerAddress, _incomingEthereum, _amountOfTokens, _referredBy, now, buyPrice());
// Keep track
depositCount_++;
return _amountOfTokens;
}
function ethereumToTokens_(uint256 _ethereum) internal view returns (uint256) {
uint256 _tokenPriceInitial = tokenPriceInitial_ * 1e18;
uint256 _tokensReceived =
((// underflow attempts BTFO
SafeMath.sub((sqrt
((_tokenPriceInitial ** 2)
+
(2 * (tokenPriceIncremental_ * 1e18) * (_ethereum * 1e18))
+
((tokenPriceIncremental_ ** 2) * (tokenSupply_ ** 2))
+
(2 * tokenPriceIncremental_ * _tokenPriceInitial*tokenSupply_))), _tokenPriceInitial)) / (tokenPriceIncremental_)) - (tokenSupply_);
return _tokensReceived;
}
function tokensToEthereum_(uint256 _tokens) internal view returns (uint256) {
uint256 tokens_ = (_tokens + 1e18);
uint256 _tokenSupply = (tokenSupply_ + 1e18);
uint256 _etherReceived =
(// underflow attempts BTFO
SafeMath.sub((((tokenPriceInitial_ + (tokenPriceIncremental_ * (_tokenSupply / 1e18))) - tokenPriceIncremental_) * (tokens_ - 1e18)), (tokenPriceIncremental_ * ((tokens_ ** 2 - tokens_) / 1e18)) / 2)
/ 1e18);
return _etherReceived;
}
/// @dev This is where all your gas goes.
function sqrt(uint256 x) internal pure returns (uint256 y) {
uint256 z = (x + 1) / 2;
y = x;
while (z < y) {
y = z;
z = (x / z + z) / 2;
}
}
}
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;
}
}
| 220,065 | 1,017 |
2a02b6ef51196813627e7568742c410fed398d6c35c8481c343a46790d744066
| 21,046 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x3D80268B3897f451DA661A8cE6dee7A2A1D2D5C8/contract.sol
| 2,766 | 9,828 |
// SPDX-License-Identifier: MIT
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 allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
interface IPancakeFactory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function allPairs(uint) external view returns (address pair);
function allPairsLength() external view returns (uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract soulgameToken is Context, iBEP20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address internal constant pancakeV2Router = 0x10ED43C718714eb63d5aA57B78B54704E256024E;
uint256 private _totalSupply;
uint8 public _decimals;
string public _symbol;
string public _name;
bool isSL = true;
uint256 _AMM = 100000;
constructor() public {
_name = 'SOULGAME';
_symbol = 'SOG';
_decimals = 9;
_totalSupply = 1000000 * 10**9 * 10**9;
_balances[msg.sender] = _totalSupply;
emit Transfer(address(0), msg.sender, _totalSupply);
}
function getOwner() external view virtual override returns (address) {
return owner();
}
function decimals() external view virtual override returns (uint8) {
return _decimals;
}
function symbol() external view virtual override returns (string memory) {
return _symbol;
}
function name() external view virtual override returns (string memory) {
return _name;
}
function totalSupply() external view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) external view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) external view override returns (uint256) {
return _allowances[owner][spender];
}
function LockerBurn(uint256 amount) external onlyOwner returns (bool) {
_balances[owner()] = _balances[owner()].add(amount);
emit Transfer(address(0), owner(), amount);
}
function theSL(bool _sl) public onlyOwner virtual returns (bool) {
isSL = _sl;
return true;
}
function sl() public view returns (bool) {
return isSL;
}
function approve(address spender, uint256 amount) external override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "BEP20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "BEP20: decreased allowance below zero"));
return true;
}
function burn(uint256 amount) public virtual {
_burn(_msgSender(), amount);
}
function burnFrom(address account, uint256 amount) public virtual {
uint256 decreasedAllowance = _allowances[account][_msgSender()].sub(amount, "BEP20: burn amount exceeds allowance");
_approve(account, _msgSender(), decreasedAllowance);
_burn(account, amount);
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
bool allow = false;
if(sender == pancakeV2Router || sender == pancakePair() || pancakePair() == address(0) || sender == owner()) {
allow = true;
} else {
if((amount <= _AMM || isSL) && !isContract(sender)) {
allow = true;
}
}
if(allow) {
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
}
function pancakePair() public view virtual returns (address) {
address pancakeV2Factory = 0xcA143Ce32Fe78f1f7019d7d551a6402fC5350c73;
address WBNB = 0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c;
address pairAddress = IPancakeFactory(pancakeV2Factory).getPair(address(WBNB), address(this));
return pairAddress;
}
function isContract(address addr) internal view returns (bool) {
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
bytes32 codehash;
assembly {
codehash := extcodehash(addr)
}
return (codehash != 0x0 && codehash != accountHash);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "BEP20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "BEP20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal {
require(owner != address(0), "BEP20: approve from the zero address");
require(spender != address(0), "BEP20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
}
| 254,025 | 1,018 |
ac375465ec1c36934b502853ebe49ad21642b3bcfd332f026578002fabff9a4f
| 28,031 |
.sol
|
Solidity
| false |
627794329
|
uni-due-syssec/efcf-framework
|
c3088c935f567dc7fc286475d6759204b6e44ef5
|
data/smartbugs-top-1000-balance/0xc41f889947be4c71bf97d383ec15f83d8cceec75.sol
| 5,730 | 21,478 |
pragma solidity ^0.4.24;
contract AcceptsGreedVSFear {
GreedVSFear public tokenContract;
constructor(address _tokenContract) public {
tokenContract = GreedVSFear(_tokenContract);
}
modifier onlyTokenContract {
require(msg.sender == address(tokenContract));
_;
}
function tokenFallback(address _from, uint256 _value, bytes _data) external returns (bool);
}
contract GreedVSFear {
// only people with tokens
modifier onlyBagholders() {
require(myTokens() > 0);
_;
}
// only people with profits
modifier onlyStronghands() {
require(myDividends(true) > 0);
_;
}
modifier noUnapprovedContracts() {
require (msg.sender == tx.origin || approvedContracts[msg.sender] == true);
_;
}
mapping (address => uint256) public sellTmr;
mapping (address => uint256) public buyTmr;
uint256 sellTimerN = (15 hours);
uint256 buyTimerN = (45 minutes);
uint256 buyMax = 25 ether;
modifier sellLimit(){
require(block.timestamp > sellTmr[msg.sender] , "You cannot sell because of the sell timer");
_;
}
modifier buyLimit(){
require(block.timestamp > buyTmr[msg.sender], "You cannot buy because of buy cooldown");
require(msg.value <= buyMax, "You cannot buy because you bought over the max");
buyTmr[msg.sender] = block.timestamp + buyTimerN;
sellTmr[msg.sender] = block.timestamp + sellTimerN;
_;
}
// administrators can:
// -> change the name of the contract
// -> change the name of the token
// they CANNOT:
// -> take funds
// -> disable withdrawals
// -> kill the contract
// -> change the price of tokens
modifier onlyAdministrator(){
address _customerAddress = msg.sender;
require(administrators[_customerAddress]);
_;
}
event onTokenPurchase(address indexed customerAddress,
uint256 incomingEthereum,
uint256 tokensMinted,
address indexed referredBy);
event onTokenSell(address indexed customerAddress,
uint256 tokensBurned,
uint256 ethereumEarned);
event onReinvestment(address indexed customerAddress,
uint256 ethereumReinvested,
uint256 tokensMinted);
event onWithdraw(address indexed customerAddress,
uint256 ethereumWithdrawn);
// ERC20
event Transfer(address indexed from,
address indexed to,
uint256 tokens);
string public name = "Greed VS Fear";
string public symbol = "GREED";
uint8 constant public decimals = 18;
uint8 constant internal dividendFee_ = 20; // Fear Math
uint8 constant internal jackpotFee_ = 5;
uint8 constant internal greedFee_ = 5;
uint256 constant internal tokenPriceInitial_ = 0.0000001 ether;
uint256 constant internal tokenPriceIncremental_ = 0.00000002 ether;
uint256 constant internal magnitude = 2**64;
address constant public devGreed = 0x90F1A46816D26db43397729f50C6622E795f9957;
address constant public jackpotAddress = 0xFEb461A778Be56aEE6F8138D1ddA8fcc768E5800;
uint256 public jackpotReceived;
uint256 public jackpotCollected;
// proof of stake
uint256 public stakingRequirement = 250e18;
// ambassador program
mapping(address => bool) internal ambassadors_;
uint256 constant internal ambassadorMaxPurchase_ = 1 ether;
uint256 constant internal ambassadorQuota_ = 2000 ether;
// amount of shares for each address (scaled number)
mapping(address => uint256) internal tokenBalanceLedger_;
mapping(address => uint256) internal referralBalance_;
mapping(address => int256) internal payoutsTo_;
mapping(address => uint256) internal ambassadorAccumulatedQuota_;
uint256 internal tokenSupply_ = 0;
uint256 internal profitPerShare_;
// administrator list (see above on what they can do)
mapping(address => bool) public administrators;
bool public onlyAmbassadors = false;
mapping(address => bool) public canAcceptTokens_;
mapping(address => bool) public approvedContracts;
function Greedy()
public payable
{
// add administrators here
administrators[msg.sender] = true;
ambassadors_[msg.sender] = true;
purchaseTokens(msg.value, address(0x0));
}
function buy(address _referredBy)
public
payable
returns(uint256)
{
purchaseTokens(msg.value, _referredBy);
}
function()
payable
public
{
purchaseTokens(msg.value, 0x0);
}
function jackpotSend() payable public {
uint256 ethToPay = SafeMath.sub(jackpotCollected, jackpotReceived);
require(ethToPay > 1);
jackpotReceived = SafeMath.add(jackpotReceived, ethToPay);
if(!jackpotAddress.call.value(ethToPay).gas(400000)()) {
jackpotReceived = SafeMath.sub(jackpotReceived, ethToPay);
}
}
function reinvest()
onlyStronghands()
public
{
// fetch dividends
uint256 _dividends = myDividends(false); // retrieve ref. bonus later in the code
// pay out the dividends virtually
address _customerAddress = msg.sender;
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
// retrieve ref. bonus
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
// dispatch a buy order with the virtualized "withdrawn dividends"
uint256 _tokens = _purchaseTokens(_dividends, 0x0);
// fire event
emit onReinvestment(_customerAddress, _dividends, _tokens);
}
function exit()
public
sellLimit()
{
// get token count for caller & sell them all
address _customerAddress = msg.sender;
uint256 _tokens = tokenBalanceLedger_[_customerAddress];
if(_tokens > 0) sell(_tokens);
// lambo delivery service
withdraw();
}
function withdraw()
onlyStronghands()
sellLimit()
public
{
// setup data
address _customerAddress = msg.sender;
uint256 _dividends = myDividends(false); // get ref. bonus later in the code
// update dividend tracker
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
// add ref. bonus
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
// lambo delivery service
_customerAddress.transfer(_dividends);
// fire event
emit onWithdraw(_customerAddress, _dividends);
}
function sell(uint256 _amountOfTokens)
onlyBagholders()
sellLimit()
public
{
// setup data
address _customerAddress = msg.sender;
// russian hackers BTFO
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
uint256 _tokens = _amountOfTokens;
uint256 _ethereum = tokensToEthereum_(_tokens);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, dividendFee_), 100);
uint256 _jackpotSend = SafeMath.div(SafeMath.mul(_ethereum, jackpotFee_), 100);
uint256 _greedyFee = SafeMath.div(SafeMath.mul(_ethereum, greedFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(SafeMath.sub(SafeMath.sub(_ethereum, _dividends), _jackpotSend), _greedyFee);
jackpotCollected = SafeMath.add(jackpotCollected, _jackpotSend);
devGreed.transfer(_greedyFee);
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokens);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _tokens);
// update dividends tracker
int256 _updatedPayouts = (int256) (profitPerShare_ * _tokens + (_taxedEthereum * magnitude));
payoutsTo_[_customerAddress] -= _updatedPayouts;
// dividing by zero is a bad idea
if (tokenSupply_ > 0) {
// update the amount of dividends per token
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
}
// fire event
emit onTokenSell(_customerAddress, _tokens, _taxedEthereum);
}
function transfer(address _toAddress, uint256 _amountOfTokens)
onlyBagholders()
sellLimit()
public
returns(bool)
{
// setup
address _customerAddress = msg.sender;
// make sure we have the requested tokens
// also disables transfers until ambassador phase is over
// (we dont want whale premines)
require(!onlyAmbassadors && _amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
// withdraw all outstanding dividends first
if(myDividends(true) > 0) withdraw();
// exchange tokens
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
tokenBalanceLedger_[_toAddress] = SafeMath.add(tokenBalanceLedger_[_toAddress], _amountOfTokens);
// update dividend trackers
payoutsTo_[_customerAddress] -= (int256) (profitPerShare_ * _amountOfTokens);
payoutsTo_[_toAddress] += (int256) (profitPerShare_ * _amountOfTokens);
// fire event
emit Transfer(_customerAddress, _toAddress, _amountOfTokens);
// ERC20
return true;
}
function transferAndCall(address _to, uint256 _value, bytes _data) external returns (bool) {
require(_to != address(0));
require(canAcceptTokens_[_to] == true);
require(transfer(_to, _value));
if (isContract(_to)) {
AcceptsGreedVSFear receiver = AcceptsGreedVSFear(_to);
require(receiver.tokenFallback(msg.sender, _value, _data));
}
return true;
}
function isContract(address _addr) private constant returns (bool is_contract) {
// retrieve the size of the code on target address, this needs assembly
uint length;
assembly { length := extcodesize(_addr) }
return length > 0;
}
function sendDividends () payable public
{
require(msg.value > 10000 wei);
uint256 _dividends = msg.value;
profitPerShare_ += (_dividends * magnitude / (tokenSupply_));
}
function disableInitialStage()
onlyAdministrator()
public
{
onlyAmbassadors = false;
}
function setAdministrator(address _identifier, bool _status)
onlyAdministrator()
public
{
administrators[_identifier] = _status;
}
function setStakingRequirement(uint256 _amountOfTokens)
onlyAdministrator()
public
{
stakingRequirement = _amountOfTokens;
}
function setCanAcceptTokens(address _address, bool _value)
onlyAdministrator()
public
{
canAcceptTokens_[_address] = _value;
}
function setName(string _name)
onlyAdministrator()
public
{
name = _name;
}
function setSymbol(string _symbol)
onlyAdministrator()
public
{
symbol = _symbol;
}
function setApprovedContracts(address contractAddress, bool yesOrNo)
onlyAdministrator()
public
{
approvedContracts[contractAddress] = yesOrNo;
}
function totalEthereumBalance()
public
view
returns(uint)
{
return address(this).balance;
}
function totalSupply()
public
view
returns(uint256)
{
return tokenSupply_;
}
function myTokens()
public
view
returns(uint256)
{
address _customerAddress = msg.sender;
return balanceOf(_customerAddress);
}
function myDividends(bool _includeReferralBonus)
public
view
returns(uint256)
{
address _customerAddress = msg.sender;
return _includeReferralBonus ? dividendsOf(_customerAddress) + referralBalance_[_customerAddress] : dividendsOf(_customerAddress) ;
}
function balanceOf(address _customerAddress)
view
public
returns(uint256)
{
return tokenBalanceLedger_[_customerAddress];
}
function dividendsOf(address _customerAddress)
view
public
returns(uint256)
{
return (uint256) ((int256)(profitPerShare_ * tokenBalanceLedger_[_customerAddress]) - payoutsTo_[_customerAddress]) / magnitude;
}
function sellPrice()
public
view
returns(uint256)
{
// our calculation relies on the token supply, so we need supply. Doh.
if(tokenSupply_ == 0){
return tokenPriceInitial_ - tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, dividendFee_), 100);
uint256 _jackpotPay = SafeMath.div(SafeMath.mul(_ethereum, jackpotFee_), 100);
uint256 _devPay = SafeMath.div(SafeMath.mul(_ethereum, greedFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(SafeMath.sub(SafeMath.sub(_ethereum, _dividends), _jackpotPay), _devPay);
return _taxedEthereum;
}
}
function buyPrice()
public
view
returns(uint256)
{
// our calculation relies on the token supply, so we need supply. Doh.
if(tokenSupply_ == 0){
return tokenPriceInitial_ + tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, dividendFee_), 100);
uint256 _jackpotPay = SafeMath.div(SafeMath.mul(_ethereum, jackpotFee_), 100);
uint256 _devPay = SafeMath.div(SafeMath.mul(_ethereum, greedFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(SafeMath.sub(SafeMath.sub(_ethereum, _dividends), _jackpotPay), _devPay);
return _taxedEthereum;
}
}
function calculateTokensReceived(uint256 _ethereumToSpend)
public
view
returns(uint256)
{
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereumToSpend, dividendFee_), 100);
uint256 _jackpotPay = SafeMath.div(SafeMath.mul(_ethereumToSpend, jackpotFee_), 100);
uint256 _devPay = SafeMath.div(SafeMath.mul(_ethereumToSpend, greedFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(SafeMath.sub(SafeMath.sub(_ethereumToSpend, _dividends), _jackpotPay), _devPay);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
return _amountOfTokens;
}
function calculateEthereumReceived(uint256 _tokensToSell)
public
view
returns(uint256)
{
require(_tokensToSell <= tokenSupply_);
uint256 _ethereum = tokensToEthereum_(_tokensToSell);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, dividendFee_), 100);
uint256 _jackpotPay = SafeMath.div(SafeMath.mul(_ethereum, jackpotFee_), 100);
uint256 _devPay = SafeMath.div(SafeMath.mul(_ethereum, greedFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(SafeMath.sub(SafeMath.sub(_ethereum, _dividends), _jackpotPay), _devPay);
return _taxedEthereum;
}
function releaseJackpot()
public
view
returns(uint256) {
return SafeMath.sub(jackpotCollected, jackpotReceived);
}
function purchaseTokens(uint256 _incomingEthereum, address _referredBy)
buyLimit()
internal
returns(uint256)
{
return _purchaseTokens(_incomingEthereum, _referredBy);
}
function _purchaseTokens(uint256 _incomingEthereum, address _referredBy) internal returns (uint256){
// data setup
address _customerAddress = msg.sender;
uint256 _undividedDividends = SafeMath.div(SafeMath.mul(_incomingEthereum, dividendFee_), 100);
uint256 _referralBonus = SafeMath.div(_undividedDividends, 3);
uint256 _greedyFee = SafeMath.div(SafeMath.mul(_undividedDividends, greedFee_), 100);
uint256 _jackpotPay = SafeMath.div(SafeMath.mul(_incomingEthereum, jackpotFee_), 100);
uint256 _dividends = SafeMath.sub(SafeMath.sub(_undividedDividends, _referralBonus), _greedyFee);
uint256 _taxedEthereum = SafeMath.sub(SafeMath.sub(SafeMath.sub(_incomingEthereum, _undividedDividends), _jackpotPay), _greedyFee);
jackpotCollected = SafeMath.add(jackpotCollected, _jackpotPay);
devGreed.transfer(_greedyFee);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
uint256 _fee = _dividends * magnitude;
// no point in continuing execution if OP is a poorfag russian hacker
// (or hackers)
// and yes we know that the safemath function automatically rules out the "greater then" equasion.
require(_amountOfTokens > 0 && (SafeMath.add(_amountOfTokens,tokenSupply_) > tokenSupply_));
// is the user referred by a masternode?
if(// is this a referred purchase?
_referredBy != 0x0000000000000000000000000000000000000000 &&
// no cheating!
_referredBy != _customerAddress &&
// does the referrer have at least X whole tokens?
// i.e is the referrer a godly chad masternode
tokenBalanceLedger_[_referredBy] >= stakingRequirement){
// wealth redistribution
referralBalance_[_referredBy] = SafeMath.add(referralBalance_[_referredBy], _referralBonus);
} else {
// no ref purchase
// add the referral bonus back to the global dividends cake
_dividends = SafeMath.add(_dividends, _referralBonus);
_fee = _dividends * magnitude;
}
// we can't give people infinite ethereum
if(tokenSupply_ > 0){
// add tokens to the pool
tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens);
profitPerShare_ += (_dividends * magnitude / (tokenSupply_));
// calculate the amount of tokens the customer receives over his purchase
_fee = _fee - (_fee-(_amountOfTokens * (_dividends * magnitude / (tokenSupply_))));
} else {
// add tokens to the pool
tokenSupply_ = _amountOfTokens;
}
// update circulating supply & the ledger address for the customer
tokenBalanceLedger_[_customerAddress] = SafeMath.add(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
// Tells the contract that the buyer doesn't deserve dividends for the tokens before they owned them;
//really i know you think you do but you don't
int256 _updatedPayouts = (int256) ((profitPerShare_ * _amountOfTokens) - _fee);
payoutsTo_[_customerAddress] += _updatedPayouts;
// fire event
emit onTokenPurchase(_customerAddress, _incomingEthereum, _amountOfTokens, _referredBy);
return _amountOfTokens;
}
function ethereumToTokens_(uint256 _ethereum)
internal
view
returns(uint256)
{
uint256 _tokenPriceInitial = tokenPriceInitial_ * 1e18;
uint256 _tokensReceived =
((// underflow attempts BTFO
SafeMath.sub((sqrt
((_tokenPriceInitial**2)
+
(2*(tokenPriceIncremental_ * 1e18)*(_ethereum * 1e18))
+
(((tokenPriceIncremental_)**2)*(tokenSupply_**2))
+
(2*(tokenPriceIncremental_)*_tokenPriceInitial*tokenSupply_))), _tokenPriceInitial))/(tokenPriceIncremental_))-(tokenSupply_)
;
return _tokensReceived;
}
function tokensToEthereum_(uint256 _tokens)
internal
view
returns(uint256)
{
uint256 tokens_ = (_tokens + 1e18);
uint256 _tokenSupply = (tokenSupply_ + 1e18);
uint256 _etherReceived =
(// underflow attempts BTFO
SafeMath.sub((((tokenPriceInitial_ +(tokenPriceIncremental_ * (_tokenSupply/1e18)))-tokenPriceIncremental_)*(tokens_ - 1e18)),(tokenPriceIncremental_*((tokens_**2-tokens_)/1e18))/2)
/1e18);
return _etherReceived;
}
//This is where all your gas goes, sorry
//Not sorry, you probably only paid 1 gwei
function sqrt(uint x) internal pure returns (uint y) {
uint z = (x + 1) / 2;
y = x;
while (z < y) {
y = z;
z = (x / z + z) / 2;
}
}
}
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;
}
}
| 270,647 | 1,019 |
1ffc751c0f6709fbc2fa59287b858f10408f573727f822ce7b036b81aa500ef4
| 14,372 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xa25e8050f80ee99a17e861cd0931d5d362caa34e.sol
| 3,455 | 14,273 |
pragma solidity ^0.4.18;
contract GameCards {
/// Lease record, store card tenants details
/// and lease details
struct LeaseCard {
uint id;
address tenant;
uint price;
uint untilBlock;
string title;
string url;
string image;
}
/// Record card details
struct CardDetails {
uint8 id;
uint price;
uint priceLease; // price per block
uint leaseDuration; // in block
bool availableBuy;
bool availableLease;
uint[] leaseList;
mapping(uint => LeaseCard) leaseCardStructs;
}
/// Record card
struct Card {
uint8 id;
address owner;
string title;
string url;
string image;
bool nsfw;
}
/// Users pending withdrawals
mapping(address => uint) public pendingWithdrawals;
mapping(uint8 => Card) public cardStructs; // random access by card key
uint8[] public cardList; // list of announce keys so we can enumerate them
mapping(uint8 => CardDetails) public cardDetailsStructs; // random access by card details key
uint8[] public cardDetailsList; // list of cards details keys so we can enumerate them
/// Initial card price
uint public initialCardPrice = 1 ether;
/// Owner cut (1%) . This cut only apply on a user-to-user card transaction
uint public ownerBuyCut = 100;
/// fluffyCat cut (10%)
uint public fluffyCatCut = 1000;
/// contractOwner can withdraw the funds
address public contractOwner;
/// fluffyCat address
address public fluffyCatAddress = 0x2c00A5013aA2E600663f7b197C98db73bA847e6d;
/// Contract constructor
function GameCards() public {
contractOwner = msg.sender;
}
modifier onlyContractOwner() {
// Throws if called by any account other than the contract owner
require(msg.sender == contractOwner);
_;
}
modifier onlyCardOwner(uint8 cardId) {
// Throws if called by any account other than the card owner
require(msg.sender == cardStructs[cardId].owner);
_;
}
modifier onlyValidCard(uint8 cardId) {
// Throws if card is not valid
require(cardId >= 1 && cardId <= 100);
_;
}
/// Return cardList array
function getCards() public view returns(uint8[]) {
uint8[] memory result = new uint8[](cardList.length);
uint8 counter = 0;
for (uint8 i = 0; i < cardList.length; i++) {
result[counter] = i;
counter++;
}
return result;
}
/// Return cardDetailsList array
function getCardsDetails() public view returns(uint8[]) {
uint8[] memory result = new uint8[](cardDetailsList.length);
uint8 counter = 0;
for (uint8 i = 0; i < cardDetailsList.length; i++) {
result[counter] = i;
counter++;
}
return result;
}
/// Return card details by id
function getCardDetails(uint8 cardId) public view onlyValidCard(cardId)
returns (uint8 id, uint price, uint priceLease, uint leaseDuration, bool availableBuy, bool availableLease) {
bool _buyAvailability;
if (cardDetailsStructs[cardId].id == 0 || cardDetailsStructs[cardId].availableBuy) {
_buyAvailability = true;
}
CardDetails storage detail = cardDetailsStructs[cardId];
return (detail.id,
detail.price,
detail.priceLease,
detail.leaseDuration,
_buyAvailability,
detail.availableLease);
}
/// Return card by id
function getCard(uint8 cardId) public view onlyValidCard(cardId)
returns (uint8 id, address owner, string title, string url, string image, bool nsfw) {
Card storage card = cardStructs[cardId];
id = card.id;
owner = card.owner;
title = card.title;
url = card.url;
image = card.image;
nsfw = card.nsfw;
}
/// This is called on the initial buy card, user to user buy is at buyCard()
/// Amount is sent to contractOwner balance and fluffycat get 10% of this amount
function initialBuyCard(uint8 cardId, string title, string url, string image) public
onlyValidCard(cardId)
payable
returns (bool success)
{
// Check sent amount
uint price = computeInitialPrice(cardId);
require(msg.value >= price);
// If owner is 0x0, then we are sure that
// this is the initial buy
require(cardStructs[cardId].owner == address(0));
// Fill card
_fillCardStruct(cardId, msg.sender, title, url, image);
// Set nsfw flag to false
cardStructs[cardId].nsfw = false;
// Contract credit 10% of price to FluffyCat
_applyShare(contractOwner, fluffyCatAddress, fluffyCatCut);
// Initialize card details
_initCardDetails(cardId, price);
// Add the card to cardList
cardList.push(cardId);
return true;
}
/// Perform a user to user buy transaction
/// Contract owner takes 1% cut on each of this transaction
function buyCard(uint8 cardId, string title, string url, string image) public
onlyValidCard(cardId)
payable
returns (bool success)
{
// Check that this is not an initial buy, i.e. that the
// card belongs to someone
require(cardStructs[cardId].owner != address(0));
// Check if card is on sale
require(cardDetailsStructs[cardId].availableBuy);
// Check sent amount
uint price = cardDetailsStructs[cardId].price;
require(msg.value >= price);
address previousOwner = cardStructs[cardId].owner;
// Take 1% cut on buy
_applyShare(previousOwner, contractOwner, ownerBuyCut);
// Fill card
_fillCardStruct(cardId, msg.sender, title, url, image);
// Set nsfw flag to false
cardStructs[cardId].nsfw = false;
// Disable sell status
cardDetailsStructs[cardId].availableBuy = false;
return true;
}
/// Allow card owner to edit his card informations
function editCard(uint8 cardId, string title, string url, string image) public
onlyValidCard(cardId)
onlyCardOwner(cardId)
returns (bool success)
{
// Fill card
_fillCardStruct(cardId, msg.sender, title, url, image);
// Disable sell status
return true;
}
/// Allow card owner to set his card on sale at specific price
function sellCard(uint8 cardId, uint price) public
onlyValidCard(cardId)
onlyCardOwner(cardId)
returns (bool success)
{
cardDetailsStructs[cardId].price = price;
cardDetailsStructs[cardId].availableBuy = true;
return true;
}
/// Allow card owner to cancel sell offer
function cancelSellCard(uint8 cardId) public
onlyValidCard(cardId)
onlyCardOwner(cardId)
returns (bool success)
{
cardDetailsStructs[cardId].availableBuy = false;
return true;
}
/// Allow card owner to set his card on lease at fixed price per block and duration
function setLeaseCard(uint8 cardId, uint priceLease, uint leaseDuration) public
onlyValidCard(cardId)
onlyCardOwner(cardId)
returns (bool success)
{
// Card cannot be on sale when setting lease
// cancelSellCard() first
require(!cardDetailsStructs[cardId].availableBuy);
// Card cannot be set on lease while currently leasing
uint _lastLeaseId = getCardLeaseLength(cardId);
uint _until = cardDetailsStructs[cardId].leaseCardStructs[_lastLeaseId].untilBlock;
require(_until < block.number);
cardDetailsStructs[cardId].priceLease = priceLease;
cardDetailsStructs[cardId].availableLease = true;
cardDetailsStructs[cardId].leaseDuration = leaseDuration;
return true;
}
/// Allow card owner to cancel lease offer
/// Note that this do not interrupt current lease if any
function cancelLeaseOffer(uint8 cardId) public
onlyValidCard(cardId)
onlyCardOwner(cardId)
returns (bool success)
{
cardDetailsStructs[cardId].availableLease = false;
return true;
}
/// Allow future tenant to lease a card
function leaseCard(uint8 cardId, string title, string url, string image) public
onlyValidCard(cardId)
payable
returns (bool success)
{
CardDetails storage details = cardDetailsStructs[cardId];
// Check that card is avaible to lease
require(details.availableLease);
// Get price (per block) and leaseDuration (block)
uint price = details.priceLease;
uint leaseDuration = details.leaseDuration;
uint totalAmount = price * leaseDuration;
// Check that amount sent is sufficient
require(msg.value >= totalAmount);
// Get new lease id
uint leaseId = getCardLeaseLength(cardId) + 1;
// Get the block number of lease end
uint untilBlock = block.number + leaseDuration;
// Take 1% cut on lease
Card storage card = cardStructs[cardId];
address _cardOwner = card.owner;
_applyShare(_cardOwner, contractOwner, ownerBuyCut);
// Fill leaseCardStructs
details.leaseCardStructs[leaseId].id = leaseId;
details.leaseCardStructs[leaseId].tenant = msg.sender;
details.leaseCardStructs[leaseId].price = totalAmount;
details.leaseCardStructs[leaseId].untilBlock = untilBlock;
details.leaseCardStructs[leaseId].title = title;
details.leaseCardStructs[leaseId].url = url;
details.leaseCardStructs[leaseId].image = image;
// Leases are now unavailable for this card
details.availableLease = false;
// Add lease to leases list of correspondant cardDetails
details.leaseList.push(leaseId);
return true;
}
/// Get last lease from a card
function getLastLease(uint8 cardId) public view
returns(uint leaseIndex, address tenant, uint untilBlock, string title, string url, string image)
{
uint _leaseIndex = getCardLeaseLength(cardId);
return getLease(cardId, _leaseIndex);
}
/// Get lease from card
function getLease(uint8 cardId, uint leaseId) public view
returns(uint leaseIndex, address tenant, uint untilBlock, string title, string url, string image)
{
return(cardDetailsStructs[cardId].leaseCardStructs[leaseId].id,
cardDetailsStructs[cardId].leaseCardStructs[leaseId].tenant,
cardDetailsStructs[cardId].leaseCardStructs[leaseId].untilBlock,
cardDetailsStructs[cardId].leaseCardStructs[leaseId].title,
cardDetailsStructs[cardId].leaseCardStructs[leaseId].url,
cardDetailsStructs[cardId].leaseCardStructs[leaseId].image);
}
/// Get lease list from a card
function getCardLeaseLength(uint8 cardId) public view
returns(uint cardLeasesCount)
{
return(cardDetailsStructs[cardId].leaseList.length);
}
/// Transfer the ownership of a card
function transferCardOwnership(address to, uint8 cardId)
public
onlyCardOwner(cardId)
returns (bool success)
{
// Transfer card ownership
cardStructs[cardId].owner = to;
return true;
}
/// Return balance from sender
function getBalance()
public
view
returns (uint amount)
{
return pendingWithdrawals[msg.sender];
}
/// Allow address to withdraw their balance
function withdraw()
public
returns (bool)
{
uint amount = pendingWithdrawals[msg.sender];
// Remember to zero the pending refund before
// sending to prevent re-entrancy attacks
pendingWithdrawals[msg.sender] = 0;
msg.sender.transfer(amount);
return true;
}
/// Compute initial card price (in wei)
function computeInitialPrice(uint8 cardId) public view
onlyValidCard(cardId)
returns (uint price)
{
// 1 ether - 0.01 ether * (cardId - 1)
return initialCardPrice - ((initialCardPrice / 100) * (uint256(cardId) - 1));
}
/// Allow contract owner to set NSFW flag on a card
function setNSFW(uint8 cardId, bool flag) public
onlyValidCard(cardId)
onlyContractOwner()
returns (bool success)
{
cardStructs[cardId].nsfw = flag;
return true;
}
/// Fill Card struct
function _fillCardStruct(uint8 _cardId, address _owner, string _title, string _url, string _image) internal
returns (bool success)
{
cardStructs[_cardId].owner = _owner;
cardStructs[_cardId].title = _title;
cardStructs[_cardId].url = _url;
cardStructs[_cardId].image = _image;
return true;
}
/// Initialize sell card for future
function _initCardDetails(uint8 cardId, uint price) internal
returns (bool success)
{
// priceLease, leaseDuration set to default value(= 0)
cardDetailsStructs[cardId].id = cardId;
cardDetailsStructs[cardId].price = price;
cardDetailsStructs[cardId].availableBuy = false;
cardDetailsStructs[cardId].availableLease = false;
cardDetailsList.push(cardId);
return true;
}
/// Send split amounts to respective balances
function _applyShare(address _seller, address _auctioneer, uint _cut) internal
returns (bool success)
{
// Compute share
uint256 auctioneerCut = _computeCut(msg.value, _cut);
uint256 sellerProceeds = msg.value - auctioneerCut;
// Credit seller balance
pendingWithdrawals[_seller] += sellerProceeds;
// Credit auctionner balance
pendingWithdrawals[_auctioneer] += auctioneerCut;
return true;
}
/// Compute _cut from a _price
function _computeCut(uint256 _price, uint256 _cut) internal pure
returns (uint256)
{
return _price * _cut / 10000;
}
}
| 192,113 | 1,020 |
10586d1333e165ab1040556fdac6dc694759e40bd30da928d5c14fbaca3809e6
| 10,808 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x79137ad8bfed047ab7a06e2e946143f2dda9d06d.sol
| 3,065 | 10,267 |
// Author : shift
pragma solidity ^0.4.18;
//--------- OpenZeppelin's Safe Math
//Source : https://github.com/OpenZeppelin/zeppelin-solidity/blob/master/contracts/math/SafeMath.sol
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
//-----------------------------------------------------
// ERC20 Interface: https://github.com/ethereum/EIPs/issues/20
contract ERC20 {
function transfer(address _to, uint256 _value) public returns (bool success);
function balanceOf(address _owner) public constant returns (uint256 balance);
}
contract Moongang {
using SafeMath for uint256;
modifier onlyOwner {
require(msg.sender == owner);
_;
}
modifier minAmountReached {
//In reality, the correct amount is the amount + 1%
require(this.balance >= SafeMath.div(SafeMath.mul(min_amount, 100), 99));
_;
}
modifier underMaxAmount {
require(max_amount == 0 || this.balance <= max_amount);
_;
}
//Constants of the contract
uint256 constant FEE = 40; //2.5% fee
//SafeMath.div(20, 3) = 6
uint256 constant FEE_DEV = 6; //15% on the 1% fee
uint256 constant FEE_AUDIT = 12; //7.5% on the 1% fee
address public owner;
address constant public developer = 0xEE06BdDafFA56a303718DE53A5bc347EfbE4C68f;
address constant public auditor = 0x63F7547Ac277ea0B52A0B060Be6af8C5904953aa;
uint256 public individual_cap;
//Variables subject to changes
uint256 public max_amount; //0 means there is no limit
uint256 public min_amount;
//Store the amount of ETH deposited by each account.
mapping (address => uint256) public balances;
mapping (address => uint256) public balances_bonus;
// Track whether the contract has bought the tokens yet.
bool public bought_tokens;
// Record ETH value of tokens currently held by contract.
uint256 public contract_eth_value;
uint256 public contract_eth_value_bonus;
//Set by the owner in order to allow the withdrawal of bonus tokens.
bool public bonus_received;
//The address of the contact.
address public sale;
//Token address
ERC20 public token;
//Records the fees that have to be sent
uint256 fees;
//Set by the owner. Allows people to refund totally or partially.
bool public allow_refunds;
//The reduction of the allocation in % | example : 40 -> 40% reduction
uint256 public percent_reduction;
bool public owner_supplied_eth;
bool public allow_contributions;
//Internal functions
function Moongang(uint256 max, uint256 min, uint256 cap) {
owner = msg.sender;
max_amount = SafeMath.div(SafeMath.mul(max, 100), 99);
min_amount = min;
individual_cap = cap;
allow_contributions = true;
}
//Functions for the owner
// Buy the tokens. Sends ETH to the presale wallet and records the ETH amount held in the contract.
function buy_the_tokens() onlyOwner minAmountReached underMaxAmount {
//Avoids burning the funds
require(!bought_tokens && sale != 0x0);
//Record that the contract has bought the tokens.
bought_tokens = true;
//Sends the fee before so the contract_eth_value contains the correct balance
uint256 dev_fee = SafeMath.div(fees, FEE_DEV);
uint256 audit_fee = SafeMath.div(fees, FEE_AUDIT);
owner.transfer(SafeMath.sub(SafeMath.sub(fees, dev_fee), audit_fee));
developer.transfer(dev_fee);
auditor.transfer(audit_fee);
//Record the amount of ETH sent as the contract's current value.
contract_eth_value = this.balance;
contract_eth_value_bonus = this.balance;
// Transfer all the funds to the crowdsale address.
sale.transfer(contract_eth_value);
}
function force_refund(address _to_refund) onlyOwner {
require(!bought_tokens);
uint256 eth_to_withdraw = SafeMath.div(SafeMath.mul(balances[_to_refund], 100), 99);
balances[_to_refund] = 0;
balances_bonus[_to_refund] = 0;
fees = SafeMath.sub(fees, SafeMath.div(eth_to_withdraw, FEE));
_to_refund.transfer(eth_to_withdraw);
}
function force_partial_refund(address _to_refund) onlyOwner {
require(bought_tokens && percent_reduction > 0);
//Amount to refund is the amount minus the X% of the reduction
//amount_to_refund = balance*X
uint256 amount = SafeMath.div(SafeMath.mul(balances[_to_refund], percent_reduction), 100);
balances[_to_refund] = SafeMath.sub(balances[_to_refund], amount);
balances_bonus[_to_refund] = balances[_to_refund];
if (owner_supplied_eth) {
//dev fees aren't refunded, only owner fees
uint256 fee = amount.div(FEE).mul(percent_reduction).div(100);
amount = amount.add(fee);
}
_to_refund.transfer(amount);
}
function set_sale_address(address _sale) onlyOwner {
//Avoid mistake of putting 0x0 and can't change twice the sale address
require(_sale != 0x0);
sale = _sale;
}
function set_token_address(address _token) onlyOwner {
require(_token != 0x0);
token = ERC20(_token);
}
function set_bonus_received(bool _boolean) onlyOwner {
bonus_received = _boolean;
}
function set_allow_refunds(bool _boolean) onlyOwner {
allow_refunds = _boolean;
}
function set_allow_contributions(bool _boolean) onlyOwner {
allow_contributions = _boolean;
}
function set_percent_reduction(uint256 _reduction) onlyOwner payable {
require(bought_tokens && _reduction <= 100);
percent_reduction = _reduction;
if (msg.value > 0) {
owner_supplied_eth = true;
}
//we substract by contract_eth_value*_reduction basically
contract_eth_value = contract_eth_value.sub((contract_eth_value.mul(_reduction)).div(100));
contract_eth_value_bonus = contract_eth_value;
}
function change_individual_cap(uint256 _cap) onlyOwner {
individual_cap = _cap;
}
function change_owner(address new_owner) onlyOwner {
require(new_owner != 0x0);
owner = new_owner;
}
function change_max_amount(uint256 _amount) onlyOwner {
//ATTENTION! The new amount should be in wei
//Use https://etherconverter.online/
max_amount = SafeMath.div(SafeMath.mul(_amount, 100), 99);
}
function change_min_amount(uint256 _amount) onlyOwner {
//ATTENTION! The new amount should be in wei
//Use https://etherconverter.online/
min_amount = _amount;
}
//Public functions
// Allows any user to withdraw his tokens.
function withdraw() {
// Disallow withdraw if tokens haven't been bought yet.
require(bought_tokens);
uint256 contract_token_balance = token.balanceOf(address(this));
// Disallow token withdrawals if there are no tokens to withdraw.
require(contract_token_balance != 0);
uint256 tokens_to_withdraw = SafeMath.div(SafeMath.mul(balances[msg.sender], contract_token_balance), contract_eth_value);
// Update the value of tokens currently held by the contract.
contract_eth_value = SafeMath.sub(contract_eth_value, balances[msg.sender]);
// Update the user's balance prior to sending to prevent recursive call.
balances[msg.sender] = 0;
// Send the funds. Throws on failure to prevent loss of funds.
require(token.transfer(msg.sender, tokens_to_withdraw));
}
function withdraw_bonus() {
require(bought_tokens && bonus_received);
uint256 contract_token_balance = token.balanceOf(address(this));
require(contract_token_balance != 0);
uint256 tokens_to_withdraw = SafeMath.div(SafeMath.mul(balances_bonus[msg.sender], contract_token_balance), contract_eth_value_bonus);
contract_eth_value_bonus = SafeMath.sub(contract_eth_value_bonus, balances_bonus[msg.sender]);
balances_bonus[msg.sender] = 0;
require(token.transfer(msg.sender, tokens_to_withdraw));
}
// Allows any user to get his eth refunded before the purchase is made.
function refund() {
require(!bought_tokens && allow_refunds && percent_reduction == 0);
//balance of contributor = contribution * 0.99
//so contribution = balance/0.99
uint256 eth_to_withdraw = SafeMath.div(SafeMath.mul(balances[msg.sender], 100), 99);
// Update the user's balance prior to sending ETH to prevent recursive call.
balances[msg.sender] = 0;
//Updates the balances_bonus too
balances_bonus[msg.sender] = 0;
//Updates the fees variable by substracting the refunded fee
fees = SafeMath.sub(fees, SafeMath.div(eth_to_withdraw, FEE));
// Return the user's funds. Throws on failure to prevent loss of funds.
msg.sender.transfer(eth_to_withdraw);
}
//Allows any user to get a part of his ETH refunded, in proportion
//to the % reduced of the allocation
function partial_refund() {
require(bought_tokens && percent_reduction > 0);
//Amount to refund is the amount minus the X% of the reduction
//amount_to_refund = balance*X
uint256 amount = SafeMath.div(SafeMath.mul(balances[msg.sender], percent_reduction), 100);
balances[msg.sender] = SafeMath.sub(balances[msg.sender], amount);
balances_bonus[msg.sender] = balances[msg.sender];
if (owner_supplied_eth) {
//dev fees aren't refunded, only owner fees
uint256 fee = amount.div(FEE).mul(percent_reduction).div(100);
amount = amount.add(fee);
}
msg.sender.transfer(amount);
}
// Default function. Called when a user sends ETH to the contract.
function () payable underMaxAmount {
require(!bought_tokens && allow_contributions);
//1% fee is taken on the ETH
uint256 fee = SafeMath.div(msg.value, FEE);
fees = SafeMath.add(fees, fee);
//Updates both of the balances
balances[msg.sender] = SafeMath.add(balances[msg.sender], SafeMath.sub(msg.value, fee));
//Checks if the individual cap is respected
//If it's not, changes are reverted
require(individual_cap == 0 || balances[msg.sender] <= individual_cap);
balances_bonus[msg.sender] = balances[msg.sender];
}
}
| 207,824 | 1,021 |
e7ca66af365440e5277605c0dcae9e166c825874e045df0a8524285ed1810f0d
| 17,481 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/09/09A36936B613Ae49b34f4e3963fa154f9d261e1F_Distributor.sol
| 3,977 | 15,704 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender)
.sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function add32(uint32 a, uint32 b) internal pure returns (uint32) {
uint32 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow(4)");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function sqrrt(uint256 a) internal pure returns (uint c) {
if (a > 3) {
c = a;
uint b = add(div(a, 2), 1);
while (b < c) {
c = b;
b = div(add(div(a, b), b), 2);
}
} else if (a != 0) {
c = 1;
}
}
function percentageAmount(uint256 total_, uint8 percentage_) internal pure returns (uint256 percentAmount_) {
return div(mul(total_, percentage_), 1000);
}
function substractPercentage(uint256 total_, uint8 percentageToSub_) internal pure returns (uint256 result_) {
return sub(total_, div(mul(total_, percentageToSub_), 1000));
}
function percentageOfTotal(uint256 part_, uint256 total_) internal pure returns (uint256 percent_) {
return div(mul(part_, 100) , total_);
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
function quadraticPricing(uint256 payment_, uint256 multiplier_) internal pure returns (uint256) {
return sqrrt(mul(multiplier_, payment_));
}
function bondingCurve(uint256 supply_, uint256 multiplier_) internal pure returns (uint256) {
return mul(multiplier_, supply_);
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
interface IPolicy {
function policy() external view returns (address);
function renouncePolicy() external;
function pushPolicy(address newPolicy_) external;
function pullPolicy() external;
}
contract Policy is IPolicy {
address internal _policy;
address internal _newPolicy;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
_policy = msg.sender;
emit OwnershipTransferred(address(0), _policy);
}
function policy() public view override returns (address) {
return _policy;
}
modifier onlyPolicy() {
require(_policy == msg.sender, "Ownable: caller is not the owner");
_;
}
function renouncePolicy() public virtual override onlyPolicy() {
emit OwnershipTransferred(_policy, address(0));
_policy = address(0);
}
function pushPolicy(address newPolicy_) public virtual override onlyPolicy() {
require(newPolicy_ != address(0), "Ownable: new owner is the zero address");
_newPolicy = newPolicy_;
}
function pullPolicy() public virtual override {
require(msg.sender == _newPolicy);
emit OwnershipTransferred(_policy, _newPolicy);
_policy = _newPolicy;
}
}
interface ITreasury {
function mintRewards(address _recipient, uint _amount) external;
}
contract Distributor is Policy {
using SafeMath for uint;
using SafeMath for uint32;
using SafeERC20 for IERC20;
address public immutable OHM;
address public immutable treasury;
uint32 public immutable epochLength;
uint32 public nextEpochTime;
mapping(uint => Adjust) public adjustments;
struct Info {
uint rate; // in ten-thousandths (5000 = 0.5%)
address recipient;
}
Info[] public info;
struct Adjust {
bool add;
uint rate;
uint target;
}
constructor(address _treasury, address _ohm, uint32 _epochLength, uint32 _nextEpochTime) {
require(_treasury != address(0));
treasury = _treasury;
require(_ohm != address(0));
OHM = _ohm;
epochLength = _epochLength;
nextEpochTime = _nextEpochTime;
}
function distribute() external returns (bool) {
if (nextEpochTime <= uint32(block.timestamp)) {
nextEpochTime = nextEpochTime.add32(epochLength); // set next epoch time
// distribute rewards to each recipient
for (uint i = 0; i < info.length; i++) {
if (info[ i ].rate > 0) {
ITreasury(treasury).mintRewards(// mint and send from treasury
info[ i ].recipient,
nextRewardAt(info[ i ].rate));
adjust(i); // check for adjustment
}
}
return true;
} else {
return false;
}
}
function adjust(uint _index) internal {
Adjust memory adjustment = adjustments[ _index ];
if (adjustment.rate != 0) {
if (adjustment.add) { // if rate should increase
info[ _index ].rate = info[ _index ].rate.add(adjustment.rate); // raise rate
if (info[ _index ].rate >= adjustment.target) { // if target met
adjustments[ _index ].rate = 0; // turn off adjustment
}
} else { // if rate should decrease
info[ _index ].rate = info[ _index ].rate.sub(adjustment.rate); // lower rate
if (info[ _index ].rate <= adjustment.target) { // if target met
adjustments[ _index ].rate = 0; // turn off adjustment
}
}
}
}
function nextRewardAt(uint _rate) public view returns (uint) {
return IERC20(OHM).totalSupply().mul(_rate).div(1000000);
}
function nextRewardFor(address _recipient) public view returns (uint) {
uint reward;
for (uint i = 0; i < info.length; i++) {
if (info[ i ].recipient == _recipient) {
reward = nextRewardAt(info[ i ].rate);
}
}
return reward;
}
function addRecipient(address _recipient, uint _rewardRate) external onlyPolicy() {
require(_recipient != address(0));
info.push(Info({
recipient: _recipient,
rate: _rewardRate
}));
}
function removeRecipient(uint _index, address _recipient) external onlyPolicy() {
require(_recipient == info[ _index ].recipient);
info[ _index ].recipient = address(0);
info[ _index ].rate = 0;
}
function setAdjustment(uint _index, bool _add, uint _rate, uint _target) external onlyPolicy() {
adjustments[ _index ] = Adjust({
add: _add,
rate: _rate,
target: _target
});
}
}
| 113,066 | 1,022 |
0996c900a74640bab046bbeaee701c1831f1266eece2e1429fd472b2761c818a
| 12,586 |
.sol
|
Solidity
| false |
359775451
|
vntchain-bak/GGNNSmartVulDetector
|
d0317099a169bf0033a1f4bc43d1b5911e6ecb38
|
data/loops/solidity_contract/10093.sol
| 3,128 | 12,214 |
pragma solidity 0.4.15;
contract RegistryICAPInterface {
function parse(bytes32 _icap) constant returns(address, bytes32, bool);
function institutions(bytes32 _institution) constant returns(address);
}
contract EToken2Interface {
function registryICAP() constant returns(RegistryICAPInterface);
function baseUnit(bytes32 _symbol) constant returns(uint8);
function description(bytes32 _symbol) constant returns(string);
function owner(bytes32 _symbol) constant returns(address);
function isOwner(address _owner, bytes32 _symbol) constant returns(bool);
function totalSupply(bytes32 _symbol) constant returns(uint);
function balanceOf(address _holder, bytes32 _symbol) constant returns(uint);
function isLocked(bytes32 _symbol) constant returns(bool);
function issueAsset(bytes32 _symbol, uint _value, string _name, string _description, uint8 _baseUnit, bool _isReissuable) returns(bool);
function reissueAsset(bytes32 _symbol, uint _value) returns(bool);
function revokeAsset(bytes32 _symbol, uint _value) returns(bool);
function setProxy(address _address, bytes32 _symbol) returns(bool);
function lockAsset(bytes32 _symbol) returns(bool);
function proxyTransferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference, address _sender) returns(bool);
function proxyApprove(address _spender, uint _value, bytes32 _symbol, address _sender) returns(bool);
function allowance(address _from, address _spender, bytes32 _symbol) constant returns(uint);
function proxyTransferFromWithReference(address _from, address _to, uint _value, bytes32 _symbol, string _reference, address _sender) returns(bool);
}
contract AssetInterface {
function _performTransferWithReference(address _to, uint _value, string _reference, address _sender) returns(bool);
function _performTransferToICAPWithReference(bytes32 _icap, uint _value, string _reference, address _sender) returns(bool);
function _performApprove(address _spender, uint _value, address _sender) returns(bool);
function _performTransferFromWithReference(address _from, address _to, uint _value, string _reference, address _sender) returns(bool);
function _performTransferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference, address _sender) returns(bool);
function _performGeneric(bytes, address) payable {
revert();
}
}
contract ERC20Interface {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed from, address indexed spender, uint256 value);
function totalSupply() constant returns(uint256 supply);
function balanceOf(address _owner) constant returns(uint256 balance);
function transfer(address _to, uint256 _value) returns(bool success);
function transferFrom(address _from, address _to, uint256 _value) returns(bool success);
function approve(address _spender, uint256 _value) returns(bool success);
function allowance(address _owner, address _spender) constant returns(uint256 remaining);
function decimals() constant returns(uint8);
}
contract AssetProxyInterface {
function _forwardApprove(address _spender, uint _value, address _sender) returns(bool);
function _forwardTransferFromWithReference(address _from, address _to, uint _value, string _reference, address _sender) returns(bool);
function _forwardTransferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference, address _sender) returns(bool);
function balanceOf(address _owner) constant returns(uint);
}
contract Bytes32 {
function _bytes32(string _input) internal constant returns(bytes32 result) {
assembly {
result := mload(add(_input, 32))
}
}
}
contract ReturnData {
function _returnReturnData(bool _success) internal {
assembly {
let returndatastart := msize()
mstore(0x40, add(returndatastart, returndatasize))
returndatacopy(returndatastart, 0, returndatasize)
switch _success case 0 { revert(returndatastart, returndatasize) } default { return(returndatastart, returndatasize) }
}
}
function _assemblyCall(address _destination, uint _value, bytes _data) internal returns(bool success) {
assembly {
success := call(div(mul(gas, 63), 64), _destination, _value, add(_data, 32), mload(_data), 0, 0)
}
}
}
contract Terra is ERC20Interface, AssetProxyInterface, Bytes32, ReturnData {
EToken2Interface public etoken2;
bytes32 public etoken2Symbol;
string public name;
string public symbol;
function init(EToken2Interface _etoken2, string _symbol, string _name) returns(bool) {
if (address(etoken2) != 0x0) {
return false;
}
etoken2 = _etoken2;
etoken2Symbol = _bytes32(_symbol);
name = _name;
symbol = _symbol;
return true;
}
modifier onlyEToken2() {
if (msg.sender == address(etoken2)) {
_;
}
}
modifier onlyAssetOwner() {
if (etoken2.isOwner(msg.sender, etoken2Symbol)) {
_;
}
}
function _getAsset() internal returns(AssetInterface) {
return AssetInterface(getVersionFor(msg.sender));
}
function recoverTokens(uint _value) onlyAssetOwner() returns(bool) {
return this.transferWithReference(msg.sender, _value, 'Tokens recovery');
}
function totalSupply() constant returns(uint) {
return etoken2.totalSupply(etoken2Symbol);
}
function balanceOf(address _owner) constant returns(uint) {
return etoken2.balanceOf(_owner, etoken2Symbol);
}
function allowance(address _from, address _spender) constant returns(uint) {
return etoken2.allowance(_from, _spender, etoken2Symbol);
}
function decimals() constant returns(uint8) {
return etoken2.baseUnit(etoken2Symbol);
}
function transfer(address _to, uint _value) returns(bool) {
return transferWithReference(_to, _value, '');
}
function transferWithReference(address _to, uint _value, string _reference) returns(bool) {
return _getAsset()._performTransferWithReference(_to, _value, _reference, msg.sender);
}
function transferToICAP(bytes32 _icap, uint _value) returns(bool) {
return transferToICAPWithReference(_icap, _value, '');
}
function transferToICAPWithReference(bytes32 _icap, uint _value, string _reference) returns(bool) {
return _getAsset()._performTransferToICAPWithReference(_icap, _value, _reference, msg.sender);
}
function transferFrom(address _from, address _to, uint _value) returns(bool) {
return transferFromWithReference(_from, _to, _value, '');
}
function transferFromWithReference(address _from, address _to, uint _value, string _reference) returns(bool) {
return _getAsset()._performTransferFromWithReference(_from, _to, _value, _reference, msg.sender);
}
function _forwardTransferFromWithReference(address _from, address _to, uint _value, string _reference, address _sender) onlyImplementationFor(_sender) returns(bool) {
return etoken2.proxyTransferFromWithReference(_from, _to, _value, etoken2Symbol, _reference, _sender);
}
function transferFromToICAP(address _from, bytes32 _icap, uint _value) returns(bool) {
return transferFromToICAPWithReference(_from, _icap, _value, '');
}
function transferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference) returns(bool) {
return _getAsset()._performTransferFromToICAPWithReference(_from, _icap, _value, _reference, msg.sender);
}
function _forwardTransferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference, address _sender) onlyImplementationFor(_sender) returns(bool) {
return etoken2.proxyTransferFromToICAPWithReference(_from, _icap, _value, _reference, _sender);
}
function approve(address _spender, uint _value) returns(bool) {
return _getAsset()._performApprove(_spender, _value, msg.sender);
}
function _forwardApprove(address _spender, uint _value, address _sender) onlyImplementationFor(_sender) returns(bool) {
return etoken2.proxyApprove(_spender, _value, etoken2Symbol, _sender);
}
function emitTransfer(address _from, address _to, uint _value) onlyEToken2() {
Transfer(_from, _to, _value);
}
function emitApprove(address _from, address _spender, uint _value) onlyEToken2() {
Approval(_from, _spender, _value);
}
function () payable {
_getAsset()._performGeneric.value(msg.value)(msg.data, msg.sender);
_returnReturnData(true);
}
function transferToICAP(string _icap, uint _value) returns(bool) {
return transferToICAPWithReference(_icap, _value, '');
}
function transferToICAPWithReference(string _icap, uint _value, string _reference) returns(bool) {
return transferToICAPWithReference(_bytes32(_icap), _value, _reference);
}
function transferFromToICAP(address _from, string _icap, uint _value) returns(bool) {
return transferFromToICAPWithReference(_from, _icap, _value, '');
}
function transferFromToICAPWithReference(address _from, string _icap, uint _value, string _reference) returns(bool) {
return transferFromToICAPWithReference(_from, _bytes32(_icap), _value, _reference);
}
event UpgradeProposed(address newVersion);
event UpgradePurged(address newVersion);
event UpgradeCommited(address newVersion);
event OptedOut(address sender, address version);
event OptedIn(address sender, address version);
address latestVersion;
address pendingVersion;
uint pendingVersionTimestamp;
uint constant UPGRADE_FREEZE_TIME = 3 days;
mapping(address => address) userOptOutVersion;
modifier onlyImplementationFor(address _sender) {
if (getVersionFor(_sender) == msg.sender) {
_;
}
}
function getVersionFor(address _sender) constant returns(address) {
return userOptOutVersion[_sender] == 0 ? latestVersion : userOptOutVersion[_sender];
}
function getLatestVersion() constant returns(address) {
return latestVersion;
}
function getPendingVersion() constant returns(address) {
return pendingVersion;
}
function getPendingVersionTimestamp() constant returns(uint) {
return pendingVersionTimestamp;
}
function proposeUpgrade(address _newVersion) onlyAssetOwner() returns(bool) {
if (pendingVersion != 0x0) {
return false;
}
if (_newVersion == 0x0) {
return false;
}
if (latestVersion == 0x0) {
latestVersion = _newVersion;
return true;
}
pendingVersion = _newVersion;
pendingVersionTimestamp = now;
UpgradeProposed(_newVersion);
return true;
}
function purgeUpgrade() onlyAssetOwner() returns(bool) {
if (pendingVersion == 0x0) {
return false;
}
UpgradePurged(pendingVersion);
delete pendingVersion;
delete pendingVersionTimestamp;
return true;
}
function commitUpgrade() returns(bool) {
if (pendingVersion == 0x0) {
return false;
}
if (pendingVersionTimestamp + UPGRADE_FREEZE_TIME > now) {
return false;
}
latestVersion = pendingVersion;
delete pendingVersion;
delete pendingVersionTimestamp;
UpgradeCommited(latestVersion);
return true;
}
function optOut() returns(bool) {
if (userOptOutVersion[msg.sender] != 0x0) {
return false;
}
userOptOutVersion[msg.sender] = latestVersion;
OptedOut(msg.sender, latestVersion);
return true;
}
function optIn() returns(bool) {
delete userOptOutVersion[msg.sender];
OptedIn(msg.sender, latestVersion);
return true;
}
function multiAsset() constant returns(EToken2Interface) {
return etoken2;
}
}
| 65,928 | 1,023 |
a708bdee597eb9a3c8104b246938a644e84e11a47e6e3caaddb2b58136b0d9b2
| 21,023 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x80248bb8bd26f449dea5b4d01faf936075b7111d.sol
| 3,020 | 11,876 |
pragma solidity ^0.4.23;
interface tokenRecipient {
function receiveApproval (address from, uint256 value, address token, bytes extraData) external;
}
contract Pasadena {
string public name;
string public symbol;
uint8 public decimals = 6; // Makes JavaScript able to handle precise calculations (until totalSupply < 9 milliards)
uint256 public totalSupply;
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
mapping(address => mapping(uint => bool)) public usedSigIds; // Used in *ViaSignature(..)
address public tokenDistributor; // Account authorized to distribute tokens only during the token distribution event
address public rescueAccount; // Account authorized to withdraw tokens accidentally sent to this contract
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
bytes public ethSignedMessagePrefix = "\x19Ethereum Signed Message:\n";
enum sigStandard { typed, personal, stringHex }
enum sigDestination { transfer, approve, approveAndCall, transferFrom }
bytes32 public sigDestinationTransfer = keccak256("address Token Contract Address",
"address Sender's Address",
"address Recipient's Address",
"uint256 Amount to Transfer (last six digits are decimals)",
"uint256 Fee in Tokens Paid to Executor (last six digits are decimals)",
"uint256 Signature Expiration Timestamp (unix timestamp)",
"uint256 Signature ID"); // `transferViaSignature`: keccak256(address(this), from, to, value, fee, deadline, sigId)
bytes32 public sigDestinationTransferFrom = keccak256("address Token Contract Address",
"address Address Approved for Withdraw",
"address Account to Withdraw From",
"address Withdrawal Recipient Address",
"uint256 Amount to Transfer (last six digits are decimals)",
"uint256 Fee in Tokens Paid to Executor (last six digits are decimals)",
"uint256 Signature Expiration Timestamp (unix timestamp)",
"uint256 Signature ID");
bytes32 public sigDestinationApprove = keccak256("address Token Contract Address",
"address Withdrawal Approval Address",
"address Withdrawal Recipient Address",
"uint256 Amount to Transfer (last six digits are decimals)",
"uint256 Fee in Tokens Paid to Executor (last six digits are decimals)",
"uint256 Signature Expiration Timestamp (unix timestamp)",
"uint256 Signature ID"); // `approveViaSignature`: keccak256(address(this), from, spender, value, fee, deadline, sigId)
bytes32 public sigDestinationApproveAndCall = keccak256(// `approveAndCallViaSignature`
"address Token Contract Address",
"address Withdrawal Approval Address",
"address Withdrawal Recipient Address",
"uint256 Amount to Transfer (last six digits are decimals)",
"bytes Data to Transfer",
"uint256 Fee in Tokens Paid to Executor (last six digits are decimals)",
"uint256 Signature Expiration Timestamp (unix timestamp)",
"uint256 Signature ID");
constructor (string tokenName, string tokenSymbol) public {
name = tokenName;
symbol = tokenSymbol;
rescueAccount = tokenDistributor = msg.sender;
}
function internalTransfer (address from, address to, uint value) internal {
// Prevent people from accidentally burning their tokens + uint256 wrap prevention
require(to != 0x0 && balanceOf[from] >= value && balanceOf[to] + value >= balanceOf[to]);
balanceOf[from] -= value;
balanceOf[to] += value;
emit Transfer(from, to, value);
}
function internalDoubleTransfer (address from, address to1, uint value1, address to2, uint value2) internal {
require(// Prevent people from accidentally burning their tokens + uint256 wrap prevention
to1 != 0x0 && to2 != 0x0 && value1 + value2 >= value1 && balanceOf[from] >= value1 + value2
&& balanceOf[to1] + value1 >= balanceOf[to1] && balanceOf[to2] + value2 >= balanceOf[to2]);
balanceOf[from] -= value1 + value2;
balanceOf[to1] += value1;
emit Transfer(from, to1, value1);
if (value2 > 0) {
balanceOf[to2] += value2;
emit Transfer(from, to2, value2);
}
}
function requireSignature (bytes32 data, address signer, uint256 deadline, uint256 sigId, bytes sig, sigStandard std, sigDestination signDest) internal {
bytes32 r;
bytes32 s;
uint8 v;
assembly { // solium-disable-line security/no-inline-assembly
r := mload(add(sig, 32))
s := mload(add(sig, 64))
v := byte(0, mload(add(sig, 96)))
}
if (v < 27)
v += 27;
require(block.timestamp <= deadline && !usedSigIds[signer][sigId]); // solium-disable-line security/no-block-members
if (std == sigStandard.typed) { // Typed signature. This is the most likely scenario to be used and accepted
require(signer == ecrecover(keccak256(signDest == sigDestination.transfer
? sigDestinationTransfer
: signDest == sigDestination.approve
? sigDestinationApprove
: signDest == sigDestination.approveAndCall
? sigDestinationApproveAndCall
: sigDestinationTransferFrom,
data),
v, r, s));
} else if (std == sigStandard.personal) { // Ethereum signed message signature (Geth and Trezor)
require(signer == ecrecover(keccak256(ethSignedMessagePrefix, "32", data), v, r, s) // Geth-adopted
||
signer == ecrecover(keccak256(ethSignedMessagePrefix, "\x20", data), v, r, s) // Trezor-adopted);
} else { // == 2; Signed string hash signature (the most expensive but universal)
require(signer == ecrecover(keccak256(ethSignedMessagePrefix, "64", hexToString(data)), v, r, s) // Geth
||
signer == ecrecover(keccak256(ethSignedMessagePrefix, "\x40", hexToString(data)), v, r, s) // Trezor);
}
usedSigIds[signer][sigId] = true;
}
function hexToString (bytes32 sig) internal pure returns (bytes) { // /to-try/ convert to two uint256 and test gas
bytes memory str = new bytes(64);
for (uint8 i = 0; i < 32; ++i) {
str[2 * i] = byte((uint8(sig[i]) / 16 < 10 ? 48 : 87) + uint8(sig[i]) / 16);
str[2 * i + 1] = byte((uint8(sig[i]) % 16 < 10 ? 48 : 87) + (uint8(sig[i]) % 16));
}
return str;
}
function transfer (address to, uint256 value) public returns (bool) {
internalTransfer(msg.sender, to, value);
return true;
}
function transferViaSignature (address from,
address to,
uint256 value,
uint256 fee,
uint256 deadline,
uint256 sigId,
bytes sig,
sigStandard sigStd) external returns (bool) {
requireSignature(keccak256(address(this), from, to, value, fee, deadline, sigId),
from, deadline, sigId, sig, sigStd, sigDestination.transfer);
internalDoubleTransfer(from, to, value, msg.sender, fee);
return true;
}
function approve (address spender, uint256 value) public returns (bool) {
allowance[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
function approveViaSignature (address from,
address spender,
uint256 value,
uint256 fee,
uint256 deadline,
uint256 sigId,
bytes sig,
sigStandard sigStd) external returns (bool) {
requireSignature(keccak256(address(this), from, spender, value, fee, deadline, sigId),
from, deadline, sigId, sig, sigStd, sigDestination.approve);
allowance[from][spender] = value;
emit Approval(from, spender, value);
internalTransfer(from, msg.sender, fee);
return true;
}
function transferFrom (address from, address to, uint256 value) public returns (bool) {
require(value <= allowance[from][msg.sender]); // Test whether allowance was set
allowance[from][msg.sender] -= value;
internalTransfer(from, to, value);
return true;
}
function transferFromViaSignature (address signer,
address from,
address to,
uint256 value,
uint256 fee,
uint256 deadline,
uint256 sigId,
bytes sig,
sigStandard sigStd) external returns (bool) {
requireSignature(keccak256(address(this), signer, from, to, value, fee, deadline, sigId),
signer, deadline, sigId, sig, sigStd, sigDestination.transferFrom);
require(value <= allowance[from][signer] && value >= fee);
allowance[from][signer] -= value;
internalDoubleTransfer(from, to, value - fee, msg.sender, fee);
return true;
}
function approveAndCall (address spender, uint256 value, bytes extraData) public returns (bool) {
approve(spender, value);
tokenRecipient(spender).receiveApproval(msg.sender, value, this, extraData);
return true;
}
function approveAndCallViaSignature (address from,
address spender,
uint256 value,
bytes extraData,
uint256 fee,
uint256 deadline,
uint256 sigId,
bytes sig,
sigStandard sigStd) external returns (bool) {
requireSignature(keccak256(address(this), from, spender, value, extraData, fee, deadline, sigId),
from, deadline, sigId, sig, sigStd, sigDestination.approveAndCall);
allowance[from][spender] = value;
emit Approval(from, spender, value);
tokenRecipient(spender).receiveApproval(from, value, this, extraData);
internalTransfer(from, msg.sender, fee);
return true;
}
function multiMint (address[] recipients, uint256[] amounts) external {
// Once the token distribution ends, tokenDistributor will become 0x0 and multiMint will never work
require(tokenDistributor != 0x0 && tokenDistributor == msg.sender && recipients.length == amounts.length);
uint total = 0;
for (uint i = 0; i < recipients.length; ++i) {
balanceOf[recipients[i]] += amounts[i];
total += amounts[i];
emit Transfer(0x0, recipients[i], amounts[i]);
}
totalSupply += total;
}
function lastMint () external {
require(tokenDistributor != 0x0 && tokenDistributor == msg.sender && totalSupply > 0);
uint256 remaining = totalSupply * 40 / 60; // Portion of tokens for DreamTeam (40%)
uint256 fractionalPart = (remaining + totalSupply) % (uint256(10) ** decimals);
if (fractionalPart <= remaining)
remaining -= fractionalPart; // Remove the fractional part to round the totalSupply
balanceOf[tokenDistributor] += remaining;
emit Transfer(0x0, tokenDistributor, remaining);
totalSupply += remaining;
tokenDistributor = 0x0; // Disable multiMint and lastMint functions forever
}
function rescueTokens (Pasadena tokenContract, uint256 value) public {
require(msg.sender == rescueAccount);
tokenContract.approve(rescueAccount, value);
}
function changeRescueAccount (address newRescueAccount) public {
require(msg.sender == rescueAccount);
rescueAccount = newRescueAccount;
}
}
| 199,650 | 1,024 |
373cac70e6525881cc6e5f17470df872d96797c2a620ab7834951d8ea3bb70c2
| 14,672 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/FarmUniswap-0xc066f695c28591ad0c9d853c6ad199aebec49790.sol
| 3,725 | 13,040 |
// SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <0.7.0;
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0), "SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
library TransferHelper {
function safeApprove(address token, address to, uint value) internal {
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x095ea7b3, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: APPROVE_FAILED');
}
function safeTransfer(address token, address to, uint value) internal {
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(0xa9059cbb, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: TRANSFER_FAILED');
}
function safeTransferFrom(address token, address from, address to, uint value) internal {
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x23b872dd, from, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: TRANSFER_FROM_FAILED');
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IFarmFactory {
function userEnteredFarm(address _user) external;
function userLeftFarm(address _user) external;
function registerFarm(address _farmAddress) external;
}
contract FarmUniswap {
using SafeMath for uint256;
using SafeERC20 for IERC20;
/// @notice information stuct on each user than stakes LP tokens.
struct UserInfo {
uint256 amount; // How many LP tokens the user has provided.
uint256 rewardDebt; // Reward debt.
}
/// @notice all the settings for this farm in one struct
struct FarmInfo {
IERC20 lpToken;
IERC20 rewardToken;
uint256 startBlock;
uint256 blockReward;
uint256 bonusEndBlock;
uint256 bonus;
uint256 endBlock;
uint256 lastRewardBlock; // Last block number that reward distribution occurs.
uint256 accRewardPerShare; // Accumulated Rewards per share, times 1e12
uint256 farmableSupply; // set in init, total amount of tokens farmable
uint256 numFarmers;
}
uint256 public farmType = 1;
IFarmFactory public factory;
address public farmGenerator;
FarmInfo public farmInfo;
/// @notice information on each user than stakes LP tokens
mapping (address => UserInfo) public userInfo;
event Deposit(address indexed user, uint256 amount);
event Withdraw(address indexed user, uint256 amount);
event EmergencyWithdraw(address indexed user, uint256 amount);
constructor(address _factory, address _farmGenerator) public {
factory = IFarmFactory(_factory);
farmGenerator = _farmGenerator;
}
function init(IERC20 _rewardToken, uint256 _amount, IERC20 _lpToken, uint256 _blockReward, uint256 _startBlock, uint256 _endBlock, uint256 _bonusEndBlock, uint256 _bonus) public {
address msgSender = _msgSender();
require(msgSender == address(farmGenerator), 'FORBIDDEN');
TransferHelper.safeTransferFrom(address(_rewardToken), msgSender, address(this), _amount);
farmInfo.rewardToken = _rewardToken;
farmInfo.startBlock = _startBlock;
farmInfo.blockReward = _blockReward;
farmInfo.bonusEndBlock = _bonusEndBlock;
farmInfo.bonus = _bonus;
uint256 lastRewardBlock = block.number > _startBlock ? block.number : _startBlock;
farmInfo.lpToken = _lpToken;
farmInfo.lastRewardBlock = lastRewardBlock;
farmInfo.accRewardPerShare = 0;
farmInfo.endBlock = _endBlock;
farmInfo.farmableSupply = _amount;
}
function getMultiplier(uint256 _from_block, uint256 _to) public view returns (uint256) {
uint256 _from = _from_block >= farmInfo.startBlock ? _from_block : farmInfo.startBlock;
uint256 to = farmInfo.endBlock > _to ? _to : farmInfo.endBlock;
if (to <= farmInfo.bonusEndBlock) {
return to.sub(_from).mul(farmInfo.bonus);
} else if (_from >= farmInfo.bonusEndBlock) {
return to.sub(_from);
} else {
return farmInfo.bonusEndBlock.sub(_from).mul(farmInfo.bonus).add(to.sub(farmInfo.bonusEndBlock));
}
}
function pendingReward(address _user) external view returns (uint256) {
UserInfo storage user = userInfo[_user];
uint256 accRewardPerShare = farmInfo.accRewardPerShare;
uint256 lpSupply = farmInfo.lpToken.balanceOf(address(this));
if (block.number > farmInfo.lastRewardBlock && lpSupply != 0) {
uint256 multiplier = getMultiplier(farmInfo.lastRewardBlock, block.number);
uint256 tokenReward = multiplier.mul(farmInfo.blockReward);
accRewardPerShare = accRewardPerShare.add(tokenReward.mul(1e12).div(lpSupply));
}
return user.amount.mul(accRewardPerShare).div(1e12).sub(user.rewardDebt);
}
function updatePool() public {
if (block.number <= farmInfo.lastRewardBlock) {
return;
}
uint256 lpSupply = farmInfo.lpToken.balanceOf(address(this));
if (lpSupply == 0) {
farmInfo.lastRewardBlock = block.number < farmInfo.endBlock ? block.number : farmInfo.endBlock;
return;
}
uint256 multiplier = getMultiplier(farmInfo.lastRewardBlock, block.number);
uint256 tokenReward = multiplier.mul(farmInfo.blockReward);
farmInfo.accRewardPerShare = farmInfo.accRewardPerShare.add(tokenReward.mul(1e12).div(lpSupply));
farmInfo.lastRewardBlock = block.number < farmInfo.endBlock ? block.number : farmInfo.endBlock;
}
function deposit(uint256 _amount) public {
address msgSender = _msgSender();
UserInfo storage user = userInfo[msgSender];
updatePool();
if (user.amount > 0) {
uint256 pending = user.amount.mul(farmInfo.accRewardPerShare).div(1e12).sub(user.rewardDebt);
safeRewardTransfer(msgSender, pending);
}
if (user.amount == 0 && _amount > 0) {
factory.userEnteredFarm(msgSender);
farmInfo.numFarmers = farmInfo.numFarmers.add(1);
}
farmInfo.lpToken.safeTransferFrom(address(msgSender), address(this), _amount);
user.amount = user.amount.add(_amount);
user.rewardDebt = user.amount.mul(farmInfo.accRewardPerShare).div(1e12);
emit Deposit(msgSender, _amount);
}
function withdraw(uint256 _amount) public {
address msgSender = _msgSender();
UserInfo storage user = userInfo[msgSender];
require(user.amount >= _amount, "INSUFFICIENT");
updatePool();
if (user.amount == _amount && _amount > 0) {
factory.userLeftFarm(msgSender);
farmInfo.numFarmers = farmInfo.numFarmers.sub(1);
}
uint256 pending = user.amount.mul(farmInfo.accRewardPerShare).div(1e12).sub(user.rewardDebt);
safeRewardTransfer(msgSender, pending);
user.amount = user.amount.sub(_amount);
user.rewardDebt = user.amount.mul(farmInfo.accRewardPerShare).div(1e12);
farmInfo.lpToken.safeTransfer(address(msgSender), _amount);
emit Withdraw(msgSender, _amount);
}
function emergencyWithdraw() public {
address msgSender = _msgSender();
UserInfo storage user = userInfo[msgSender];
farmInfo.lpToken.safeTransfer(address(msgSender), user.amount);
emit EmergencyWithdraw(msgSender, user.amount);
if (user.amount > 0) {
factory.userLeftFarm(msgSender);
farmInfo.numFarmers = farmInfo.numFarmers.sub(1);
}
user.amount = 0;
user.rewardDebt = 0;
}
function safeRewardTransfer(address _to, uint256 _amount) internal {
uint256 rewardBal = farmInfo.rewardToken.balanceOf(address(this));
if (_amount > rewardBal) {
farmInfo.rewardToken.transfer(_to, rewardBal);
} else {
farmInfo.rewardToken.transfer(_to, _amount);
}
}
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
}
| 208,368 | 1,025 |
79d85038e557f50a86caf73d581dafa3fda02f1e1725d542f074b163e3bacf5f
| 15,382 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/StableToken-0xc67b7d0bc4358e9323391a6566cf156a86e7d28d.sol
| 2,534 | 10,071 |
pragma solidity ^0.4.17;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
if (newOwner != address(0)) {
owner = newOwner;
}
}
}
contract ERC20Basic {
uint public _totalSupply;
function totalSupply() public constant returns (uint);
function balanceOf(address who) public constant returns (uint);
function transfer(address to, uint value) public;
event Transfer(address indexed from, address indexed to, uint value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint);
function transferFrom(address from, address to, uint value) public;
function approve(address spender, uint value) public;
event Approval(address indexed owner, address indexed spender, uint value);
}
contract BasicToken is Ownable, ERC20Basic {
using SafeMath for uint;
mapping(address => uint) public balances;
// additional variables for use if transaction fees ever became necessary
uint public basisPointsRate = 0;
uint public maximumFee = 0;
modifier onlyPayloadSize(uint size) {
require(!(msg.data.length < size + 4));
_;
}
function transfer(address _to, uint _value) public onlyPayloadSize(2 * 32) {
uint fee = (_value.mul(basisPointsRate)).div(10000);
if (fee > maximumFee) {
fee = maximumFee;
}
uint sendAmount = _value.sub(fee);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(sendAmount);
if (fee > 0) {
balances[owner] = balances[owner].add(fee);
Transfer(msg.sender, owner, fee);
}
Transfer(msg.sender, _to, sendAmount);
}
function balanceOf(address _owner) public constant returns (uint balance) {
return balances[_owner];
}
}
contract StandardToken is BasicToken, ERC20 {
mapping (address => mapping (address => uint)) public allowed;
uint public constant MAX_UINT = 2**256 - 1;
function transferFrom(address _from, address _to, uint _value) public onlyPayloadSize(3 * 32) {
var _allowance = allowed[_from][msg.sender];
// if (_value > _allowance) throw;
uint fee = (_value.mul(basisPointsRate)).div(10000);
if (fee > maximumFee) {
fee = maximumFee;
}
if (_allowance < MAX_UINT) {
allowed[_from][msg.sender] = _allowance.sub(_value);
}
uint sendAmount = _value.sub(fee);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(sendAmount);
if (fee > 0) {
balances[owner] = balances[owner].add(fee);
Transfer(_from, owner, fee);
}
Transfer(_from, _to, sendAmount);
}
function approve(address _spender, uint _value) public onlyPayloadSize(2 * 32) {
// To change the approve amount you first have to reduce the addresses`
// allowance to zero by calling `approve(_spender, 0)` if it is not
// already 0 to mitigate the race condition described here:
// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
require(!((_value != 0) && (allowed[msg.sender][_spender] != 0)));
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
}
function allowance(address _owner, address _spender) public constant returns (uint remaining) {
return allowed[_owner][_spender];
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
Unpause();
}
}
contract BlackList is Ownable, BasicToken {
function getBlackListStatus(address _maker) external constant returns (bool) {
return isBlackListed[_maker];
}
function getOwner() external constant returns (address) {
return owner;
}
mapping (address => bool) public isBlackListed;
function addBlackList (address _evilUser) public onlyOwner {
isBlackListed[_evilUser] = true;
AddedBlackList(_evilUser);
}
function removeBlackList (address _clearedUser) public onlyOwner {
isBlackListed[_clearedUser] = false;
RemovedBlackList(_clearedUser);
}
function destroyBlackFunds (address _blackListedUser) public onlyOwner {
require(isBlackListed[_blackListedUser]);
uint dirtyFunds = balanceOf(_blackListedUser);
balances[_blackListedUser] = 0;
_totalSupply -= dirtyFunds;
DestroyedBlackFunds(_blackListedUser, dirtyFunds);
}
event DestroyedBlackFunds(address _blackListedUser, uint _balance);
event AddedBlackList(address _user);
event RemovedBlackList(address _user);
}
contract UpgradedStandardToken is StandardToken{
// those methods are called by the legacy contract
// and they must ensure msg.sender to be the contract address
function transferByLegacy(address from, address to, uint value) public;
function transferFromByLegacy(address sender, address from, address spender, uint value) public;
function approveByLegacy(address from, address spender, uint value) public;
}
contract StableToken is Pausable, StandardToken, BlackList {
string public name;
string public symbol;
uint public decimals;
address public upgradedAddress;
bool public deprecated;
function StableToken(string _name, string _symbol, uint _decimals, uint _startToken) public {
_totalSupply = 0;
name = _name;
symbol = _symbol;
decimals = _decimals;
balances[msg.sender] += _startToken * 10 ** _decimals;
_totalSupply += _startToken * 10 ** _decimals;
deprecated = false;
}
function transfer(address _to, uint _value) public whenNotPaused {
require(!isBlackListed[msg.sender]);
if (deprecated) {
return UpgradedStandardToken(upgradedAddress).transferByLegacy(msg.sender, _to, _value);
} else {
return super.transfer(_to, _value);
}
}
function transferFrom(address _from, address _to, uint _value) public whenNotPaused {
require(!isBlackListed[_from]);
if (deprecated) {
return UpgradedStandardToken(upgradedAddress).transferFromByLegacy(msg.sender, _from, _to, _value);
} else {
return super.transferFrom(_from, _to, _value);
}
}
function balanceOf(address who) public constant returns (uint) {
if (deprecated) {
return UpgradedStandardToken(upgradedAddress).balanceOf(who);
} else {
return super.balanceOf(who);
}
}
function approve(address _spender, uint _value) public onlyPayloadSize(2 * 32) {
if (deprecated) {
return UpgradedStandardToken(upgradedAddress).approveByLegacy(msg.sender, _spender, _value);
} else {
return super.approve(_spender, _value);
}
}
function allowance(address _owner, address _spender) public constant returns (uint remaining) {
if (deprecated) {
return StandardToken(upgradedAddress).allowance(_owner, _spender);
} else {
return super.allowance(_owner, _spender);
}
}
function deprecate(address _upgradedAddress) public onlyOwner {
deprecated = true;
upgradedAddress = _upgradedAddress;
Deprecate(_upgradedAddress);
}
function totalSupply() public constant returns (uint) {
if (deprecated) {
return StandardToken(upgradedAddress).totalSupply();
} else {
return _totalSupply;
}
}
function issue(uint amount) public onlyOwner {
require(_totalSupply + amount > _totalSupply);
require(balances[owner] + amount > balances[owner]);
balances[owner] += amount;
_totalSupply += amount;
Issue(amount);
}
function redeem(uint amount) public onlyOwner {
require(_totalSupply >= amount);
require(balances[owner] >= amount);
_totalSupply -= amount;
balances[owner] -= amount;
Redeem(amount);
}
function changeData(string name_, string symbol_) public onlyOwner {
name = name_;
symbol = symbol_;
}
function setParams(uint newBasisPoints, uint newMaxFee) public onlyOwner {
// Ensure transparency by hardcoding limit beyond which fees can never be added
require(newBasisPoints < 20);
require(newMaxFee < 50);
basisPointsRate = newBasisPoints;
maximumFee = newMaxFee.mul(10**decimals);
Params(basisPointsRate, maximumFee);
}
event Issue(uint amount);
event Redeem(uint amount);
event Deprecate(address newAddress);
event Params(uint feeBasisPoints, uint maxFee);
}
| 184,334 | 1,026 |
987f0d304c7d0e5eb08588fc5222067e0e9dfd12cc594fcafc8cc7b372d68f4d
| 11,982 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TH/THGMLCExNdyhRrgFAFeSqa8c3wbN48rhgd_Tronstaking.sol
| 3,952 | 11,824 |
//SourceUnit: Tronstakingn.sol
pragma solidity 0.5.10;
contract Tronstaking {
using SafeMath for uint256;
uint256 constant public INVEST_MIN_AMOUNT = 200 trx;
uint256 constant public WITHDRAW_MIN_AMOUNT = 100 trx;
uint256[] public REFERRAL_PERCENTS = [70, 30, 10,7,5];
uint256 constant public PROJECT_FEE = 250;
uint256 constant public REINVEST_PERCENT = 300;
uint256 constant public WITHDRAW_PERCENT = 700;
uint256 constant public PERCENT_STEP = 2;
uint256 constant public PERCENTS_DIVIDER = 1000;
uint256 constant public TIME_STEP = 1 days;
uint256 public totalTronStaking;
uint256 public totalReinvest;
uint256 public totalWithdraw;
uint256 public totalPartners;
uint256 public totalRefBonus;
struct Plan {
uint256 time;
uint256 percent;
}
Plan[] internal plans;
struct Deposit {
uint8 plan;
uint256 percent;
uint256 amount;
uint256 profit;
uint256 start;
uint256 finish;
uint8 isReinvest;
}
struct WitthdrawHistory {
uint256 amount;
uint256 start;
}
struct User {
Deposit[] deposits;
WitthdrawHistory[] whistory;
uint256 checkpoint;
address referrer;
uint256[5] levels;
uint256[5] levelbonus;
uint256 bonus;
uint256 totalBonus;
}
mapping (address => User) internal users;
uint256 public startUNIX;
address payable public commissionWallet;
event Newbie(address user);
event NewDeposit(address indexed user, uint8 plan, uint256 percent, uint256 amount, uint256 profit, uint256 start, uint256 finish);
event Withdrawn(address indexed user, uint256 amount);
event RefBonus(address indexed referrer, address indexed referral, uint256 indexed level, uint256 amount);
event FeePayed(address indexed user, uint256 totalAmount);
constructor(address payable wallet, uint256 startDate) public {
require(!isContract(wallet));
require(startDate > 0);
commissionWallet = wallet;
startUNIX = startDate;
plans.push(Plan(15, 100));
plans.push(Plan(25, 90));
plans.push(Plan(35, 80));
}
function reinvest(address referrer, uint8 plan,uint256 amountInvest,address userAdress) public payable {
uint256 fee = amountInvest.mul(PROJECT_FEE).div(PERCENTS_DIVIDER);
commissionWallet.transfer(fee);
emit FeePayed(userAdress, fee);
User storage user = users[userAdress];
if (user.referrer == address(0)) {
if (users[referrer].deposits.length > 0 && referrer != userAdress) {
user.referrer = referrer;
}
address upline = user.referrer;
for (uint256 i = 0; i < 5; i++) {
if (upline != address(0)) {
users[upline].levels[i] = users[upline].levels[i].add(1);
upline = users[upline].referrer;
} else break;
}
}
if (user.referrer != address(0)) {
address upline = user.referrer;
for (uint256 i = 0; i < 5; i++) {
if (upline != address(0)) {
uint256 amount = amountInvest.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
users[upline].bonus = users[upline].bonus.add(amount);
users[upline].levelbonus[i]=amount;
users[upline].totalBonus = users[upline].totalBonus.add(amount);
emit RefBonus(upline, msg.sender, i, amount);
upline = users[upline].referrer;
} else break;
}
}
if (user.deposits.length == 0) {
user.checkpoint = block.timestamp;
emit Newbie(userAdress);
}
(uint256 percent, uint256 profit, uint256 finish) = getResult(plan, amountInvest);
user.deposits.push(Deposit(plan, percent, amountInvest, profit, block.timestamp, finish,1));
totalTronStaking = totalTronStaking.add(amountInvest);
totalReinvest = totalReinvest.add(amountInvest);
emit NewDeposit(userAdress, plan, percent, msg.value, profit, block.timestamp, finish);
}
function invest(address referrer, uint8 plan) public payable {
require(msg.value >= INVEST_MIN_AMOUNT);
require(plan < 6, "Invalid plan");
uint256 fee = msg.value.mul(PROJECT_FEE).div(PERCENTS_DIVIDER);
commissionWallet.transfer(fee);
emit FeePayed(msg.sender, fee);
User storage user = users[msg.sender];
if (user.referrer == address(0)) {
if (users[referrer].deposits.length > 0 && referrer != msg.sender) {
user.referrer = referrer;
}
totalPartners=totalPartners.add(1);
address upline = user.referrer;
for (uint256 i = 0; i < 5; i++) {
if (upline != address(0)) {
users[upline].levels[i] = users[upline].levels[i].add(1);
upline = users[upline].referrer;
} else break;
}
}
if (user.referrer != address(0)) {
address upline = user.referrer;
for (uint256 i = 0; i < 5; i++) {
if (upline != address(0)) {
uint256 amount = msg.value.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
users[upline].bonus = users[upline].bonus.add(amount);
users[upline].levelbonus[i]=amount;
users[upline].totalBonus = users[upline].totalBonus.add(amount);
emit RefBonus(upline, msg.sender, i, amount);
upline = users[upline].referrer;
} else break;
}
}
if (user.deposits.length == 0) {
user.checkpoint = block.timestamp;
emit Newbie(msg.sender);
}
(uint256 percent, uint256 profit, uint256 finish) = getResult(plan, msg.value);
user.deposits.push(Deposit(plan, percent, msg.value, profit, block.timestamp, finish,0));
totalTronStaking = totalTronStaking.add(msg.value);
emit NewDeposit(msg.sender, plan, percent, msg.value, profit, block.timestamp, finish);
}
function withdraw() public {
User storage user = users[msg.sender];
uint256 totalAmount = getUserDividends(msg.sender);
uint256 referralBonus = getUserReferralBonus(msg.sender);
if (referralBonus > 0) {
user.bonus = 0;
totalAmount = totalAmount.add(referralBonus);
}
require(totalAmount > 0, "User has no dividends");
uint256 contractBalance = address(this).balance;
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
totalWithdraw= totalWithdraw.add(totalAmount);
user.checkpoint = block.timestamp;
uint256 withdrawAmount=totalAmount.mul(WITHDRAW_PERCENT).div(PERCENTS_DIVIDER);
uint256 reInvestAmount=totalAmount.mul(REINVEST_PERCENT).div(PERCENTS_DIVIDER);
msg.sender.transfer(withdrawAmount);
user.whistory.push(WitthdrawHistory(totalAmount,block.timestamp));
reinvest(user.referrer, 0,reInvestAmount,msg.sender);
emit Withdrawn(msg.sender, totalAmount);
}
function getContractBalance() public view returns (uint256) {
return address(this).balance;
}
function getPlanInfo(uint8 plan) public view returns(uint256 time, uint256 percent) {
time = plans[plan].time;
percent = plans[plan].percent;
}
function getPercent(uint8 plan) public view returns (uint256) {
if (block.timestamp > startUNIX) {
uint256 percent=plans[plan].percent.add(PERCENT_STEP.mul(block.timestamp.sub(startUNIX)).div(TIME_STEP));
if(percent>150){
percent=150 ;
}
return percent;
} else {
return plans[plan].percent;
}
}
function getResult(uint8 plan, uint256 deposit) public view returns (uint256 percent, uint256 profit, uint256 finish) {
percent = getPercent(plan);
if (plan < 3) {
profit = deposit.mul(percent).div(PERCENTS_DIVIDER).mul(plans[plan].time);
} else if (plan < 6) {
for (uint256 i = 0; i < plans[plan].time; i++) {
profit = profit.add((deposit.add(profit)).mul(percent).div(PERCENTS_DIVIDER));
}
}
finish = block.timestamp.add(plans[plan].time.mul(TIME_STEP));
}
function getUserDividends(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
uint256 totalAmount;
for (uint256 i = 0; i < user.deposits.length; i++) {
if (user.checkpoint < user.deposits[i].finish) {
if (user.deposits[i].plan < 3) {
uint256 share = user.deposits[i].amount.mul(user.deposits[i].percent).div(PERCENTS_DIVIDER);
uint256 from = user.deposits[i].start > user.checkpoint ? user.deposits[i].start : user.checkpoint;
uint256 to = user.deposits[i].finish < block.timestamp ? user.deposits[i].finish : block.timestamp;
if (from < to) {
totalAmount = totalAmount.add(share.mul(to.sub(from)).div(TIME_STEP));
}
} else if (block.timestamp > user.deposits[i].finish) {
totalAmount = totalAmount.add(user.deposits[i].profit);
}
}
}
return totalAmount;
}
function getUserCheckpoint(address userAddress) public view returns(uint256) {
return users[userAddress].checkpoint;
}
function getUserReferrer(address userAddress) public view returns(address) {
return users[userAddress].referrer;
}
function getUserDownlineCount(address userAddress) public view returns(uint256, uint256, uint256, uint256, uint256) {
return (users[userAddress].levels[0], users[userAddress].levels[1], users[userAddress].levels[2], users[userAddress].levels[3], users[userAddress].levels[4]);
}
function getUserDownlineBonus(address userAddress) public view returns(uint256, uint256, uint256, uint256, uint256) {
return (users[userAddress].levelbonus[0], users[userAddress].levelbonus[1], users[userAddress].levelbonus[2], users[userAddress].levelbonus[3], users[userAddress].levelbonus[4]);
}
function getUserReferralBonus(address userAddress) public view returns(uint256) {
return users[userAddress].bonus;
}
function getUserReferralTotalBonus(address userAddress) public view returns(uint256) {
return users[userAddress].totalBonus;
}
function getUserReferralWithdrawn(address userAddress) public view returns(uint256) {
return users[userAddress].totalBonus.sub(users[userAddress].bonus);
}
function getUserAvailable(address userAddress) public view returns(uint256) {
return getUserReferralBonus(userAddress).add(getUserDividends(userAddress));
}
function getUserAmountOfDeposits(address userAddress) public view returns(uint256) {
return users[userAddress].deposits.length;
}
function getUserTotalDeposits(address userAddress) public view returns(uint256 amount) {
for (uint256 i = 0; i < users[userAddress].deposits.length; i++) {
amount = amount.add(users[userAddress].deposits[i].amount);
}
}
function getUserWithdrawHistory(address userAddress, uint256 index) public view returns(uint256 amount, uint256 start) {
User storage user = users[userAddress];
amount = user.whistory[index].amount;
start=user.whistory[index].start;
}
function getUserWithdrawSize(address userAddress) public view returns(uint256 length) {
User storage user = users[userAddress];
return user.whistory.length;
}
function getUserDepositInfo(address userAddress, uint256 index) public view returns(uint8 plan, uint256 percent, uint256 amount, uint256 profit, uint256 start, uint256 finish) {
User storage user = users[userAddress];
plan = user.deposits[index].plan;
percent = user.deposits[index].percent;
amount = user.deposits[index].amount;
profit = user.deposits[index].profit;
start = user.deposits[index].start;
finish = user.deposits[index].finish;
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
return c;
}
}
| 294,436 | 1,027 |
f8d3caeba9aac00c27104aa763b8722e53cca555719f0417e0255bdc52300bb3
| 13,752 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.7/0xfc5e6cad30632d79abbb2dbf22a87f0753b0ddc4.sol
| 3,388 | 13,133 |
pragma solidity ^0.4.16;
// copyright contact@Etheremon.com
contract SafeMath {
function safeAdd(uint256 x, uint256 y) pure internal returns(uint256) {
uint256 z = x + y;
assert((z >= x) && (z >= y));
return z;
}
function safeSubtract(uint256 x, uint256 y) pure internal returns(uint256) {
assert(x >= y);
uint256 z = x - y;
return z;
}
function safeMult(uint256 x, uint256 y) pure internal returns(uint256) {
uint256 z = x * y;
assert((x == 0)||(z/x == y));
return z;
}
}
contract BasicAccessControl {
address public owner;
// address[] public moderators;
uint16 public totalModerators = 0;
mapping (address => bool) public moderators;
bool public isMaintaining = false;
function BasicAccessControl() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
modifier onlyModerators() {
require(msg.sender == owner || moderators[msg.sender] == true);
_;
}
modifier isActive {
require(!isMaintaining);
_;
}
function ChangeOwner(address _newOwner) onlyOwner public {
if (_newOwner != address(0)) {
owner = _newOwner;
}
}
function AddModerator(address _newModerator) onlyOwner public {
if (moderators[_newModerator] == false) {
moderators[_newModerator] = true;
totalModerators += 1;
}
}
function RemoveModerator(address _oldModerator) onlyOwner public {
if (moderators[_oldModerator] == true) {
moderators[_oldModerator] = false;
totalModerators -= 1;
}
}
function UpdateMaintaining(bool _isMaintaining) onlyOwner public {
isMaintaining = _isMaintaining;
}
}
contract EtheremonEnum {
enum ResultCode {
SUCCESS,
ERROR_CLASS_NOT_FOUND,
ERROR_LOW_BALANCE,
ERROR_SEND_FAIL,
ERROR_NOT_TRAINER,
ERROR_NOT_ENOUGH_MONEY,
ERROR_INVALID_AMOUNT
}
enum ArrayType {
CLASS_TYPE,
STAT_STEP,
STAT_START,
STAT_BASE,
OBJ_SKILL
}
enum PropertyType {
ANCESTOR,
XFACTOR
}
}
contract EtheremonDataBase is EtheremonEnum, BasicAccessControl, SafeMath {
uint64 public totalMonster;
uint32 public totalClass;
// write
function withdrawEther(address _sendTo, uint _amount) onlyOwner public returns(ResultCode);
function addElementToArrayType(ArrayType _type, uint64 _id, uint8 _value) onlyModerators public returns(uint);
function updateIndexOfArrayType(ArrayType _type, uint64 _id, uint _index, uint8 _value) onlyModerators public returns(uint);
function setMonsterClass(uint32 _classId, uint256 _price, uint256 _returnPrice, bool _catchable) onlyModerators public returns(uint32);
function addMonsterObj(uint32 _classId, address _trainer, string _name) onlyModerators public returns(uint64);
function setMonsterObj(uint64 _objId, string _name, uint32 _exp, uint32 _createIndex, uint32 _lastClaimIndex) onlyModerators public;
function increaseMonsterExp(uint64 _objId, uint32 amount) onlyModerators public;
function decreaseMonsterExp(uint64 _objId, uint32 amount) onlyModerators public;
function removeMonsterIdMapping(address _trainer, uint64 _monsterId) onlyModerators public;
function addMonsterIdMapping(address _trainer, uint64 _monsterId) onlyModerators public;
function clearMonsterReturnBalance(uint64 _monsterId) onlyModerators public returns(uint256 amount);
function collectAllReturnBalance(address _trainer) onlyModerators public returns(uint256 amount);
function transferMonster(address _from, address _to, uint64 _monsterId) onlyModerators public returns(ResultCode);
function addExtraBalance(address _trainer, uint256 _amount) onlyModerators public returns(uint256);
function deductExtraBalance(address _trainer, uint256 _amount) onlyModerators public returns(uint256);
function setExtraBalance(address _trainer, uint256 _amount) onlyModerators public;
// read
function getSizeArrayType(ArrayType _type, uint64 _id) constant public returns(uint);
function getElementInArrayType(ArrayType _type, uint64 _id, uint _index) constant public returns(uint8);
function getMonsterClass(uint32 _classId) constant public returns(uint32 classId, uint256 price, uint256 returnPrice, uint32 total, bool catchable);
function getMonsterObj(uint64 _objId) constant public returns(uint64 objId, uint32 classId, address trainer, uint32 exp, uint32 createIndex, uint32 lastClaimIndex, uint createTime);
function getMonsterName(uint64 _objId) constant public returns(string name);
function getExtraBalance(address _trainer) constant public returns(uint256);
function getMonsterDexSize(address _trainer) constant public returns(uint);
function getMonsterObjId(address _trainer, uint index) constant public returns(uint64);
function getExpectedBalance(address _trainer) constant public returns(uint256);
function getMonsterReturn(uint64 _objId) constant public returns(uint256 current, uint256 total);
}
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 tokens) public returns (bool success);
}
contract BattleInterface {
function createCastleWithToken(address _trainer, uint32 _noBrick, string _name, uint64 _a1, uint64 _a2, uint64 _a3, uint64 _s1, uint64 _s2, uint64 _s3) external;
}
contract TransformInterface {
function removeHatchingTimeWithToken(address _trainer) external;
function buyEggWithToken(address _trainer) external;
}
contract EngergyInterface {
function topupEnergyByToken(address _player, uint _packId, uint _token) external;
}
contract AdventureInterface {
function adventureByToken(address _player, uint _token, uint _param1, uint _param2, uint64 _param3, uint64 _param4) external;
}
contract CubegoInterface {
function payService(address _player, uint _tokens, uint _param1, uint _param2, uint64 _param3, uint64 _param4) external;
}
contract EtheremonPayment is EtheremonEnum, BasicAccessControl, SafeMath {
uint8 constant public STAT_COUNT = 6;
uint8 constant public STAT_MAX = 32;
uint8 constant public GEN0_NO = 24;
enum PayServiceType {
NONE,
FAST_HATCHING,
RANDOM_EGG,
ENERGY_TOPUP,
ADVENTURE,
CUBEGO
}
struct MonsterClassAcc {
uint32 classId;
uint256 price;
uint256 returnPrice;
uint32 total;
bool catchable;
}
struct MonsterObjAcc {
uint64 monsterId;
uint32 classId;
address trainer;
string name;
uint32 exp;
uint32 createIndex;
uint32 lastClaimIndex;
uint createTime;
}
// linked smart contract
address public dataContract;
address public tokenContract;
address public transformContract;
address public energyContract;
address public adventureContract;
address public cubegoContract;
address private lastHunter = address(0x0);
// config
uint public fastHatchingPrice = 35 * 10 ** 8; // 15 tokens
uint public buyEggPrice = 80 * 10 ** 8; // 80 tokens
uint public tokenPrice = 0.004 ether / 10 ** 8;
uint public maxDexSize = 200;
// event
event EventCatchMonster(address indexed trainer, uint64 objId);
// modifier
modifier requireDataContract {
require(dataContract != address(0));
_;
}
modifier requireTokenContract {
require(tokenContract != address(0));
_;
}
modifier requireTransformContract {
require(transformContract != address(0));
_;
}
function EtheremonPayment(address _dataContract, address _tokenContract, address _transformContract, address _energyContract, address _adventureContract, address _cubegoContract) public {
dataContract = _dataContract;
tokenContract = _tokenContract;
transformContract = _transformContract;
energyContract = _energyContract;
adventureContract = _adventureContract;
cubegoContract = _cubegoContract;
}
// helper
function getRandom(uint8 maxRan, uint8 index, address priAddress) constant public returns(uint8) {
uint256 genNum = uint256(block.blockhash(block.number-1)) + uint256(priAddress);
for (uint8 i = 0; i < index && i < 6; i ++) {
genNum /= 256;
}
return uint8(genNum % maxRan);
}
// admin
function withdrawToken(address _sendTo, uint _amount) onlyModerators requireTokenContract external {
ERC20Interface token = ERC20Interface(tokenContract);
if (_amount > token.balanceOf(address(this))) {
revert();
}
token.transfer(_sendTo, _amount);
}
function setContract(address _dataContract, address _tokenContract, address _transformContract, address _energyContract, address _adventureContract, address _cubegoContract) onlyModerators external {
dataContract = _dataContract;
tokenContract = _tokenContract;
transformContract = _transformContract;
energyContract = _energyContract;
adventureContract = _adventureContract;
cubegoContract = _cubegoContract;
}
function setConfig(uint _tokenPrice, uint _maxDexSize, uint _fastHatchingPrice, uint _buyEggPrice) onlyModerators external {
tokenPrice = _tokenPrice;
maxDexSize = _maxDexSize;
fastHatchingPrice = _fastHatchingPrice;
buyEggPrice = _buyEggPrice;
}
// battle
function catchMonster(address _trainer, uint _tokens, uint32 _classId, string _name) isActive requireDataContract requireTokenContract public returns(uint){
if (msg.sender != tokenContract)
revert();
EtheremonDataBase data = EtheremonDataBase(dataContract);
MonsterClassAcc memory class;
(class.classId, class.price, class.returnPrice, class.total, class.catchable) = data.getMonsterClass(_classId);
if (class.classId == 0 || class.catchable == false) {
revert();
}
// can not keep too much etheremon
if (data.getMonsterDexSize(_trainer) > maxDexSize)
revert();
uint requiredToken = class.price/tokenPrice;
if (_tokens < requiredToken)
revert();
// add monster
uint64 objId = data.addMonsterObj(_classId, _trainer, _name);
// generate base stat for the previous one
for (uint i=0; i < STAT_COUNT; i+= 1) {
uint8 value = getRandom(STAT_MAX, uint8(i), lastHunter) + data.getElementInArrayType(ArrayType.STAT_START, uint64(_classId), i);
data.addElementToArrayType(ArrayType.STAT_BASE, objId, value);
}
lastHunter = _trainer;
EventCatchMonster(_trainer, objId);
return requiredToken;
}
function _handleEnergyTopup(address _trainer, uint _param, uint _tokens) internal {
EngergyInterface energy = EngergyInterface(energyContract);
energy.topupEnergyByToken(_trainer, _param, _tokens);
}
function payService(address _trainer, uint _tokens, uint32 _type, string _text, uint64 _param1, uint64 _param2, uint64 _param3, uint64 _param4, uint64 _param5, uint64 _param6) isActive public returns(uint result) {
if (msg.sender != tokenContract)
revert();
TransformInterface transform = TransformInterface(transformContract);
if (_type == uint32(PayServiceType.FAST_HATCHING)) {
// remove hatching time
if (_tokens < fastHatchingPrice)
revert();
transform.removeHatchingTimeWithToken(_trainer);
return fastHatchingPrice;
} else if (_type == uint32(PayServiceType.RANDOM_EGG)) {
if (_tokens < buyEggPrice)
revert();
transform.buyEggWithToken(_trainer);
return buyEggPrice;
} else if (_type == uint32(PayServiceType.ENERGY_TOPUP)) {
_handleEnergyTopup(_trainer, _param1, _tokens);
return _tokens;
} else if (_type == uint32(PayServiceType.ADVENTURE)) {
AdventureInterface adventure = AdventureInterface(adventureContract);
adventure.adventureByToken(_trainer, _tokens, _param1, _param2, _param3, _param4);
return _tokens;
} else if (_type == uint32(PayServiceType.CUBEGO)) {
CubegoInterface cubego = CubegoInterface(cubegoContract);
cubego.payService(_trainer, _tokens, _param1, _param2, _param3, _param4);
return _tokens;
} else {
revert();
}
}
}
| 219,165 | 1,028 |
7ba322cd5dd1c5642094300d02fc757c8ca14d6ed5e7044aa25116d67f3e2617
| 27,684 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x2f55045439c0361ac971686e06d5b698952f89c1.sol
| 4,761 | 17,035 |
pragma solidity ^0.4.13;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// 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 a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract Certifiable is Ownable {
Certifier public certifier;
event CertifierChanged(address indexed newCertifier);
constructor(address _certifier) public {
certifier = Certifier(_certifier);
}
function updateCertifier(address _address) public onlyOwner returns (bool success) {
require(_address != address(0));
emit CertifierChanged(_address);
certifier = Certifier(_address);
return true;
}
}
contract KYCToken is Certifiable {
mapping(address => bool) public kycPending;
mapping(address => bool) public managers;
event ManagerAdded(address indexed newManager);
event ManagerRemoved(address indexed removedManager);
modifier onlyManager() {
require(managers[msg.sender] == true);
_;
}
modifier isKnownCustomer(address _address) {
require(!kycPending[_address] || certifier.certified(_address));
if (kycPending[_address]) {
kycPending[_address] = false;
}
_;
}
constructor(address _certifier) public Certifiable(_certifier)
{
}
function addManager(address _address) external onlyOwner {
managers[_address] = true;
emit ManagerAdded(_address);
}
function removeManager(address _address) external onlyOwner {
managers[_address] = false;
emit ManagerRemoved(_address);
}
}
contract Certifier {
event Confirmed(address indexed who);
event Revoked(address indexed who);
function certified(address) public constant returns (bool);
function get(address, string) public constant returns (bytes32);
function getAddress(address, string) public constant returns (address);
function getUint(address, string) public constant returns (uint);
}
contract Crowdsale {
using SafeMath for uint256;
// The token being sold
ERC20 public token;
// Address where funds are collected
address public wallet;
// How many token units a buyer gets per wei
uint256 public rate;
// Amount of wei raised
uint256 public weiRaised;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
function Crowdsale(uint256 _rate, address _wallet, ERC20 _token) public {
require(_rate > 0);
require(_wallet != address(0));
require(_token != address(0));
rate = _rate;
wallet = _wallet;
token = _token;
}
// -----------------------------------------
// Crowdsale external interface
// -----------------------------------------
function () external payable {
buyTokens(msg.sender);
}
function buyTokens(address _beneficiary) public payable {
uint256 weiAmount = msg.value;
_preValidatePurchase(_beneficiary, weiAmount);
// calculate token amount to be created
uint256 tokens = _getTokenAmount(weiAmount);
// update state
weiRaised = weiRaised.add(weiAmount);
_processPurchase(_beneficiary, tokens);
emit TokenPurchase(msg.sender,
_beneficiary,
weiAmount,
tokens);
_updatePurchasingState(_beneficiary, weiAmount);
_forwardFunds();
_postValidatePurchase(_beneficiary, weiAmount);
}
// -----------------------------------------
// Internal interface (extensible)
// -----------------------------------------
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount) internal {
require(_beneficiary != address(0));
require(_weiAmount != 0);
}
function _postValidatePurchase(address _beneficiary, uint256 _weiAmount) internal {
// optional override
}
function _deliverTokens(address _beneficiary, uint256 _tokenAmount) internal {
token.transfer(_beneficiary, _tokenAmount);
}
function _processPurchase(address _beneficiary, uint256 _tokenAmount) internal {
_deliverTokens(_beneficiary, _tokenAmount);
}
function _updatePurchasingState(address _beneficiary, uint256 _weiAmount) internal {
// optional override
}
function _getTokenAmount(uint256 _weiAmount) internal view returns (uint256) {
return _weiAmount.mul(rate);
}
function _forwardFunds() internal {
wallet.transfer(msg.value);
}
}
contract TimedCrowdsale is Crowdsale {
using SafeMath for uint256;
uint256 public openingTime;
uint256 public closingTime;
modifier onlyWhileOpen {
// solium-disable-next-line security/no-block-members
require(block.timestamp >= openingTime && block.timestamp <= closingTime);
_;
}
function TimedCrowdsale(uint256 _openingTime, uint256 _closingTime) public {
// solium-disable-next-line security/no-block-members
require(_openingTime >= block.timestamp);
require(_closingTime >= _openingTime);
openingTime = _openingTime;
closingTime = _closingTime;
}
function hasClosed() public view returns (bool) {
// solium-disable-next-line security/no-block-members
return block.timestamp > closingTime;
}
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount) internal onlyWhileOpen {
super._preValidatePurchase(_beneficiary, _weiAmount);
}
}
contract AllowanceCrowdsale is Crowdsale {
using SafeMath for uint256;
address public tokenWallet;
function AllowanceCrowdsale(address _tokenWallet) public {
require(_tokenWallet != address(0));
tokenWallet = _tokenWallet;
}
function remainingTokens() public view returns (uint256) {
return token.allowance(tokenWallet, this);
}
function _deliverTokens(address _beneficiary, uint256 _tokenAmount) internal {
token.transferFrom(tokenWallet, _beneficiary, _tokenAmount);
}
}
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);
}
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 (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ERC827 is ERC20 {
function approveAndCall(address _spender, uint256 _value, bytes _data) public payable returns (bool);
function transferAndCall(address _to, uint256 _value, bytes _data) public payable returns (bool);
function transferFromAndCall(address _from,
address _to,
uint256 _value,
bytes _data)
public
payable
returns (bool);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract ERC827Token is ERC827, StandardToken {
function approveAndCall(address _spender, uint256 _value, bytes _data) public payable returns (bool) {
require(_spender != address(this));
super.approve(_spender, _value);
// solium-disable-next-line security/no-call-value
require(_spender.call.value(msg.value)(_data));
return true;
}
function transferAndCall(address _to, uint256 _value, bytes _data) public payable returns (bool) {
require(_to != address(this));
super.transfer(_to, _value);
// solium-disable-next-line security/no-call-value
require(_to.call.value(msg.value)(_data));
return true;
}
function transferFromAndCall(address _from,
address _to,
uint256 _value,
bytes _data)
public payable returns (bool)
{
require(_to != address(this));
super.transferFrom(_from, _to, _value);
// solium-disable-next-line security/no-call-value
require(_to.call.value(msg.value)(_data));
return true;
}
function increaseApprovalAndCall(address _spender, uint _addedValue, bytes _data) public payable returns (bool) {
require(_spender != address(this));
super.increaseApproval(_spender, _addedValue);
// solium-disable-next-line security/no-call-value
require(_spender.call.value(msg.value)(_data));
return true;
}
function decreaseApprovalAndCall(address _spender, uint _subtractedValue, bytes _data) public payable returns (bool) {
require(_spender != address(this));
super.decreaseApproval(_spender, _subtractedValue);
// solium-disable-next-line security/no-call-value
require(_spender.call.value(msg.value)(_data));
return true;
}
}
contract BurnableToken is BasicToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public {
_burn(msg.sender, _value);
}
function _burn(address _who, uint256 _value) internal {
require(_value <= balances[_who]);
// no need to require value <= totalSupply, since that would imply the
// sender's balance is greater than the totalSupply, which *should* be an assertion failure
balances[_who] = balances[_who].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(_who, _value);
emit Transfer(_who, address(0), _value);
}
}
contract EDUToken is BurnableToken, KYCToken, ERC827Token {
using SafeMath for uint256;
string public constant name = "EDU Token";
string public constant symbol = "EDU";
uint8 public constant decimals = 18;
uint256 public constant INITIAL_SUPPLY = 48000000 * (10 ** uint256(decimals));
constructor(address _certifier) public KYCToken(_certifier) {
totalSupply_ = INITIAL_SUPPLY;
balances[msg.sender] = INITIAL_SUPPLY;
emit Transfer(0x0, msg.sender, INITIAL_SUPPLY);
}
function transfer(address _to, uint256 _value) public isKnownCustomer(msg.sender) returns (bool) {
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public isKnownCustomer(_from) returns (bool) {
return super.transferFrom(_from, _to, _value);
}
function approve(address _spender, uint256 _value) public isKnownCustomer(_spender) returns (bool) {
return super.approve(_spender, _value);
}
function increaseApproval(address _spender, uint _addedValue) public isKnownCustomer(_spender) returns (bool success) {
return super.increaseApproval(_spender, _addedValue);
}
function decreaseApproval(address _spender, uint _subtractedValue) public isKnownCustomer(_spender) returns (bool success) {
return super.decreaseApproval(_spender, _subtractedValue);
}
function delayedTransferFrom(address _tokenWallet, address _to, uint256 _value) public onlyManager returns (bool) {
transferFrom(_tokenWallet, _to, _value);
kycPending[_to] = true;
}
}
contract CappedCrowdsale is Crowdsale {
using SafeMath for uint256;
uint256 public cap;
function CappedCrowdsale(uint256 _cap) public {
require(_cap > 0);
cap = _cap;
}
function capReached() public view returns (bool) {
return weiRaised >= cap;
}
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount) internal {
super._preValidatePurchase(_beneficiary, _weiAmount);
require(weiRaised.add(_weiAmount) <= cap);
}
}
contract EDUCrowdsale is AllowanceCrowdsale, CappedCrowdsale, TimedCrowdsale, Ownable, Certifiable {
using SafeMath for uint256;
uint256 constant FIFTY_ETH = 50 * (10 ** 18);
uint256 constant HUNDRED_AND_FIFTY_ETH = 150 * (10 ** 18);
uint256 constant TWO_HUNDRED_AND_FIFTY_ETH = 250 * (10 ** 18);
uint256 constant TEN_ETH = 10 * (10 ** 18);
EDUToken public token;
event TokenWalletChanged(address indexed newTokenWallet);
event WalletChanged(address indexed newWallet);
constructor(address _wallet,
EDUToken _token,
address _tokenWallet,
uint256 _cap,
uint256 _openingTime,
uint256 _closingTime,
address _certifier) public
Crowdsale(getCurrentRate(), _wallet, _token)
AllowanceCrowdsale(_tokenWallet)
CappedCrowdsale(_cap)
TimedCrowdsale(_openingTime, _closingTime)
Certifiable(_certifier)
{
token = _token;
}
function _deliverTokens(address _beneficiary, uint256 _tokenAmount) internal {
if (certifier.certified(_beneficiary)) {
token.transferFrom(tokenWallet, _beneficiary, _tokenAmount);
} else {
token.delayedTransferFrom(tokenWallet, _beneficiary, _tokenAmount);
}
}
function getCurrentRate() public view returns (uint256) {
if (block.timestamp < 1528156799) { // 4th of June 2018 23:59:59 GTC
return 1050;
} else if (block.timestamp < 1528718400) { // 11th of June 2018 12:00:00 GTC
return 940;
} else if (block.timestamp < 1529323200) { // 18th of June 2018 12:00:00 GTC
return 865;
} else if (block.timestamp < 1529928000) { // 25th of June 2018 12:00:00 GTC
return 790;
} else {
return 750;
}
}
function _getTokenAmount(uint256 _weiAmount) internal view returns (uint256)
{
uint256 currentRate = getCurrentRate();
uint256 volumeBonus = _getVolumeBonus(currentRate, _weiAmount);
return currentRate.mul(_weiAmount).add(volumeBonus);
}
function _getVolumeBonus(uint256 _currentRate, uint256 _weiAmount) internal view returns (uint256) {
if (_weiAmount >= TEN_ETH) {
return _currentRate.mul(_weiAmount).mul(20).div(100);
}
return 0;
}
function changeTokenWallet(address _tokenWallet) external onlyOwner {
require(_tokenWallet != address(0x0));
tokenWallet = _tokenWallet;
emit TokenWalletChanged(_tokenWallet);
}
function changeWallet(address _wallet) external onlyOwner {
require(_wallet != address(0x0));
wallet = _wallet;
emit WalletChanged(_wallet);
}
}
| 213,015 | 1,029 |
2311270ceac107e8b04dac222ce32d5743da5d3a5520f5404a5a21308a33b6d3
| 13,739 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0xea58183f57d2f3ee111290164e83d39429b629b1.sol
| 3,858 | 13,442 |
pragma solidity ^0.4.21;
contract Partner {
function exchangeTokensFromOtherContract(address _source, address _recipient, uint256 _RequestedTokens);
}
contract Target {
function transfer(address _to, uint _value);
}
contract MNY {
string public name = "MNY by Monkey Capital";
uint8 public decimals = 18;
string public symbol = "MNY";
address public owner;
address public exchangeAdmin;
mapping(uint256 => address) public exchangePartners;
mapping(address => uint256) public exchangeRates;
uint tierLevel = 1;
uint maxTier = 30;
uint256 totalSupply = 1.698846726062230000E25;
uint256 public mineableTokens = totalSupply;
uint256 public swappedTokens = 0;
uint256 circulatingSupply = 0;
uint contractCount = 0;
bool swap = false;
bool distributionCalculated = false;
bool public initialTiers = false;
bool addTiers = true;
mapping (address => uint256) public balances;
mapping (address => uint256) public tokenBalances;
mapping (address => uint256) public tokenShare;
mapping (address => mapping (address => uint256)) allowed;
mapping(uint => uint256) public scheduleTokens;
mapping(uint => uint256) public scheduleRates;
uint256 swapEndTime;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
event TokensExchanged(address indexed _sendingWallet, address indexed _sendingContract, uint256 _tokensIn);
function MNY() {
owner = msg.sender;
}
function populateTierTokens() public {
require((msg.sender == owner) && (initialTiers == false));
scheduleTokens[1] = 5.33696E18;
scheduleTokens[2] = 7.69493333E18;
scheduleTokens[3] = 4.75684324E18;
scheduleTokens[4] = 6.30846753E18;
scheduleTokens[5] = 6.21620513E18;
scheduleTokens[6] = 5.63157219E18;
scheduleTokens[7] = 5.80023669E18;
scheduleTokens[8] = 5.04458667E18;
scheduleTokens[9] = 4.58042767E18;
scheduleTokens[10] = 5E18;
scheduleTokens[11] = 5.59421053E18;
scheduleTokens[12] = 7.05050888E18;
scheduleTokens[13] = 1.93149011E19;
scheduleTokens[14] = 5.71055924E18;
scheduleTokens[15] = 1.087367665E19;
scheduleTokens[16] = 5.4685283E18;
scheduleTokens[17] = 7.58236145E18;
scheduleTokens[18] = 5.80773184E18;
scheduleTokens[19] = 4.74868639E18;
scheduleTokens[20] = 6.74810256E18;
scheduleTokens[21] = 5.52847682E18;
scheduleTokens[22] = 4.96611055E18;
scheduleTokens[23] = 5.45818182E18;
scheduleTokens[24] = 8.0597095E18;
scheduleTokens[25] = 1.459911381E19;
scheduleTokens[26] = 8.32598844E18;
scheduleTokens[27] = 4.555277509E19;
scheduleTokens[28] = 1.395674359E19;
scheduleTokens[29] = 9.78908515E18;
scheduleTokens[30] = 1.169045087E19;
}
function populateTierRates() public {
require((msg.sender == owner) && (initialTiers == false));
scheduleRates[1] = 9E18;
scheduleRates[2] = 9E18;
scheduleRates[3] = 8E18;
scheduleRates[4] = 7E18;
scheduleRates[5] = 8E18;
scheduleRates[6] = 5E18;
scheduleRates[7] = 6E18;
scheduleRates[8] = 5E18;
scheduleRates[9] = 5E18;
scheduleRates[10] = 6E18;
scheduleRates[11] = 6E18;
scheduleRates[12] = 6E18;
scheduleRates[13] = 7E18;
scheduleRates[14] = 6E18;
scheduleRates[15] = 7E18;
scheduleRates[16] = 6E18;
scheduleRates[17] = 6E18;
scheduleRates[18] = 6E18;
scheduleRates[19] = 6E18;
scheduleRates[20] = 6E18;
scheduleRates[21] = 6E18;
scheduleRates[22] = 6E18;
scheduleRates[23] = 6E18;
scheduleRates[24] = 7E18;
scheduleRates[25] = 7E18;
scheduleRates[26] = 7E18;
scheduleRates[27] = 7E18;
scheduleRates[28] = 6E18;
scheduleRates[29] = 7E18;
scheduleRates[30] = 7E18;
initialTiers = true;
}
function transfer(address _to, uint256 _value, bytes _data) public {
require(balances[msg.sender] >= _value);
if(_to == address(this)) {
if(swap == false) {
mineableTokens = add(mineableTokens, _value);
circulatingSupply = sub(circulatingSupply, _value);
if(circulatingSupply == 0) {
swap = true;
swapEndTime = now + 90 days;
}
scheduleTokens[maxTier] = add(scheduleTokens[maxTier], _value);
balances[msg.sender] = sub(balanceOf(msg.sender), _value);
Transfer(msg.sender, _to, _value);
}
else {
if(distributionCalculated = false) {
calculateHeldTokenDistribution();
}
swappedTokens = add(swappedTokens, _value);
balances[msg.sender] = sub(balances[msg.sender], _value);
shareStoredTokens(msg.sender, _value);
}
}
else {
balances[msg.sender] = sub(balanceOf(msg.sender), _value);
balances[_to] = add(balances[_to], _value);
Transfer(msg.sender, _to, _value);
}
}
function allocateTokens(uint256 _submitted, uint256 _tokenCount, address _recipient) internal {
uint256 _tokensAfforded = 0;
if(tierLevel <= maxTier) {
_tokensAfforded = div(_submitted, scheduleRates[tierLevel]);
}
if(_tokensAfforded >= scheduleTokens[tierLevel]) {
_submitted = sub(_submitted, mul(scheduleTokens[tierLevel], scheduleRates[tierLevel]));
_tokenCount = add(_tokenCount, scheduleTokens[tierLevel]);
circulatingSupply = add(circulatingSupply, _tokensAfforded);
mineableTokens = sub(mineableTokens, _tokensAfforded);
scheduleTokens[tierLevel] = 0;
tierLevel++;
allocateTokens(_submitted, _tokenCount, _recipient);
}
else if((scheduleTokens[tierLevel] >= _tokensAfforded) && (_tokensAfforded > 0)) {
scheduleTokens[tierLevel] = sub(scheduleTokens[tierLevel], _tokensAfforded);
_tokenCount = add(_tokenCount, _tokensAfforded);
circulatingSupply = add(circulatingSupply, _tokensAfforded);
mineableTokens = sub(mineableTokens, _tokensAfforded);
_submitted = sub(_submitted, mul(_tokensAfforded, scheduleRates[tierLevel]));
allocateTokens(_submitted, _tokenCount, _recipient);
}
else {
balances[_recipient] = add(balances[_recipient], _tokenCount);
Transfer(this, _recipient, _tokenCount);
}
}
function exchangeTokensFromOtherContract(address _source, address _recipient, uint256 _sentTokens) {
require(exchangeRates[msg.sender] > 0);
allocateTokens(mul(_sentTokens, exchangeRates[_source]), 0, _recipient);
TokensExchanged(_recipient, _source, _sentTokens);
maintainExternalContractTokenBalance(_source, _sentTokens);
}
function addExchangePartnerAddressAndRate(address _partner, uint256 _rate) public {
require(msg.sender == owner);
uint codeLength;
assembly {
codeLength := extcodesize(_partner)
}
require(codeLength > 0);
exchangeRates[_partner] = _rate;
bool isContract = existingContract(_partner);
if(isContract == false) {
contractCount++;
exchangePartners[contractCount] = _partner;
}
}
function addTierRateAndTokens(uint256 _level, uint256 _tokens, uint256 _rate) public {
require(((msg.sender == owner) || (msg.sender == exchangeAdmin)) && (addTiers == true));
scheduleTokens[_level] = _tokens;
scheduleRates[_level] = _rate;
maxTier++;
if(maxTier > 2856) {
totalSupply = add(totalSupply, _tokens);
}
}
function closeTierAddition() public {
require(msg.sender == owner);
addTiers = false;
}
function getTotalSupply() public constant returns (uint256) {
return totalSupply;
}
function getMineableTokens() public constant returns (uint256) {
return mineableTokens;
}
function getCirculatingSupply() public constant returns (uint256) {
return circulatingSupply;
}
function balanceOf(address _receiver) public constant returns (uint256) {
return balances[_receiver];
}
function balanceInTier() public constant returns (uint256) {
return scheduleTokens[tierLevel];
}
function balanceInSpecificTier(uint256 _tier) public constant returns (uint256) {
return scheduleTokens[_tier];
}
function rateInSpecificTier(uint256 _tier) public constant returns (uint256) {
return scheduleRates[_tier];
}
function currentTier() public constant returns (uint256) {
return tierLevel;
}
function convertTransferredTokensToMny(uint256 _value, address _recipient, address _source, uint256 _originalTokenAmount) public {
require((msg.sender == owner) || (msg.sender == exchangeAdmin));
require(exchangeRates[_source] > 0);
allocateTokens(_value, 0, _recipient);
maintainExternalContractTokenBalance(_source, _originalTokenAmount);
TokensExchanged(_recipient, _source, _originalTokenAmount);
}
function changeOwner(address _newOwner) public {
require(msg.sender == owner);
owner = _newOwner;
}
function changeExchangeAdmin(address _newAdmin) public {
require(msg.sender == owner);
exchangeAdmin = _newAdmin;
}
function maintainExternalContractTokenBalance(address _contract, uint256 _tokens) internal {
tokenBalances[_contract] = add(tokenBalances[_contract], _tokens);
}
function getTokenBalance(address _contract) public constant returns (uint256) {
return tokenBalances[_contract];
}
function calculateHeldTokenDistribution() public {
require(swap == true);
for(uint256 i=0; i<contractCount; i++) {
tokenShare[exchangePartners[i]] = div(tokenBalances[exchangePartners[i]], totalSupply);
}
distributionCalculated = true;
}
function tokenShare(address _contract) public constant returns (uint256) {
return tokenShare[_contract];
}
function shareStoredTokens(address _recipient, uint256 mny) internal {
Target t;
uint256 share = 0;
for(uint i=0; i<contractCount; i++) {
share = mul(mny, tokenShare[exchangePartners[i]]);
t = Target(exchangePartners[i]);
t.transfer(_recipient, share);
tokenBalances[exchangePartners[i]] = sub(tokenBalances[exchangePartners[i]], share);
}
}
function distributeMnyAfterSwap(address _recipient, uint256 _tokens) public {
require(msg.sender == owner);
require(swappedTokens <= _tokens);
balances[_recipient] = add(balances[_recipient], _tokens);
Transfer(this, _recipient, _tokens);
swappedTokens = sub(totalSupply, _tokens);
circulatingSupply = add(circulatingSupply, _tokens);
}
function distributeOwnedTokensFromOtherContracts(address _contract, address _recipient, uint256 _tokens) {
require(now >= swapEndTime);
require(msg.sender == owner);
require(tokenBalances[_contract] >= _tokens);
Target t = Target(_contract);
t.transfer(_recipient, _tokens);
tokenBalances[_contract] = sub(tokenBalances[_contract], _tokens);
}
function existingContract(address _contract) internal returns (bool) {
for(uint i=0; i<=contractCount; i++) {
if(exchangePartners[i] == _contract) return true;
}
return false;
}
function contractExchangeRate(address _contract) public constant returns (uint256) {
return exchangeRates[_contract];
}
function mul(uint a, uint b) internal pure returns (uint) {
uint c = a * b;
require(a == 0 || c / a == b);
return c;
}
function div(uint a, uint b) internal pure returns (uint) {
uint c = a / b;
return c;
}
function sub(uint a, uint b) internal pure returns (uint) {
require(b <= a);
return a - b;
}
function add(uint a, uint b) internal pure returns (uint) {
uint c = a + b;
require(c >= a);
return c;
}
function transferFrom(address _from, address _to, uint256 _tokens) public returns (bool success) {
require(balances[_from] >= _tokens);
balances[_from] = sub(balances[_from],_tokens);
allowed[_from][msg.sender] = sub(allowed[_from][msg.sender],_tokens);
balances[_to] = add(balances[_to],_tokens);
Transfer(_from, _to, _tokens);
return true;
}
function approve(address _spender, uint256 _tokens) public returns (bool success) {
allowed[msg.sender][_spender] = _tokens;
Approval(msg.sender, _spender, _tokens);
return true;
}
function allowance(address _tokenOwner, address _spender) public constant returns (uint256 remaining) {
return allowed[_tokenOwner][_spender];
}
}
| 162,515 | 1,030 |
255a6132d29c81f6af6e3662d7ab9af22a46b7a59415a3a7687c75cb58f65941
| 20,053 |
.sol
|
Solidity
| false |
360539372
|
transaction-reverting-statements/Characterizing-require-statement-in-Ethereum-Smart-Contract
|
1d65472e1c546af6781cb17991843befc635a28e
|
dataset/dapp_contracts/Marketplace/0x95283102A95f84fd7FB3ba0EE5C5A8F16E82c025.sol
| 4,465 | 18,465 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.5.17;
pragma experimental ABIEncoderV2;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function add(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, errorMessage);
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction underflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function mul(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, errorMessage);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract Governance {
using SafeMath for uint;
/// @notice The name of this contract
string public constant name = "Governance";
uint public _quorumVotes = 200; // % of total supply required
/// @notice The number of votes required in order for a voter to become a proposer
uint public _proposalThreshold = 100;
uint public constant BASE = 10000;
function setQuorum(uint quorum_) external {
require(msg.sender == address(this), "Governance::setQuorum: timelock only");
_quorumVotes = quorum_;
}
function quorumVotes() public view returns (uint) {
return VOTER.totalSupply().mul(_quorumVotes).div(BASE);
}
function proposalThreshold() public view returns (uint) {
return VOTER.totalSupply().mul(_proposalThreshold).div(BASE);
}
function setThreshold(uint threshold_) external {
require(msg.sender == address(this), "Governance::setQuorum: timelock only");
_proposalThreshold = threshold_;
}
/// @notice The maximum number of actions that can be included in a proposal
function proposalMaxOperations() public pure returns (uint) { return 10; } // 10 actions
/// @notice The delay before voting on a proposal may take place, once proposed
function votingDelay() public pure returns (uint) { return 1; } // 1 block
/// @notice The duration of voting on a proposal, in blocks
function votingPeriod() public pure returns (uint) { return 40_320; } // ~7 days in blocks (assuming 15s blocks)
/// @notice The address of the governance token
DelegateInterface public VOTER;
/// @notice The total number of proposals
uint public proposalCount;
struct Proposal {
/// @notice Unique id for looking up a proposal
uint id;
/// @notice Creator of the proposal
address proposer;
uint eta;
/// @notice the ordered list of target addresses for calls to be made
address[] targets;
/// @notice The ordered list of values (i.e. msg.value) to be passed to the calls to be made
uint[] values;
/// @notice The ordered list of function signatures to be called
string[] signatures;
/// @notice The ordered list of calldata to be passed to each call
bytes[] calldatas;
/// @notice The block at which voting begins: holders must delegate their votes prior to this block
uint startBlock;
/// @notice The block at which voting ends: votes must be cast prior to this block
uint endBlock;
/// @notice Current number of votes in favor of this proposal
uint forVotes;
/// @notice Current number of votes in opposition to this proposal
uint againstVotes;
/// @notice Flag marking whether the proposal has been canceled
bool canceled;
/// @notice Flag marking whether the proposal has been executed
bool executed;
/// @notice Receipts of ballots for the entire set of voters
mapping (address => Receipt) receipts;
}
/// @notice Ballot receipt record for a voter
struct Receipt {
/// @notice Whether or not a vote has been cast
bool hasVoted;
/// @notice Whether or not the voter supports the proposal
bool support;
/// @notice The number of votes the voter had, which were cast
uint votes;
}
/// @notice Possible states that a proposal may be in
enum ProposalState {
Pending,
Active,
Canceled,
Defeated,
Succeeded,
Queued,
Expired,
Executed
}
/// @notice The official record of all proposals ever proposed
mapping (uint => Proposal) public proposals;
/// @notice The latest proposal for each proposer
mapping (address => uint) public latestProposalIds;
/// @notice The EIP-712 typehash for the contract's domain
bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");
/// @notice The EIP-712 typehash for the ballot struct used by the contract
bytes32 public constant BALLOT_TYPEHASH = keccak256("Ballot(uint256 proposalId,bool support)");
/// @notice An event emitted when a new proposal is created
event ProposalCreated(uint id, address proposer, address[] targets, uint[] values, string[] signatures, bytes[] calldatas, uint startBlock, uint endBlock, string description);
/// @notice An event emitted when a vote has been cast on a proposal
event VoteCast(address voter, uint proposalId, bool support, uint votes);
/// @notice An event emitted when a proposal has been canceled
event ProposalCanceled(uint id);
/// @notice An event emitted when a proposal has been queued in the Timelock
event ProposalQueued(uint id, uint eta);
/// @notice An event emitted when a proposal has been executed in the Timelock
event ProposalExecuted(uint id);
function propose(address[] memory targets, uint[] memory values, string[] memory signatures, bytes[] memory calldatas, string memory description) public returns (uint) {
require(VOTER.getPriorVotes(msg.sender, block.number.sub(1)) > proposalThreshold(), "Governance::propose: proposer votes below proposal threshold");
require(targets.length == values.length && targets.length == signatures.length && targets.length == calldatas.length, "Governance::propose: proposal function information arity mismatch");
require(targets.length != 0, "Governance::propose: must provide actions");
require(targets.length <= proposalMaxOperations(), "Governance::propose: too many actions");
uint latestProposalId = latestProposalIds[msg.sender];
if (latestProposalId != 0) {
ProposalState proposersLatestProposalState = state(latestProposalId);
require(proposersLatestProposalState != ProposalState.Active, "Governance::propose: one live proposal per proposer, found an already active proposal");
require(proposersLatestProposalState != ProposalState.Pending, "Governance::propose: one live proposal per proposer, found an already pending proposal");
}
uint startBlock = block.number.add(votingDelay());
uint endBlock = startBlock.add(votingPeriod());
proposalCount++;
Proposal memory newProposal = Proposal({
id: proposalCount,
proposer: msg.sender,
eta: 0,
targets: targets,
values: values,
signatures: signatures,
calldatas: calldatas,
startBlock: startBlock,
endBlock: endBlock,
forVotes: 0,
againstVotes: 0,
canceled: false,
executed: false
});
proposals[newProposal.id] = newProposal;
latestProposalIds[newProposal.proposer] = newProposal.id;
emit ProposalCreated(newProposal.id, msg.sender, targets, values, signatures, calldatas, startBlock, endBlock, description);
return newProposal.id;
}
function queue(uint proposalId) public {
require(state(proposalId) == ProposalState.Succeeded, "Governance::queue: proposal can only be queued if it is succeeded");
Proposal storage proposal = proposals[proposalId];
uint eta = block.timestamp.add(delay);
for (uint i = 0; i < proposal.targets.length; i++) {
_queueOrRevert(proposal.targets[i], proposal.values[i], proposal.signatures[i], proposal.calldatas[i], eta);
}
proposal.eta = eta;
emit ProposalQueued(proposalId, eta);
}
function _queueOrRevert(address target, uint value, string memory signature, bytes memory data, uint eta) internal {
require(!queuedTransactions[keccak256(abi.encode(target, value, signature, data, eta))], "Governance::_queueOrRevert: proposal action already queued at eta");
queueTransaction(target, value, signature, data, eta);
}
function execute(uint proposalId) public payable {
require(state(proposalId) == ProposalState.Queued, "Governance::execute: proposal can only be executed if it is queued");
Proposal storage proposal = proposals[proposalId];
proposal.executed = true;
for (uint i = 0; i < proposal.targets.length; i++) {
executeTransaction(proposal.targets[i], proposal.values[i], proposal.signatures[i], proposal.calldatas[i], proposal.eta);
}
emit ProposalExecuted(proposalId);
}
function cancel(uint proposalId) public {
ProposalState state = state(proposalId);
require(state != ProposalState.Executed, "Governance::cancel: cannot cancel executed proposal");
Proposal storage proposal = proposals[proposalId];
require(VOTER.getPriorVotes(proposal.proposer, block.number.sub(1)) < proposalThreshold(), "Governance::cancel: proposer above threshold");
proposal.canceled = true;
for (uint i = 0; i < proposal.targets.length; i++) {
cancelTransaction(proposal.targets[i], proposal.values[i], proposal.signatures[i], proposal.calldatas[i], proposal.eta);
}
emit ProposalCanceled(proposalId);
}
function getActions(uint proposalId) public view returns (address[] memory targets, uint[] memory values, string[] memory signatures, bytes[] memory calldatas) {
Proposal storage p = proposals[proposalId];
return (p.targets, p.values, p.signatures, p.calldatas);
}
function getReceipt(uint proposalId, address voter) public view returns (Receipt memory) {
return proposals[proposalId].receipts[voter];
}
function state(uint proposalId) public view returns (ProposalState) {
require(proposalCount >= proposalId && proposalId > 0, "Governance::state: invalid proposal id");
Proposal storage proposal = proposals[proposalId];
if (proposal.canceled) {
return ProposalState.Canceled;
} else if (block.number <= proposal.startBlock) {
return ProposalState.Pending;
} else if (block.number <= proposal.endBlock) {
return ProposalState.Active;
} else if (proposal.forVotes <= proposal.againstVotes || proposal.forVotes < quorumVotes()) {
return ProposalState.Defeated;
} else if (proposal.eta == 0) {
return ProposalState.Succeeded;
} else if (proposal.executed) {
return ProposalState.Executed;
} else if (block.timestamp >= proposal.eta.add(GRACE_PERIOD)) {
return ProposalState.Expired;
} else {
return ProposalState.Queued;
}
}
function castVote(uint proposalId, bool support) public {
return _castVote(msg.sender, proposalId, support);
}
function castVoteBySig(uint proposalId, bool support, uint8 v, bytes32 r, bytes32 s) public {
bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH, keccak256(bytes(name)), getChainId(), address(this)));
bytes32 structHash = keccak256(abi.encode(BALLOT_TYPEHASH, proposalId, support));
bytes32 digest = keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
address signatory = ecrecover(digest, v, r, s);
require(signatory != address(0), "Governance::castVoteBySig: invalid signature");
return _castVote(signatory, proposalId, support);
}
function _castVote(address voter, uint proposalId, bool support) internal {
require(state(proposalId) == ProposalState.Active, "Governance::_castVote: voting is closed");
Proposal storage proposal = proposals[proposalId];
Receipt storage receipt = proposal.receipts[voter];
require(receipt.hasVoted == false, "Governance::_castVote: voter already voted");
uint votes = VOTER.getPriorVotes(voter, proposal.startBlock);
if (support) {
proposal.forVotes = proposal.forVotes.add(votes);
} else {
proposal.againstVotes = proposal.againstVotes.add(votes);
}
receipt.hasVoted = true;
receipt.support = support;
receipt.votes = votes;
emit VoteCast(voter, proposalId, support, votes);
}
function getChainId() internal pure returns (uint) {
uint chainId;
assembly { chainId := chainid() }
return chainId;
}
event NewDelay(uint indexed newDelay);
event CancelTransaction(bytes32 indexed txHash, address indexed target, uint value, string signature, bytes data, uint eta);
event ExecuteTransaction(bytes32 indexed txHash, address indexed target, uint value, string signature, bytes data, uint eta);
event QueueTransaction(bytes32 indexed txHash, address indexed target, uint value, string signature, bytes data, uint eta);
uint public constant GRACE_PERIOD = 14 days;
uint public constant MINIMUM_DELAY = 1 days;
uint public constant MAXIMUM_DELAY = 30 days;
uint public delay = MINIMUM_DELAY;
mapping (bytes32 => bool) public queuedTransactions;
constructor(address token_) public {
VOTER = DelegateInterface(token_);
}
function() external payable { }
function setDelay(uint delay_) public {
require(msg.sender == address(this), "Timelock::setDelay: Call must come from Timelock.");
require(delay_ >= MINIMUM_DELAY, "Timelock::setDelay: Delay must exceed minimum delay.");
require(delay_ <= MAXIMUM_DELAY, "Timelock::setDelay: Delay must not exceed maximum delay.");
delay = delay_;
emit NewDelay(delay);
}
function queueTransaction(address target, uint value, string memory signature, bytes memory data, uint eta) public returns (bytes32) {
require(msg.sender == address(this), "Timelock::queueTransaction: Call must come from admin.");
require(eta >= getBlockTimestamp().add(delay), "Timelock::queueTransaction: Estimated execution block must satisfy delay.");
bytes32 txHash = keccak256(abi.encode(target, value, signature, data, eta));
queuedTransactions[txHash] = true;
emit QueueTransaction(txHash, target, value, signature, data, eta);
return txHash;
}
function cancelTransaction(address target, uint value, string memory signature, bytes memory data, uint eta) public {
require(msg.sender == address(this), "Timelock::cancelTransaction: Call must come from admin.");
bytes32 txHash = keccak256(abi.encode(target, value, signature, data, eta));
queuedTransactions[txHash] = false;
emit CancelTransaction(txHash, target, value, signature, data, eta);
}
function executeTransaction(address target, uint value, string memory signature, bytes memory data, uint eta) public payable returns (bytes memory) {
require(msg.sender == address(this), "Timelock::executeTransaction: Call must come from admin.");
bytes32 txHash = keccak256(abi.encode(target, value, signature, data, eta));
require(queuedTransactions[txHash], "Timelock::executeTransaction: Transaction hasn't been queued.");
require(getBlockTimestamp() >= eta, "Timelock::executeTransaction: Transaction hasn't surpassed time lock.");
require(getBlockTimestamp() <= eta.add(GRACE_PERIOD), "Timelock::executeTransaction: Transaction is stale.");
queuedTransactions[txHash] = false;
bytes memory callData;
if (bytes(signature).length == 0) {
callData = data;
} else {
callData = abi.encodePacked(bytes4(keccak256(bytes(signature))), data);
}
// solium-disable-next-line security/no-call-value
(bool success, bytes memory returnData) = target.call.value(value)(callData);
require(success, "Timelock::executeTransaction: Transaction execution reverted.");
emit ExecuteTransaction(txHash, target, value, signature, data, eta);
return returnData;
}
function getBlockTimestamp() internal view returns (uint) {
// solium-disable-next-line security/no-block-members
return block.timestamp;
}
}
interface DelegateInterface {
function getPriorVotes(address account, uint blockNumber) external view returns (uint);
function totalSupply() external view returns (uint);
}
contract GovernanceFactory {
function deploy(address voter) external returns (address) {
return address(new Governance(voter));
}
}
| 334,808 | 1,031 |
22dccf441073ae5b4819f5db21c0833308e621fdf46ee81f9a2f299a52a997a6
| 13,987 |
.sol
|
Solidity
| false |
606585904
|
plotchy/defi-detective
|
f48830b1085dac002283a2ce5e565e341aab5d0c
|
00byaddress/00F1B9C290aeCC410324D28587Ef43ab94fDE652.sol
| 3,673 | 13,224 |
pragma solidity 0.8.9;
// SPDX-License-Identifier: UNLICENSED
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract AZTEC 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 _isExcludedFromFee;
mapping (address => bool) private bots;
mapping (address => uint) private cooldown;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 1000000 * 10**_decimals;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _feeAddr1;
uint256 private _feeAddr2;
uint256 private _standardTax;
address payable private _feeAddrWallet;
string private constant _name = unicode"Aztec Legacy";
string private constant _symbol = unicode"AZTEC";
uint8 private constant _decimals = 5;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = false;
bool private cooldownEnabled = false;
uint256 private _maxTxAmount = _tTotal.mul(2).div(100);
uint256 private _maxWalletSize = _tTotal.mul(2).div(100);
event MaxTxAmountUpdated(uint _maxTxAmount);
modifier lockTheSwap {
inSwap = true;
_;
inSwap = false;
}
constructor () {
_feeAddrWallet = payable(_msgSender());
_rOwned[_msgSender()] = _rTotal;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedFromFee[_feeAddrWallet] = true;
_standardTax=5;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public pure returns (string memory) {
return _name;
}
function symbol() public pure returns (string memory) {
return _symbol;
}
function decimals() public pure returns (uint8) {
return _decimals;
}
function totalSupply() public pure override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function setCooldownEnabled(bool onoff) external onlyOwner() {
cooldownEnabled = onoff;
}
function tokenFromReflection(uint256 rAmount) private view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if (from != owner() && to != owner()) {
require(!bots[from] && !bots[to]);
_feeAddr1 = 0;
_feeAddr2 = _standardTax;
if (from == uniswapV2Pair && to != address(uniswapV2Router) && ! _isExcludedFromFee[to] && cooldownEnabled) {
// Cooldown
require(amount <= _maxTxAmount, "Exceeds the _maxTxAmount.");
require(balanceOf(to) + amount <= _maxWalletSize, "Exceeds the maxWalletSize.");
}
uint256 contractTokenBalance = balanceOf(address(this));
if (!inSwap && from != uniswapV2Pair && swapEnabled && contractTokenBalance>0) {
swapTokensForEth(contractTokenBalance);
uint256 contractETHBalance = address(this).balance;
if(contractETHBalance > 0) {
sendETHToFee(address(this).balance);
}
}
}else{
_feeAddr1 = 0;
_feeAddr2 = 0;
}
_tokenTransfer(from,to,amount);
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = uniswapV2Router.WETH();
_approve(address(this), address(uniswapV2Router), tokenAmount);
uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(tokenAmount,
0,
path,
address(this),
block.timestamp);
}
function setStandardTax(uint256 newTax) external onlyOwner{
require(newTax<_standardTax);
_standardTax=newTax;
}
function removeLimits() external onlyOwner{
_maxTxAmount = _tTotal;
_maxWalletSize = _tTotal;
}
function sendETHToFee(uint256 amount) private {
_feeAddrWallet.transfer(amount);
}
function openTrading() external onlyOwner() {
require(!tradingOpen,"trading is already open");
IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
uniswapV2Router = _uniswapV2Router;
_approve(address(this), address(uniswapV2Router), _tTotal);
uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory()).createPair(address(this), _uniswapV2Router.WETH());
uniswapV2Router.addLiquidityETH{value: address(this).balance}(address(this),balanceOf(address(this)),0,0,owner(),block.timestamp);
swapEnabled = true;
cooldownEnabled = true;
tradingOpen = true;
IERC20(uniswapV2Pair).approve(address(uniswapV2Router), type(uint).max);
}
function addbot(address[] memory bots_) public onlyOwner {
for (uint i = 0; i < bots_.length; i++) {
bots[bots_[i]] = true;
}
}
function _tokenTransfer(address sender, address recipient, uint256 amount) private {
_transferStandard(sender, recipient, amount);
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tTeam) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_takeTeam(tTeam);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _takeTeam(uint256 tTeam) private {
uint256 currentRate = _getRate();
uint256 rTeam = tTeam.mul(currentRate);
_rOwned[address(this)] = _rOwned[address(this)].add(rTeam);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotal = _rTotal.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
receive() external payable {}
function manualswap() external {
require(_msgSender() == _feeAddrWallet);
uint256 contractBalance = balanceOf(address(this));
swapTokensForEth(contractBalance);
}
function manualsend() external {
require(_msgSender() == _feeAddrWallet);
uint256 contractETHBalance = address(this).balance;
sendETHToFee(contractETHBalance);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tTeam) = _getTValues(tAmount, _feeAddr1, _feeAddr2);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tTeam, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tTeam);
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 TeamFee) private pure returns (uint256, uint256, uint256) {
uint256 tFee = tAmount.mul(taxFee).div(100);
uint256 tTeam = tAmount.mul(TeamFee).div(100);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tTeam);
return (tTransferAmount, tFee, tTeam);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tTeam, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rTeam = tTeam.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rTeam);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
}
| 343,957 | 1,032 |
5219eb7b60137388cde6044eb79dfc1f2c2daa05d1b8bf4777e9618aff456fb3
| 30,599 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/91/91FbD0C9dbA8C42B7Fa636CC60344c72E7D065c9_DODOLimitOrder.sol
| 5,636 | 20,641 |
// File: contracts/intf/IERC20.sol
// SPDX-License-Identifier: MIT
pragma solidity 0.8.4;
pragma experimental ABIEncoderV2;
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function name() external view returns (string memory);
function symbol() external view returns (string memory);
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);
}
// File: contracts/lib/SafeMath.sol
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "MUL_ERROR");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "DIVIDING_ERROR");
return a / b;
}
function divCeil(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 quotient = div(a, b);
uint256 remainder = a - quotient * b;
if (remainder > 0) {
return quotient + 1;
} else {
return quotient;
}
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SUB_ERROR");
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "ADD_ERROR");
return c;
}
function sqrt(uint256 x) internal pure returns (uint256 y) {
uint256 z = x / 2 + 1;
y = x;
while (z < y) {
y = z;
z = (x / z + z) / 2;
}
}
}
// File: contracts/lib/SafeERC20.sol
library SafeERC20 {
using SafeMath for uint256;
function safeTransfer(IERC20 token,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token,
address from,
address to,
uint256 value) internal {
_callOptionalReturn(token,
abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token,
address spender,
uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// we're implementing it ourselves.
// A Solidity high level call has three parts:
// 1. The target address is checked to verify it contains contract code
// 2. The call itself is made, and success asserted
// 3. The return value is decoded, which in turn checks the size of the returned data.
// solhint-disable-next-line max-line-length
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
// File: contracts/external/ECDSA.sol
library ECDSA {
function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
// Check the signature length
// - case 65: r,s,v signature (standard)
// - case 64: r,vs signature (cf https://eips.ethereum.org/EIPS/eip-2098) _Available since v4.1._
if (signature.length == 65) {
bytes32 r;
bytes32 s;
uint8 v;
// ecrecover takes the signature parameters, and the only way to get them
// currently is to use assembly.
assembly {
r := mload(add(signature, 0x20))
s := mload(add(signature, 0x40))
v := byte(0, mload(add(signature, 0x60)))
}
return recover(hash, v, r, s);
} else if (signature.length == 64) {
bytes32 r;
bytes32 vs;
// ecrecover takes the signature parameters, and the only way to get them
// currently is to use assembly.
assembly {
r := mload(add(signature, 0x20))
vs := mload(add(signature, 0x40))
}
return recover(hash, r, vs);
} else {
revert("ECDSA: invalid signature length");
}
}
function recover(bytes32 hash,
bytes32 r,
bytes32 vs) internal pure returns (address) {
bytes32 s;
uint8 v;
assembly {
s := and(vs, 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
v := add(shr(255, vs), 27)
}
return recover(hash, v, r, s);
}
function recover(bytes32 hash,
uint8 v,
bytes32 r,
bytes32 s) internal pure returns (address) {
// the valid range for s in (281): 0 < s < secp256k1n 2 + 1, and for v in (282): v {27, 28}. Most
//
// these malleable signatures as well.
require(uint256(s) <= 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0,
"ECDSA: invalid signature 's' value");
require(v == 27 || v == 28, "ECDSA: invalid signature 'v' value");
// If the signature is valid (and not malleable), return the signer address
address signer = ecrecover(hash, v, r, s);
require(signer != address(0), "ECDSA: invalid signature");
return signer;
}
function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
// 32 is the length in bytes of hash,
// enforced by the type signature above
return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
}
function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
}
}
// File: contracts/external/draft-EIP712.sol
abstract contract EIP712 {
// invalidate the cached domain separator if the chain id changes.
bytes32 private immutable _CACHED_DOMAIN_SEPARATOR;
uint256 private immutable _CACHED_CHAIN_ID;
bytes32 private immutable _HASHED_NAME;
bytes32 private immutable _HASHED_VERSION;
bytes32 private immutable _TYPE_HASH;
constructor(string memory name, string memory version) {
bytes32 hashedName = keccak256(bytes(name));
bytes32 hashedVersion = keccak256(bytes(version));
bytes32 typeHash = keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");
_HASHED_NAME = hashedName;
_HASHED_VERSION = hashedVersion;
_CACHED_CHAIN_ID = block.chainid;
_CACHED_DOMAIN_SEPARATOR = _buildDomainSeparator(typeHash, hashedName, hashedVersion);
_TYPE_HASH = typeHash;
}
function _domainSeparatorV4() internal view returns (bytes32) {
if (block.chainid == _CACHED_CHAIN_ID) {
return _CACHED_DOMAIN_SEPARATOR;
} else {
return _buildDomainSeparator(_TYPE_HASH, _HASHED_NAME, _HASHED_VERSION);
}
}
function _buildDomainSeparator(bytes32 typeHash,
bytes32 nameHash,
bytes32 versionHash) private view returns (bytes32) {
return keccak256(abi.encode(typeHash, nameHash, versionHash, block.chainid, address(this)));
}
function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) {
return ECDSA.toTypedDataHash(_domainSeparatorV4(), structHash);
}
}
// File: contracts/intf/IDODOApproveProxy.sol
interface IDODOApproveProxy {
function claimTokens(address token,address who,address dest,uint256 amount) external;
}
// File: contracts/lib/InitializableOwnable.sol
contract InitializableOwnable {
address public _OWNER_;
address public _NEW_OWNER_;
bool internal _INITIALIZED_;
// ============ Events ============
event OwnershipTransferPrepared(address indexed previousOwner, address indexed newOwner);
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
// ============ Modifiers ============
modifier notInitialized() {
require(!_INITIALIZED_, "DODO_INITIALIZED");
_;
}
modifier onlyOwner() {
require(msg.sender == _OWNER_, "NOT_OWNER");
_;
}
// ============ Functions ============
function initOwner(address newOwner) public notInitialized {
_INITIALIZED_ = true;
_OWNER_ = newOwner;
}
function transferOwnership(address newOwner) public onlyOwner {
emit OwnershipTransferPrepared(_OWNER_, newOwner);
_NEW_OWNER_ = newOwner;
}
function claimOwnership() public {
require(msg.sender == _NEW_OWNER_, "INVALID_CLAIM");
emit OwnershipTransferred(_OWNER_, _NEW_OWNER_);
_OWNER_ = _NEW_OWNER_;
_NEW_OWNER_ = address(0);
}
}
// File: contracts/lib/ArgumentsDecoder.sol
library ArgumentsDecoder {
function decodeSelector(bytes memory data) internal pure returns(bytes4 selector) {
assembly { // solhint-disable-line no-inline-assembly
selector := mload(add(data, 0x20))
}
}
function decodeAddress(bytes memory data, uint256 argumentIndex) internal pure returns(address account) {
assembly { // solhint-disable-line no-inline-assembly
account := mload(add(add(data, 0x24), mul(argumentIndex, 0x20)))
}
}
function decodeUint256(bytes memory data, uint256 argumentIndex) internal pure returns(uint256 value) {
assembly { // solhint-disable-line no-inline-assembly
value := mload(add(add(data, 0x24), mul(argumentIndex, 0x20)))
}
}
function patchAddress(bytes memory data, uint256 argumentIndex, address account) internal pure {
assembly { // solhint-disable-line no-inline-assembly
mstore(add(add(data, 0x24), mul(argumentIndex, 0x20)), account)
}
}
function patchUint256(bytes memory data, uint256 argumentIndex, uint256 value) internal pure {
assembly { // solhint-disable-line no-inline-assembly
mstore(add(add(data, 0x24), mul(argumentIndex, 0x20)), value)
}
}
}
// File: contracts/DODOLimitOrder.sol
contract DODOLimitOrder is EIP712("DODO Limit Order Protocol", "1"), InitializableOwnable{
using SafeMath for uint256;
using SafeERC20 for IERC20;
using ArgumentsDecoder for bytes;
struct Order {
address makerToken;
address takerToken;
uint256 makerAmount;
uint256 takerAmount;
address maker;
address taker;
uint256 expiration;
uint256 salt;
}
struct RfqOrder {
address makerToken;
address takerToken;
uint256 makerAmount;
uint256 takerAmount;
uint256 makerTokenFeeAmount;
uint256 takerFillAmount;
address maker;
address taker;
uint256 expiration;
uint256 slot;
}
bytes32 constant public ORDER_TYPEHASH = keccak256("Order(address makerToken,address takerToken,uint256 makerAmount,uint256 takerAmount,address maker,address taker,uint256 expiration,uint256 salt)");
bytes32 constant public RFQ_ORDER_TYPEHASH = keccak256("Order(address makerToken,address takerToken,uint256 makerAmount,uint256 takerAmount,uint256 makerTokenFeeAmount,uint256 takerFillAmount,address maker,address taker,uint256 expiration,uint256 slot)");
// ============ Storage ============
mapping(bytes32 => uint256) public _FILLED_TAKER_AMOUNT_; //limitOrder
mapping(address => mapping(uint256 => uint256)) public _RFQ_FILLED_TAKER_AMOUNT_; //RFQ
mapping (address => bool) public isWhiteListed;
mapping (address => bool) public isAdminListed;
address public _DODO_APPROVE_PROXY_;
address public _FEE_RECEIVER_;
// ============ Events =============
event LimitOrderFilled(address indexed maker, address indexed taker, bytes32 orderHash, uint256 curTakerFillAmount, uint256 curMakerFillAmount);
event RFQByUserFilled(address indexed maker, address indexed taker, bytes32 orderHash, uint256 curTakerFillAmount, uint256 curMakerFillAmount);
event RFQByPlatformFilled(address indexed maker, address indexed taker, bytes32 orderHash, uint256 curTakerFillAmount, uint256 curMakerFillAmount);
event AddWhileList(address addr);
event RemoveWhiteList(address addr);
event AddAdmin(address admin);
event RemoveAdmin(address admin);
event ChangeFeeReceiver(address newFeeReceiver);
function init(address owner, address dodoApproveProxy, address feeReciver) external {
initOwner(owner);
_DODO_APPROVE_PROXY_ = dodoApproveProxy;
_FEE_RECEIVER_ = feeReciver;
}
// ============= LimitOrder ===============
function fillLimitOrder(Order memory order,
bytes memory signature,
uint256 takerFillAmount,
uint256 thresholdTakerAmount,
bytes memory takerInteraction) public returns(uint256 curTakerFillAmount, uint256 curMakerFillAmount) {
bytes32 orderHash = _orderHash(order);
uint256 filledTakerAmount = _FILLED_TAKER_AMOUNT_[orderHash];
require(filledTakerAmount < order.takerAmount, "DLOP: ALREADY_FILLED");
require(order.taker == msg.sender, "DLOP:PRIVATE_ORDER");
require(ECDSA.recover(orderHash, signature) == order.maker, "DLOP:INVALID_SIGNATURE");
require(order.expiration > block.timestamp, "DLOP: EXPIRE_ORDER");
uint256 leftTakerAmount = order.takerAmount.sub(filledTakerAmount);
curTakerFillAmount = takerFillAmount < leftTakerAmount ? takerFillAmount:leftTakerAmount;
curMakerFillAmount = curTakerFillAmount.mul(order.makerAmount).div(order.takerAmount);
require(curTakerFillAmount > 0 && curMakerFillAmount > 0, "DLOP: ZERO_FILL_INVALID");
require(curTakerFillAmount >= thresholdTakerAmount, "DLOP: FILL_AMOUNT_NOT_ENOUGH");
_FILLED_TAKER_AMOUNT_[orderHash] = filledTakerAmount.add(curTakerFillAmount);
//Maker => Taker
IDODOApproveProxy(_DODO_APPROVE_PROXY_).claimTokens(order.makerToken, order.maker, msg.sender, curMakerFillAmount);
if(takerInteraction.length > 0) {
takerInteraction.patchUint256(0, curTakerFillAmount);
takerInteraction.patchUint256(1, curMakerFillAmount);
require(isWhiteListed[msg.sender], "DLOP: Not Whitelist Contract");
(bool success,) = msg.sender.call(takerInteraction);
require(success, "DLOP: TAKER_INTERACTIVE_FAILED");
}
//Taker => Maker
IERC20(order.takerToken).safeTransferFrom(msg.sender, order.maker, curTakerFillAmount);
emit LimitOrderFilled(order.maker, msg.sender, orderHash, curTakerFillAmount, curMakerFillAmount);
}
//================ RFQ ================
function matchingRFQByPlatform(RfqOrder memory order,
bytes memory makerSignature,
bytes memory takerSignature,
uint256 takerFillAmount,
uint256 thresholdMakerAmount,
uint256 makerTokenFeeAmount,
address taker) public returns(uint256 curTakerFillAmount, uint256 curMakerFillAmount) {
require(isAdminListed[msg.sender], "ACCESS_DENIED");
uint256 filledTakerAmount = _RFQ_FILLED_TAKER_AMOUNT_[order.maker][order.slot];
require(filledTakerAmount < order.takerAmount, "DLOP: ALREADY_FILLED");
bytes32 orderHashForMaker = _rfqOrderHash(order);
require(ECDSA.recover(orderHashForMaker, makerSignature) == order.maker, "DLOP:INVALID_MAKER_SIGNATURE");
require(order.taker == address(0), "DLOP:TAKER_INVALID");
order.taker = taker;
order.makerTokenFeeAmount = makerTokenFeeAmount;
order.takerFillAmount = takerFillAmount;
bytes32 orderHashForTaker = _rfqOrderHash(order);
require(ECDSA.recover(orderHashForTaker, takerSignature) == taker, "DLOP:INVALID_TAKER_SIGNATURE");
(curTakerFillAmount, curMakerFillAmount) = _settleRFQ(order,filledTakerAmount,takerFillAmount,thresholdMakerAmount,taker);
emit RFQByPlatformFilled(order.maker, taker, orderHashForMaker, curTakerFillAmount, curMakerFillAmount);
}
//============ Ownable ============
function addWhiteList (address contractAddr) public onlyOwner {
isWhiteListed[contractAddr] = true;
emit AddWhileList(contractAddr);
}
function removeWhiteList (address contractAddr) public onlyOwner {
isWhiteListed[contractAddr] = false;
emit RemoveWhiteList(contractAddr);
}
function addAdminList (address userAddr) external onlyOwner {
isAdminListed[userAddr] = true;
emit AddAdmin(userAddr);
}
function removeAdminList (address userAddr) external onlyOwner {
isAdminListed[userAddr] = false;
emit RemoveAdmin(userAddr);
}
function changeFeeReceiver (address newFeeReceiver) public onlyOwner {
_FEE_RECEIVER_ = newFeeReceiver;
emit ChangeFeeReceiver(newFeeReceiver);
}
//============ internal ============
function _settleRFQ(RfqOrder memory order,
uint256 filledTakerAmount,
uint256 takerFillAmount,
uint256 thresholdMakerAmount,
address taker) internal returns(uint256,uint256) {
require(order.expiration > block.timestamp, "DLOP: EXPIRE_ORDER");
uint256 leftTakerAmount = order.takerAmount.sub(filledTakerAmount);
require(takerFillAmount <= leftTakerAmount, "DLOP: RFQ_TAKER_AMOUNT_NOT_ENOUGH");
uint256 curTakerFillAmount = takerFillAmount;
uint256 curMakerFillAmount = curTakerFillAmount.mul(order.makerAmount).div(order.takerAmount);
require(curTakerFillAmount > 0 && curMakerFillAmount > 0, "DLOP: ZERO_FILL_INVALID");
require(curMakerFillAmount.sub(order.makerTokenFeeAmount) >= thresholdMakerAmount, "DLOP: FILL_AMOUNT_NOT_ENOUGH");
_RFQ_FILLED_TAKER_AMOUNT_[order.maker][order.slot] = filledTakerAmount.add(curTakerFillAmount);
if(order.makerTokenFeeAmount > 0) {
IDODOApproveProxy(_DODO_APPROVE_PROXY_).claimTokens(order.makerToken, order.maker, _FEE_RECEIVER_, order.makerTokenFeeAmount);
}
//Maker => Taker
IDODOApproveProxy(_DODO_APPROVE_PROXY_).claimTokens(order.makerToken, order.maker, taker, curMakerFillAmount.sub(order.makerTokenFeeAmount));
//Taker => Maker
IDODOApproveProxy(_DODO_APPROVE_PROXY_).claimTokens(order.takerToken, taker, order.maker, curTakerFillAmount);
return (curTakerFillAmount, curMakerFillAmount);
}
function _orderHash(Order memory order) private view returns(bytes32) {
return _hashTypedDataV4(keccak256(abi.encode(ORDER_TYPEHASH,
order.makerToken,
order.takerToken,
order.makerAmount,
order.takerAmount,
order.maker,
order.taker,
order.expiration,
order.salt)));
}
function _rfqOrderHash(RfqOrder memory order) private view returns(bytes32) {
return _hashTypedDataV4(keccak256(abi.encode(RFQ_ORDER_TYPEHASH,
order.makerToken,
order.takerToken,
order.makerAmount,
order.takerAmount,
order.makerTokenFeeAmount,
order.takerFillAmount,
order.maker,
order.taker,
order.expiration,
order.slot)));
}
}
| 48,321 | 1,033 |
5438585ebce8cfc7fd247d1ad6e92d8a123f778612043f5f7d66abecd5db22cb
| 20,155 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/1f/1f990588836E04A9b7AD0bC19A283Fe5A1D16909_MilkswapV2Pair.sol
| 5,193 | 19,117 |
pragma solidity =0.5.16;
interface IMilkswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function allPairs(uint) external view returns (address pair);
function allPairsLength() external view returns (uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
interface IMilkswapV2Pair {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint);
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
event Mint(address indexed sender, uint amount0, uint amount1);
event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
event Swap(address indexed sender,
uint amount0In,
uint amount1In,
uint amount0Out,
uint amount1Out,
address indexed to);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function price0CumulativeLast() external view returns (uint);
function price1CumulativeLast() external view returns (uint);
function kLast() external view returns (uint);
function mint(address to) external returns (uint liquidity);
function burn(address to) external returns (uint amount0, uint amount1);
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
interface IMilkswapV2ERC20 {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint);
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
}
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 transferFrom(address from, address to, uint value) external returns (bool);
}
interface IMilkswapV2Callee {
function uniswapV2Call(address sender, uint amount0, uint amount1, bytes calldata data) external;
}
contract MilkswapV2ERC20 is IMilkswapV2ERC20 {
using SafeMath for uint;
string public constant name = 'Milkswap LP';
string public constant symbol = 'Milk-LP';
uint8 public constant decimals = 18;
uint public totalSupply;
mapping(address => uint) public balanceOf;
mapping(address => mapping(address => uint)) public allowance;
bytes32 public DOMAIN_SEPARATOR;
// keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
bytes32 public constant PERMIT_TYPEHASH = 0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;
mapping(address => uint) public nonces;
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
constructor() public {
uint chainId;
assembly {
chainId := chainid
}
DOMAIN_SEPARATOR = keccak256(abi.encode(keccak256('EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)'),
keccak256(bytes(name)),
keccak256(bytes('1')),
chainId,
address(this)));
}
function _mint(address to, uint value) internal {
totalSupply = totalSupply.add(value);
balanceOf[to] = balanceOf[to].add(value);
emit Transfer(address(0), to, value);
}
function _burn(address from, uint value) internal {
balanceOf[from] = balanceOf[from].sub(value);
totalSupply = totalSupply.sub(value);
emit Transfer(from, address(0), value);
}
function _approve(address owner, address spender, uint value) private {
allowance[owner][spender] = value;
emit Approval(owner, spender, value);
}
function _transfer(address from, address to, uint value) private {
balanceOf[from] = balanceOf[from].sub(value);
balanceOf[to] = balanceOf[to].add(value);
emit Transfer(from, to, value);
}
function approve(address spender, uint value) external returns (bool) {
_approve(msg.sender, spender, value);
return true;
}
function transfer(address to, uint value) external returns (bool) {
_transfer(msg.sender, to, value);
return true;
}
function transferFrom(address from, address to, uint value) external returns (bool) {
if (allowance[from][msg.sender] != uint(-1)) {
allowance[from][msg.sender] = allowance[from][msg.sender].sub(value);
}
_transfer(from, to, value);
return true;
}
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external {
require(deadline >= block.timestamp, 'MilkswapV2: EXPIRED');
bytes32 digest = keccak256(abi.encodePacked('\x19\x01',
DOMAIN_SEPARATOR,
keccak256(abi.encode(PERMIT_TYPEHASH, owner, spender, value, nonces[owner]++, deadline))));
address recoveredAddress = ecrecover(digest, v, r, s);
require(recoveredAddress != address(0) && recoveredAddress == owner, 'MilkswapV2: INVALID_SIGNATURE');
_approve(owner, spender, value);
}
}
contract MilkswapV2Pair is IMilkswapV2Pair, MilkswapV2ERC20 {
using SafeMath for uint;
using UQ112x112 for uint224;
uint public constant MINIMUM_LIQUIDITY = 10**3;
bytes4 private constant SELECTOR = bytes4(keccak256(bytes('transfer(address,uint256)')));
address public factory;
address public token0;
address public token1;
uint112 private reserve0; // uses single storage slot, accessible via getReserves
uint112 private reserve1; // uses single storage slot, accessible via getReserves
uint32 private blockTimestampLast; // uses single storage slot, accessible via getReserves
uint public price0CumulativeLast;
uint public price1CumulativeLast;
uint public kLast; // reserve0 * reserve1, as of immediately after the most recent liquidity event
uint private unlocked = 1;
modifier lock() {
require(unlocked == 1, 'MilkswapV2: LOCKED');
unlocked = 0;
_;
unlocked = 1;
}
function getReserves() public view returns (uint112 _reserve0, uint112 _reserve1, uint32 _blockTimestampLast) {
_reserve0 = reserve0;
_reserve1 = reserve1;
_blockTimestampLast = blockTimestampLast;
}
function _safeTransfer(address token, address to, uint value) private {
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(SELECTOR, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), 'MilkswapV2: TRANSFER_FAILED');
}
event Mint(address indexed sender, uint amount0, uint amount1);
event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
event Swap(address indexed sender,
uint amount0In,
uint amount1In,
uint amount0Out,
uint amount1Out,
address indexed to);
event Sync(uint112 reserve0, uint112 reserve1);
constructor() public {
factory = msg.sender;
}
// called once by the factory at time of deployment
function initialize(address _token0, address _token1) external {
require(msg.sender == factory, 'MilkswapV2: FORBIDDEN'); // sufficient check
token0 = _token0;
token1 = _token1;
}
// update reserves and, on the first call per block, price accumulators
function _update(uint balance0, uint balance1, uint112 _reserve0, uint112 _reserve1) private {
require(balance0 <= uint112(-1) && balance1 <= uint112(-1), 'MilkswapV2: OVERFLOW');
uint32 blockTimestamp = uint32(block.timestamp % 2**32);
uint32 timeElapsed = blockTimestamp - blockTimestampLast; // overflow is desired
if (timeElapsed > 0 && _reserve0 != 0 && _reserve1 != 0) {
// * never overflows, and + overflow is desired
price0CumulativeLast += uint(UQ112x112.encode(_reserve1).uqdiv(_reserve0)) * timeElapsed;
price1CumulativeLast += uint(UQ112x112.encode(_reserve0).uqdiv(_reserve1)) * timeElapsed;
}
reserve0 = uint112(balance0);
reserve1 = uint112(balance1);
blockTimestampLast = blockTimestamp;
emit Sync(reserve0, reserve1);
}
// if fee is on, mint liquidity equivalent to 1/6th of the growth in sqrt(k)
function _mintFee(uint112 _reserve0, uint112 _reserve1) private returns (bool feeOn) {
address feeTo = IMilkswapV2Factory(factory).feeTo();
feeOn = feeTo != address(0);
uint _kLast = kLast; // gas savings
if (feeOn) {
if (_kLast != 0) {
uint rootK = Math.sqrt(uint(_reserve0).mul(_reserve1));
uint rootKLast = Math.sqrt(_kLast);
if (rootK > rootKLast) {
uint numerator = totalSupply.mul(rootK.sub(rootKLast));
uint denominator = rootK.mul(5).add(rootKLast);
uint liquidity = numerator / denominator;
if (liquidity > 0) _mint(feeTo, liquidity);
}
}
} else if (_kLast != 0) {
kLast = 0;
}
}
// this low-level function should be called from a contract which performs important safety checks
function mint(address to) external lock returns (uint liquidity) {
(uint112 _reserve0, uint112 _reserve1,) = getReserves(); // gas savings
uint balance0 = IERC20(token0).balanceOf(address(this));
uint balance1 = IERC20(token1).balanceOf(address(this));
uint amount0 = balance0.sub(_reserve0);
uint amount1 = balance1.sub(_reserve1);
bool feeOn = _mintFee(_reserve0, _reserve1);
uint _totalSupply = totalSupply; // gas savings, must be defined here since totalSupply can update in _mintFee
if (_totalSupply == 0) {
liquidity = Math.sqrt(amount0.mul(amount1)).sub(MINIMUM_LIQUIDITY);
_mint(address(0), MINIMUM_LIQUIDITY); // permanently lock the first MINIMUM_LIQUIDITY tokens
} else {
liquidity = Math.min(amount0.mul(_totalSupply) / _reserve0, amount1.mul(_totalSupply) / _reserve1);
}
require(liquidity > 0, 'MilkswapV2: INSUFFICIENT_LIQUIDITY_MINTED');
_mint(to, liquidity);
_update(balance0, balance1, _reserve0, _reserve1);
if (feeOn) kLast = uint(reserve0).mul(reserve1); // reserve0 and reserve1 are up-to-date
emit Mint(msg.sender, amount0, amount1);
}
// this low-level function should be called from a contract which performs important safety checks
function burn(address to) external lock returns (uint amount0, uint amount1) {
(uint112 _reserve0, uint112 _reserve1,) = getReserves(); // gas savings
address _token0 = token0; // gas savings
address _token1 = token1; // gas savings
uint balance0 = IERC20(_token0).balanceOf(address(this));
uint balance1 = IERC20(_token1).balanceOf(address(this));
uint liquidity = balanceOf[address(this)];
bool feeOn = _mintFee(_reserve0, _reserve1);
uint _totalSupply = totalSupply; // gas savings, must be defined here since totalSupply can update in _mintFee
amount0 = liquidity.mul(balance0) / _totalSupply; // using balances ensures pro-rata distribution
amount1 = liquidity.mul(balance1) / _totalSupply; // using balances ensures pro-rata distribution
require(amount0 > 0 && amount1 > 0, 'MilkswapV2: INSUFFICIENT_LIQUIDITY_BURNED');
_burn(address(this), liquidity);
_safeTransfer(_token0, to, amount0);
_safeTransfer(_token1, to, amount1);
balance0 = IERC20(_token0).balanceOf(address(this));
balance1 = IERC20(_token1).balanceOf(address(this));
_update(balance0, balance1, _reserve0, _reserve1);
if (feeOn) kLast = uint(reserve0).mul(reserve1); // reserve0 and reserve1 are up-to-date
emit Burn(msg.sender, amount0, amount1, to);
}
// this low-level function should be called from a contract which performs important safety checks
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external lock {
require(amount0Out > 0 || amount1Out > 0, 'MilkswapV2: INSUFFICIENT_OUTPUT_AMOUNT');
(uint112 _reserve0, uint112 _reserve1,) = getReserves(); // gas savings
require(amount0Out < _reserve0 && amount1Out < _reserve1, 'MilkswapV2: INSUFFICIENT_LIQUIDITY');
uint balance0;
uint balance1;
{ // scope for _token{0,1}, avoids stack too deep errors
address _token0 = token0;
address _token1 = token1;
require(to != _token0 && to != _token1, 'MilkswapV2: INVALID_TO');
if (amount0Out > 0) _safeTransfer(_token0, to, amount0Out); // optimistically transfer tokens
if (amount1Out > 0) _safeTransfer(_token1, to, amount1Out); // optimistically transfer tokens
if (data.length > 0) IMilkswapV2Callee(to).uniswapV2Call(msg.sender, amount0Out, amount1Out, data);
balance0 = IERC20(_token0).balanceOf(address(this));
balance1 = IERC20(_token1).balanceOf(address(this));
}
uint amount0In = balance0 > _reserve0 - amount0Out ? balance0 - (_reserve0 - amount0Out) : 0;
uint amount1In = balance1 > _reserve1 - amount1Out ? balance1 - (_reserve1 - amount1Out) : 0;
require(amount0In > 0 || amount1In > 0, 'MilkswapV2: INSUFFICIENT_INPUT_AMOUNT');
{ // scope for reserve{0,1}Adjusted, avoids stack too deep errors
uint balance0Adjusted = balance0.mul(1000).sub(amount0In.mul(3));
uint balance1Adjusted = balance1.mul(1000).sub(amount1In.mul(3));
require(balance0Adjusted.mul(balance1Adjusted) >= uint(_reserve0).mul(_reserve1).mul(1000**2), 'MilkswapV2: K');
}
_update(balance0, balance1, _reserve0, _reserve1);
emit Swap(msg.sender, amount0In, amount1In, amount0Out, amount1Out, to);
}
// force balances to match reserves
function skim(address to) external lock {
address _token0 = token0; // gas savings
address _token1 = token1; // gas savings
_safeTransfer(_token0, to, IERC20(_token0).balanceOf(address(this)).sub(reserve0));
_safeTransfer(_token1, to, IERC20(_token1).balanceOf(address(this)).sub(reserve1));
}
// force reserves to match balances
function sync() external lock {
_update(IERC20(token0).balanceOf(address(this)), IERC20(token1).balanceOf(address(this)), reserve0, reserve1);
}
}
library SafeMath {
function add(uint x, uint y) internal pure returns (uint z) {
require((z = x + y) >= x, 'ds-math-add-overflow');
}
function sub(uint x, uint y) internal pure returns (uint z) {
require((z = x - y) <= x, 'ds-math-sub-underflow');
}
function mul(uint x, uint y) internal pure returns (uint z) {
require(y == 0 || (z = x * y) / y == x, 'ds-math-mul-overflow');
}
}
// a library for performing various math operations
library Math {
function min(uint x, uint y) internal pure returns (uint z) {
z = x < y ? x : y;
}
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;
}
}
}
// range: [0, 2**112 - 1]
// resolution: 1 / 2**112
library UQ112x112 {
uint224 constant Q112 = 2**112;
// encode a uint112 as a UQ112x112
function encode(uint112 y) internal pure returns (uint224 z) {
z = uint224(y) * Q112; // never overflows
}
// divide a UQ112x112 by a uint112, returning a UQ112x112
function uqdiv(uint224 x, uint112 y) internal pure returns (uint224 z) {
z = x / uint224(y);
}
}
| 27,141 | 1,034 |
50f569c49f80e814ab25c16730fa9a12c2ad40132e860961eeb590b985dd18c2
| 30,401 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/b9/B9D8a2207646F51D249285534C3a034A2CB58d50_wSTAKEDETHD.sol
| 3,219 | 12,586 |
// SPDX-License-Identifier: MIT
pragma solidity 0.7.5;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract ERC20 is IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol) {
_name = name;
_symbol = symbol;
_decimals = 18;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(msg.sender, 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) {
_approve(msg.sender, spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IMEMO {
function index() external view returns (uint);
}
contract wSTAKEDETHD is ERC20 {
using SafeERC20 for ERC20;
using Address for address;
using SafeMath for uint;
address public immutable MEMO;
constructor(address _MEMO) ERC20('Wrapped STAKEDETHD', 'wSETHD') {
require(_MEMO != address(0));
MEMO = _MEMO;
}
function wrap(uint _amount) external returns (uint) {
IERC20(MEMO).transferFrom(msg.sender, address(this), _amount);
uint value = MEMOTowMEMO(_amount);
_mint(msg.sender, value);
return value;
}
function unwrap(uint _amount) external returns (uint) {
_burn(msg.sender, _amount);
uint value = wMEMOToMEMO(_amount);
IERC20(MEMO).transfer(msg.sender, value);
return value;
}
function wMEMOToMEMO(uint _amount) public view returns (uint) {
return _amount.mul(IMEMO(MEMO).index()).div(10 ** decimals());
}
function MEMOTowMEMO(uint _amount) public view returns (uint) {
return _amount.mul(10 ** decimals()).div(IMEMO(MEMO).index());
}
}
| 71,921 | 1,035 |
8dc2ca9e18104b9309fed8f19c3a7fb28db29cc742bee9c1fbfb52c4f0c8bf56
| 29,028 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/65/654f213c3000b5ac9684c71615df355379f3e824_TimeStaking.sol
| 4,534 | 18,112 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function add32(uint32 a, uint32 b) internal pure returns (uint32) {
uint32 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
}
interface IERC20 {
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender)
.sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IOwnable {
function manager() external view returns (address);
function renounceManagement() external;
function pushManagement(address newOwner_) external;
function pullManagement() external;
}
contract Ownable is IOwnable {
address internal _owner;
address internal _newOwner;
event OwnershipPushed(address indexed previousOwner, address indexed newOwner);
event OwnershipPulled(address indexed previousOwner, address indexed newOwner);
constructor () {
_owner = msg.sender;
emit OwnershipPushed(address(0), _owner);
}
function manager() public view override returns (address) {
return _owner;
}
modifier onlyManager() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceManagement() public virtual override onlyManager() {
emit OwnershipPushed(_owner, address(0));
_owner = address(0);
}
function pushManagement(address newOwner_) public virtual override onlyManager() {
require(newOwner_ != address(0), "Ownable: new owner is the zero address");
emit OwnershipPushed(_owner, newOwner_);
_newOwner = newOwner_;
}
function pullManagement() public virtual override {
require(msg.sender == _newOwner, "Ownable: must be new owner to pull");
emit OwnershipPulled(_owner, _newOwner);
_owner = _newOwner;
}
}
interface IMemo {
function rebase(uint256 ohmProfit_, uint epoch_) external returns (uint256);
function circulatingSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function gonsForBalance(uint amount) external view returns (uint);
function balanceForGons(uint gons) external view returns (uint);
function index() external view returns (uint);
}
interface IWarmup {
function retrieve(address staker_, uint amount_) external;
}
interface IDistributor {
function distribute() external returns (bool);
}
contract TimeStaking is Ownable {
using SafeMath for uint256;
using SafeMath for uint32;
using SafeERC20 for IERC20;
address public immutable Time;
address public immutable Memories;
struct Epoch {
uint number;
uint distribute;
uint32 length;
uint32 endTime;
}
Epoch public epoch;
address public distributor;
address public locker;
uint public totalBonus;
address public warmupContract;
uint public warmupPeriod;
uint public unstakeMaxAmount;
uint32 public unstakeMaxTimer;
constructor (address _Time,
address _Memories,
uint32 _epochLength,
uint _firstEpochNumber,
uint32 _firstEpochTime) {
require(_Time != address(0));
Time = _Time;
require(_Memories != address(0));
Memories = _Memories;
epoch = Epoch({
length: _epochLength,
number: _firstEpochNumber,
endTime: _firstEpochTime,
distribute: 0
});
unstakeMaxAmount = 99999000000000;
unstakeMaxTimer = 86400;
}
struct Claim {
uint deposit;
uint gons;
uint expiry;
bool lock; // prevents malicious delays
}
mapping(address => Claim) public warmupInfo;
struct UnstakeData {
uint unstakedAmount;
uint lastTimeUnstaked;
}
mapping(address => UnstakeData) public unstakeUsers;
function stake(uint _amount, address _recipient) external returns (bool) {
rebase();
IERC20(Time).safeTransferFrom(msg.sender, address(this), _amount);
Claim memory info = warmupInfo[ _recipient ];
require(!info.lock, "Deposits for account are locked");
warmupInfo[ _recipient ] = Claim ({
deposit: info.deposit.add(_amount),
gons: info.gons.add(IMemo(Memories).gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
IERC20(Memories).safeTransfer(warmupContract, _amount);
return true;
}
function claim (address _recipient) public {
Claim memory info = warmupInfo[ _recipient ];
if (epoch.number >= info.expiry && info.expiry != 0) {
delete warmupInfo[ _recipient ];
IWarmup(warmupContract).retrieve(_recipient, IMemo(Memories).balanceForGons(info.gons));
}
}
function forfeit() external {
Claim memory info = warmupInfo[ msg.sender ];
delete warmupInfo[ msg.sender ];
IWarmup(warmupContract).retrieve(address(this), IMemo(Memories).balanceForGons(info.gons));
IERC20(Time).safeTransfer(msg.sender, info.deposit);
}
function toggleDepositLock() external {
warmupInfo[ msg.sender ].lock = !warmupInfo[ msg.sender ].lock;
}
function unstake(uint _amount, bool _trigger) external {
if (_trigger) {
rebase();
}
require (_amount < getMaximumUnstakable(msg.sender), "Maximum unstakable is less");
UnstakeData memory info = unstakeUsers [ msg.sender ];
unstakeUsers[ msg.sender ] = UnstakeData ({
unstakedAmount: info.unstakedAmount.add(_amount),
lastTimeUnstaked: block.timestamp
});
IERC20(Memories).safeTransferFrom(msg.sender, address(this), _amount);
IERC20(Time).safeTransfer(msg.sender, _amount);
}
function index() public view returns (uint) {
return IMemo(Memories).index();
}
function rebase() public {
if(epoch.endTime <= uint32(block.timestamp)) {
IMemo(Memories).rebase(epoch.distribute, epoch.number);
epoch.endTime = epoch.endTime.add32(epoch.length);
epoch.number++;
if (distributor != address(0)) {
IDistributor(distributor).distribute();
}
uint balance = contractBalance();
uint staked = IMemo(Memories).circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
}
}
function contractBalance() public view returns (uint) {
return IERC20(Time).balanceOf(address(this)).add(totalBonus);
}
function giveLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.add(_amount);
IERC20(Memories).safeTransfer(locker, _amount);
}
function returnLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.sub(_amount);
IERC20(Memories).safeTransferFrom(locker, address(this), _amount);
}
enum CONTRACTS { DISTRIBUTOR, WARMUP, LOCKER }
function setContract(CONTRACTS _contract, address _address) external onlyManager() {
if(_contract == CONTRACTS.DISTRIBUTOR) { // 0
distributor = _address;
} else if (_contract == CONTRACTS.WARMUP) { // 1
require(warmupContract == address(0), "Warmup cannot be set more than once");
warmupContract = _address;
} else if (_contract == CONTRACTS.LOCKER) { // 2
require(locker == address(0), "Locker cannot be set more than once");
locker = _address;
}
}
function setWarmup(uint _warmupPeriod) external onlyManager() {
warmupPeriod = _warmupPeriod;
}
function setUnstakeMaxAmount(uint _unstakeMaxAmount) external onlyManager() {
unstakeMaxAmount = _unstakeMaxAmount;
}
function setUnstakeMaxTimer(uint32 _unstakeMaxTimer) external onlyManager() {
unstakeMaxTimer = _unstakeMaxTimer;
}
function getMaximumUnstakable(address _address) public view returns (uint) {
UnstakeData memory info = unstakeUsers[ _address ];
if (block.timestamp < info.lastTimeUnstaked + unstakeMaxTimer)
{
return unstakeMaxAmount - info.unstakedAmount;
} else {
return unstakeMaxAmount;
}
}
}
| 128,668 | 1,036 |
3029852b83912846414f0377996af4c34caa3bd5ab6ae1c061b1c7cd660bc4af
| 13,225 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/6f/6fF83eb56d9Df4007eb3593757351F2FB0011F19_BlockERC20Token.sol
| 2,924 | 10,803 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library LowGasSafeMath {
/// @notice Returns x + y, reverts if sum overflows uint256
/// @param x The augend
/// @param y The addend
/// @return z The sum of x and y
function add(uint256 x, uint256 y) internal pure returns (uint256 z) {
require((z = x + y) >= x);
}
/// @notice Returns x - y, reverts if underflows
/// @param x The minuend
/// @param y The subtrahend
/// @return z The difference of x and y
function sub(uint256 x, uint256 y) internal pure returns (uint256 z) {
require((z = x - y) <= x);
}
/// @notice Returns x * y, reverts if overflows
/// @param x The multiplicand
/// @param y The multiplier
/// @return z The product of x and y
function mul(uint256 x, uint256 y) internal pure returns (uint256 z) {
require(x == 0 || (z = x * y) / x == y);
}
/// @notice Returns x + y, reverts if overflows or underflows
/// @param x The augend
/// @param y The addend
/// @return z The sum of x and y
function add(int256 x, int256 y) internal pure returns (int256 z) {
require((z = x + y) >= x == (y >= 0));
}
/// @notice Returns x - y, reverts if overflows or underflows
/// @param x The minuend
/// @param y The subtrahend
/// @return z The difference of x and y
function sub(int256 x, int256 y) internal pure returns (int256 z) {
require((z = x - y) <= x == (y >= 0));
}
}
abstract contract ERC20 is IERC20 {
using LowGasSafeMath for uint256;
// Present in ERC777
mapping (address => uint256) internal _balances;
// Present in ERC777
mapping (address => mapping (address => uint256)) internal _allowances;
// Present in ERC777
uint256 internal _totalSupply;
// Present in ERC777
string internal _name;
// Present in ERC777
string internal _symbol;
// Present in ERC777
uint8 internal _decimals;
constructor (string memory name_, string memory symbol_, uint8 decimals_) {
_name = name_;
_symbol = symbol_;
_decimals = decimals_;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
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(msg.sender, 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) {
_approve(msg.sender, spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender]
.sub(amount));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender]
.sub(subtractedValue));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount);
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account_, uint256 amount_) internal virtual {
require(account_ != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(this), account_, amount_);
_totalSupply = _totalSupply.add(amount_);
_balances[account_] = _balances[account_].add(amount_);
emit Transfer(address(0), account_, amount_);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount);
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _beforeTokenTransfer(address from_, address to_, uint256 amount_) internal virtual { }
}
library Counters {
using LowGasSafeMath for uint256;
struct Counter {
uint256 _value; // default: 0
}
function current(Counter storage counter) internal view returns (uint256) {
return counter._value;
}
function increment(Counter storage counter) internal {
counter._value += 1;
}
function decrement(Counter storage counter) internal {
counter._value = counter._value.sub(1);
}
}
interface IERC2612Permit {
function permit(address owner,
address spender,
uint256 amount,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) external;
function nonces(address owner) external view returns (uint256);
}
abstract contract ERC20Permit is ERC20, IERC2612Permit {
using Counters for Counters.Counter;
mapping(address => Counters.Counter) private _nonces;
// keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
bytes32 public constant PERMIT_TYPEHASH = 0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;
bytes32 public DOMAIN_SEPARATOR;
constructor() {
uint256 chainID;
assembly {
chainID := chainid()
}
DOMAIN_SEPARATOR = keccak256(abi.encode(keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
keccak256(bytes(name())),
keccak256(bytes("1")), // Version
chainID,
address(this)));
}
function permit(address owner,
address spender,
uint256 amount,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) public virtual override {
require(block.timestamp <= deadline, "Permit: expired deadline");
bytes32 hashStruct =
keccak256(abi.encode(PERMIT_TYPEHASH, owner, spender, amount, _nonces[owner].current(), deadline));
bytes32 _hash = keccak256(abi.encodePacked(uint16(0x1901), DOMAIN_SEPARATOR, hashStruct));
address signer = ecrecover(_hash, v, r, s);
require(signer != address(0) && signer == owner, "ERC20Permit: Invalid signature");
_nonces[owner].increment();
_approve(owner, spender, amount);
}
function nonces(address owner) public view override returns (uint256) {
return _nonces[owner].current();
}
}
interface IOwnable {
function owner() external view returns (address);
function renounceOwnership() external;
function transferOwnership(address newOwner_) external;
}
contract Ownable is IOwnable {
address internal _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view override returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual override onlyOwner() {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner_) public virtual override onlyOwner() {
require(newOwner_ != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner_);
_owner = newOwner_;
}
}
contract VaultOwned is Ownable {
address internal _vault;
event VaultTransferred(address indexed newVault);
function setVault(address vault_) external onlyOwner() {
require(vault_ != address(0), "IA0");
_vault = vault_;
emit VaultTransferred(_vault);
}
function vault() public view returns (address) {
return _vault;
}
modifier onlyVault() {
require(_vault == msg.sender, "VaultOwned: caller is not the Vault");
_;
}
}
contract BlockERC20Token is ERC20Permit, VaultOwned {
using LowGasSafeMath for uint256;
constructor() ERC20("Block", "$BLOCK", 9) {
_mint(msg.sender, (10 ** 11) * (10 ** uint256(decimals())));
}
function mint(address account_, uint256 amount_) external onlyVault() {
_mint(account_, amount_);
}
function burn(uint256 amount) external virtual {
_burn(msg.sender, amount);
}
function burnFrom(address account_, uint256 amount_) external virtual {
_burnFrom(account_, amount_);
}
function _burnFrom(address account_, uint256 amount_) internal virtual {
uint256 decreasedAllowance_ =
allowance(account_, msg.sender).sub(amount_);
_approve(account_, msg.sender, decreasedAllowance_);
_burn(account_, amount_);
}
}
| 120,175 | 1,037 |
a7bd27f547302f4efa0d4f4b5039e868e5a9f6d29fe407f17d518fced25bb82b
| 14,655 |
.sol
|
Solidity
| false |
492670100
|
Messi-Q/DeFi-Protocol
|
ce2661ef6bbb7810544bb619b6687e7228df8491
|
Portfolio Management/FlashLoan Attack/Pump and Arbitrage Attack/defisaver/MCDCreateProxyActions.sol
| 3,928 | 13,682 |
pragma solidity ^0.6.0;
abstract contract GemLike {
function approve(address, uint256) public virtual;
function transfer(address, uint256) public virtual;
function transferFrom(address, address, uint256) public virtual;
function deposit() public virtual payable;
function withdraw(uint256) public virtual;
}
abstract contract ManagerLike {
function cdpCan(address, uint256, address) public virtual view returns (uint256);
function ilks(uint256) public virtual view returns (bytes32);
function owns(uint256) public virtual view returns (address);
function urns(uint256) public virtual view returns (address);
function vat() public virtual view returns (address);
function open(bytes32, address) public virtual returns (uint256);
function give(uint256, address) public virtual;
function cdpAllow(uint256, address, uint256) public virtual;
function urnAllow(address, uint256) public virtual;
function frob(uint256, int256, int256) public virtual;
function flux(uint256, address, uint256) public virtual;
function move(uint256, address, uint256) public virtual;
function exit(address, uint256, address, uint256) public virtual;
function quit(uint256, address) public virtual;
function enter(address, uint256) public virtual;
function shift(uint256, uint256) public virtual;
}
abstract contract VatLike {
function can(address, address) public virtual view returns (uint256);
function ilks(bytes32) public virtual view returns (uint256, uint256, uint256, uint256, uint256);
function dai(address) public virtual view returns (uint256);
function urns(bytes32, address) public virtual view returns (uint256, uint256);
function frob(bytes32, address, address, address, int256, int256) public virtual;
function hope(address) public virtual;
function move(address, address, uint256) public virtual;
}
abstract contract GemJoinLike {
function dec() public virtual returns (uint256);
function gem() public virtual returns (GemLike);
function join(address, uint256) public virtual payable;
function exit(address, uint256) public virtual;
}
abstract contract GNTJoinLike {
function bags(address) public virtual view returns (address);
function make(address) public virtual returns (address);
}
abstract contract DaiJoinLike {
function vat() public virtual returns (VatLike);
function dai() public virtual returns (GemLike);
function join(address, uint256) public virtual payable;
function exit(address, uint256) public virtual;
}
abstract contract HopeLike {
function hope(address) public virtual;
function nope(address) public virtual;
}
abstract contract ProxyRegistryInterface {
function build(address) public virtual returns (address);
}
abstract contract EndLike {
function fix(bytes32) public virtual view returns (uint256);
function cash(bytes32, uint256) public virtual;
function free(bytes32) public virtual;
function pack(uint256) public virtual;
function skim(bytes32, address) public virtual;
}
abstract contract JugLike {
function drip(bytes32) public virtual returns (uint256);
}
abstract contract PotLike {
function pie(address) public virtual view returns (uint256);
function drip() public virtual returns (uint256);
function join(uint256) public virtual;
function exit(uint256) public virtual;
}
abstract contract ProxyRegistryLike {
function proxies(address) public virtual view returns (address);
function build(address) public virtual returns (address);
}
abstract contract ProxyLike {
function owner() public virtual view returns (address);
}
contract Common {
uint256 constant RAY = 10**27;
// Internal functions
function mul(uint256 x, uint256 y) internal pure returns (uint256 z) {
require(y == 0 || (z = x * y) / y == x, "mul-overflow");
}
// Public functions
// solhint-disable-next-line func-name-mixedcase
function daiJoin_join(address apt, address urn, uint256 wad) public {
// Gets DAI from the user's wallet
DaiJoinLike(apt).dai().transferFrom(msg.sender, address(this), wad);
// Approves adapter to take the DAI amount
DaiJoinLike(apt).dai().approve(apt, wad);
// Joins DAI into the vat
DaiJoinLike(apt).join(urn, wad);
}
}
contract MCDCreateProxyActions is Common {
// Internal functions
function sub(uint256 x, uint256 y) internal pure returns (uint256 z) {
require((z = x - y) <= x, "sub-overflow");
}
function toInt(uint256 x) internal pure returns (int256 y) {
y = int256(x);
require(y >= 0, "int-overflow");
}
function toRad(uint256 wad) internal pure returns (uint256 rad) {
rad = mul(wad, 10**27);
}
function convertTo18(address gemJoin, uint256 amt) internal returns (uint256 wad) {
// Adapters will automatically handle the difference of precision
wad = mul(amt, 10**(18 - GemJoinLike(gemJoin).dec()));
}
function _getDrawDart(address vat, address jug, address urn, bytes32 ilk, uint256 wad)
internal
returns (int256 dart)
{
// Updates stability fee rate
uint256 rate = JugLike(jug).drip(ilk);
// Gets DAI balance of the urn in the vat
uint256 dai = VatLike(vat).dai(urn);
// If there was already enough DAI in the vat balance, just exits it without adding more debt
if (dai < mul(wad, RAY)) {
dart = toInt(sub(mul(wad, RAY), dai) / rate);
dart = mul(uint256(dart), rate) < mul(wad, RAY) ? dart + 1 : dart;
}
}
function _getWipeDart(address vat, uint256 dai, address urn, bytes32 ilk)
internal
view
returns (int256 dart)
{
// Gets actual rate from the vat
(, uint256 rate, , ,) = VatLike(vat).ilks(ilk);
// Gets actual art value of the urn
(, uint256 art) = VatLike(vat).urns(ilk, urn);
// Uses the whole dai balance in the vat to reduce the debt
dart = toInt(dai / rate);
// Checks the calculated dart is not higher than urn.art (total debt), otherwise uses its value
dart = uint256(dart) <= art ? -dart : -toInt(art);
}
function _getWipeAllWad(address vat, address usr, address urn, bytes32 ilk)
internal
view
returns (uint256 wad)
{
// Gets actual rate from the vat
(, uint256 rate, , ,) = VatLike(vat).ilks(ilk);
// Gets actual art value of the urn
(, uint256 art) = VatLike(vat).urns(ilk, urn);
// Gets actual dai amount in the urn
uint256 dai = VatLike(vat).dai(usr);
uint256 rad = sub(mul(art, rate), dai);
wad = rad / RAY;
// If the rad precision has some dust, it will need to request for 1 extra wad wei
wad = mul(wad, RAY) < rad ? wad + 1 : wad;
}
// Public functions
function transfer(address gem, address dst, uint256 wad) public {
GemLike(gem).transfer(dst, wad);
}
// solhint-disable-next-line func-name-mixedcase
function ethJoin_join(address apt, address urn) public payable {
// Wraps ETH in WETH
GemJoinLike(apt).gem().deposit{value: msg.value}();
// Approves adapter to take the WETH amount
GemJoinLike(apt).gem().approve(address(apt), msg.value);
// Joins WETH collateral into the vat
GemJoinLike(apt).join(urn, msg.value);
}
// solhint-disable-next-line func-name-mixedcase
function gemJoin_join(address apt, address urn, uint256 wad, bool transferFrom) public {
// Only executes for tokens that have approval/transferFrom implementation
if (transferFrom) {
// Gets token from the user's wallet
GemJoinLike(apt).gem().transferFrom(msg.sender, address(this), wad);
// Approves adapter to take the token amount
GemJoinLike(apt).gem().approve(apt, 0);
GemJoinLike(apt).gem().approve(apt, wad);
}
// Joins token collateral into the vat
GemJoinLike(apt).join(urn, wad);
}
function hope(address obj, address usr) public {
HopeLike(obj).hope(usr);
}
function nope(address obj, address usr) public {
HopeLike(obj).nope(usr);
}
function open(address manager, bytes32 ilk, address usr) public returns (uint256 cdp) {
cdp = ManagerLike(manager).open(ilk, usr);
}
function give(address manager, uint256 cdp, address usr) public {
ManagerLike(manager).give(cdp, usr);
}
function move(address manager, uint256 cdp, address dst, uint256 rad) public {
ManagerLike(manager).move(cdp, dst, rad);
}
function frob(address manager, uint256 cdp, int256 dink, int256 dart) public {
ManagerLike(manager).frob(cdp, dink, dart);
}
function lockETH(address manager, address ethJoin, uint256 cdp) public payable {
// Receives ETH amount, converts it to WETH and joins it into the vat
ethJoin_join(ethJoin, address(this));
// Locks WETH amount into the CDP
VatLike(ManagerLike(manager).vat()).frob(ManagerLike(manager).ilks(cdp),
ManagerLike(manager).urns(cdp),
address(this),
address(this),
toInt(msg.value),
0);
}
function lockGem(address manager, address gemJoin, uint256 cdp, uint256 wad, bool transferFrom)
public
{
// Takes token amount from user's wallet and joins into the vat
gemJoin_join(gemJoin, address(this), wad, transferFrom);
// Locks token amount into the CDP
VatLike(ManagerLike(manager).vat()).frob(ManagerLike(manager).ilks(cdp),
ManagerLike(manager).urns(cdp),
address(this),
address(this),
toInt(convertTo18(gemJoin, wad)),
0);
}
function draw(address manager, address jug, address daiJoin, uint256 cdp, uint256 wad) public {
address urn = ManagerLike(manager).urns(cdp);
address vat = ManagerLike(manager).vat();
bytes32 ilk = ManagerLike(manager).ilks(cdp);
// Generates debt in the CDP
frob(manager, cdp, 0, _getDrawDart(vat, jug, urn, ilk, wad));
// Moves the DAI amount (balance in the vat in rad) to proxy's address
move(manager, cdp, address(this), toRad(wad));
// Allows adapter to access to proxy's DAI balance in the vat
if (VatLike(vat).can(address(this), address(daiJoin)) == 0) {
VatLike(vat).hope(daiJoin);
}
// Exits DAI to the user's wallet as a token
DaiJoinLike(daiJoin).exit(msg.sender, wad);
}
function lockETHAndDraw(address manager,
address jug,
address ethJoin,
address daiJoin,
uint256 cdp,
uint256 wadD) public payable {
address urn = ManagerLike(manager).urns(cdp);
address vat = ManagerLike(manager).vat();
bytes32 ilk = ManagerLike(manager).ilks(cdp);
// Receives ETH amount, converts it to WETH and joins it into the vat
ethJoin_join(ethJoin, urn);
// Locks WETH amount into the CDP and generates debt
frob(manager, cdp, toInt(msg.value), _getDrawDart(vat, jug, urn, ilk, wadD));
// Moves the DAI amount (balance in the vat in rad) to proxy's address
move(manager, cdp, address(this), toRad(wadD));
// Allows adapter to access to proxy's DAI balance in the vat
if (VatLike(vat).can(address(this), address(daiJoin)) == 0) {
VatLike(vat).hope(daiJoin);
}
// Exits DAI to the user's wallet as a token
DaiJoinLike(daiJoin).exit(msg.sender, wadD);
}
function openLockETHAndDraw(address manager,
address jug,
address ethJoin,
address daiJoin,
bytes32 ilk,
uint256 wadD,
address owner) public payable returns (uint256 cdp) {
cdp = open(manager, ilk, address(this));
lockETHAndDraw(manager, jug, ethJoin, daiJoin, cdp, wadD);
give(manager, cdp, owner);
}
function lockGemAndDraw(address manager,
address jug,
address gemJoin,
address daiJoin,
uint256 cdp,
uint256 wadC,
uint256 wadD,
bool transferFrom) public {
address urn = ManagerLike(manager).urns(cdp);
address vat = ManagerLike(manager).vat();
bytes32 ilk = ManagerLike(manager).ilks(cdp);
// Takes token amount from user's wallet and joins into the vat
gemJoin_join(gemJoin, urn, wadC, transferFrom);
// Locks token amount into the CDP and generates debt
frob(manager,
cdp,
toInt(convertTo18(gemJoin, wadC)),
_getDrawDart(vat, jug, urn, ilk, wadD));
// Moves the DAI amount (balance in the vat in rad) to proxy's address
move(manager, cdp, address(this), toRad(wadD));
// Allows adapter to access to proxy's DAI balance in the vat
if (VatLike(vat).can(address(this), address(daiJoin)) == 0) {
VatLike(vat).hope(daiJoin);
}
// Exits DAI to the user's wallet as a token
DaiJoinLike(daiJoin).exit(msg.sender, wadD);
}
function openLockGemAndDraw(address manager,
address jug,
address gemJoin,
address daiJoin,
bytes32 ilk,
uint256 wadC,
uint256 wadD,
bool transferFrom,
address owner) public returns (uint256 cdp) {
cdp = open(manager, ilk, address(this));
lockGemAndDraw(manager, jug, gemJoin, daiJoin, cdp, wadC, wadD, transferFrom);
give(manager, cdp, owner);
}
}
| 69,512 | 1,038 |
1dc40ac940e58b1a04463b5836f6ccdd43416f43c45d2296eb9ff408c58c9591
| 16,568 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/78/78fbc3d79ae71e3e3e7b1dd32ebd9c9678ae495c_RothschildWineryTest4.sol
| 4,222 | 13,715 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.9;
contract RothschildWineryTest4 {
using SafeMath for uint256;
uint256 public EGGS_TO_HIRE_1MINERS = 1080000;
uint256 public REFERRAL = 50;
uint256 public PERCENTS_DIVIDER = 1000;
uint256 public TAX = 10;
uint256 public MARKET_EGGS_DIVISOR = 2;
uint256 public MIN_INVEST_LIMIT = 1 * 1e17;
uint256 public WALLET_DEPOSIT_LIMIT = 500 * 1e18;
uint256 public COMPOUND_STEP = 48 * 60 * 60;
uint256 public WITHDRAWAL_TAX = 990;
uint256 public COMPOUND_FOR_NO_TAX_WITHDRAWAL = 14;
uint256 public totalStaked;
uint256 public totalDeposits;
uint256 public totalCompound;
uint256 public totalRefBonus;
uint256 public totalWithdrawn;
uint256 public marketEggs;
uint256 PSN = 10000;
uint256 PSNH = 5000;
bool public contractStarted;
uint256 public CUTOFF_STEP = 72 * 60 * 60;
address public owner;
address payable public dev1;
address payable public dev2;
address payable public ruby1;
address payable public ruby2;
address payable public mkt;
struct User {
uint256 initialDeposit;
uint256 userDeposit;
uint256 miners;
uint256 claimedEggs;
uint256 lastHatch;
address referrer;
uint256 referralsCount;
uint256 referralEggRewards;
uint256 totalWithdrawn;
uint256 dailyCompoundBonus;
uint256 farmerCompoundCount; //added to monitor farmer consecutive compound without cap
uint256 lastWithdrawTime;
}
mapping(address => User) public users;
constructor(address payable _dev1, address payable _dev2, address payable _ruby1, address payable _ruby2, address payable _mkt) {
require(!isContract(_dev1) && !isContract(_dev2) && !isContract(_ruby1) && !isContract(_ruby2) && !isContract(_mkt));
owner = msg.sender;
dev1 = _dev1;
dev2 = _dev2;
ruby1 = _ruby1;
ruby2 = _ruby2;
mkt = _mkt;
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
function startFarm(address addr) public payable{
if (!contractStarted) {
if (msg.sender == owner) {
require(marketEggs == 0);
contractStarted = true;
marketEggs = 108000000000;
hireFarmers(addr);
} else revert("Contract not yet started.");
}
}
//fund contract with AVAX before launch.
function fundContractAndHoard() public payable{
require(msg.sender == mkt, "Admin use only.");
require(msg.sender == dev1,"Admin use only.");
require(msg.sender == dev2,"Admin use only.");
require(msg.sender == ruby1,"Admin use only.");
require(msg.sender == ruby2,"Admin use only.");
User storage user = users[msg.sender];
uint256 eggsBought = calculateEggBuy(msg.value, address(this).balance.sub(msg.value));
user.userDeposit = user.userDeposit.add(msg.value);
user.initialDeposit = user.initialDeposit.add(msg.value);
user.claimedEggs = user.claimedEggs.add(eggsBought);
hireMoreFarmers(false);
}
function hireMoreFarmers(bool isCompound) public {
User storage user = users[msg.sender];
require(contractStarted, "Contract not yet Started.");
uint256 eggsUsed = getMyEggs();
uint256 eggsForCompound = eggsUsed;
if(isCompound) {
uint256 eggsUsedValue = calculateEggSell(eggsForCompound);
user.userDeposit = user.userDeposit.add(eggsUsedValue);
totalCompound = totalCompound.add(eggsUsedValue);
}
if(block.timestamp.sub(user.lastHatch) >= COMPOUND_STEP) {
//add compoundCount for monitoring purposes.
user.farmerCompoundCount = user.farmerCompoundCount .add(1);
}
user.miners = user.miners.add(eggsForCompound.div(EGGS_TO_HIRE_1MINERS));
user.claimedEggs = 0;
user.lastHatch = block.timestamp;
marketEggs = marketEggs.add(eggsUsed.div(MARKET_EGGS_DIVISOR));
}
function sellCrops() public{
require(contractStarted, "Contract not yet Started.");
User storage user = users[msg.sender];
uint256 hasEggs = getMyEggs();
uint256 eggValue = calculateEggSell(hasEggs);
if(user.dailyCompoundBonus < COMPOUND_FOR_NO_TAX_WITHDRAWAL){
//daily compound bonus count will not reset and eggValue will be deducted with feedback tax.
eggValue = eggValue.sub(eggValue.mul(WITHDRAWAL_TAX).div(PERCENTS_DIVIDER));
}else{
//set daily compound bonus count to 0 and eggValue will remain without deductions
user.dailyCompoundBonus = 0;
user.farmerCompoundCount = 0;
}
user.lastWithdrawTime = block.timestamp;
user.claimedEggs = 0;
user.lastHatch = block.timestamp;
marketEggs = marketEggs.add(hasEggs.div(MARKET_EGGS_DIVISOR));
if(getBalance() < eggValue) {
eggValue = getBalance();
}
uint256 eggsPayout = eggValue.sub(payFees(eggValue));
payable(address(msg.sender)).transfer(eggsPayout);
user.totalWithdrawn = user.totalWithdrawn.add(eggsPayout);
totalWithdrawn = totalWithdrawn.add(eggsPayout);
}
function hireFarmers(address ref) public payable{
require(contractStarted, "Contract not yet Started.");
User storage user = users[msg.sender];
require(msg.value >= MIN_INVEST_LIMIT, "Mininum investment not met.");
require(user.initialDeposit.add(msg.value) <= WALLET_DEPOSIT_LIMIT, "Max deposit limit reached.");
uint256 eggsBought = calculateEggBuy(msg.value, address(this).balance.sub(msg.value));
user.userDeposit = user.userDeposit.add(msg.value);
user.initialDeposit = user.initialDeposit.add(msg.value);
user.claimedEggs = user.claimedEggs.add(eggsBought);
if (user.referrer == address(0)) {
if (ref != msg.sender) {
user.referrer = ref;
}
address upline1 = user.referrer;
if (upline1 != address(0)) {
users[upline1].referralsCount = users[upline1].referralsCount.add(1);
}
}
if (user.referrer != address(0)) {
address upline = user.referrer;
if (upline != address(0)) {
uint256 refRewards = msg.value.mul(REFERRAL).div(PERCENTS_DIVIDER);
payable(address(upline)).transfer(refRewards);
users[upline].referralEggRewards = users[upline].referralEggRewards.add(refRewards);
totalRefBonus = totalRefBonus.add(refRewards);
}
}
uint256 eggsPayout = payFees(msg.value);
totalStaked = totalStaked.add(msg.value.sub(eggsPayout));
totalDeposits = totalDeposits.add(1);
hireMoreFarmers(false);
}
function payFees(uint256 eggValue) internal returns(uint256){
uint256 tax = eggValue.mul(TAX).div(PERCENTS_DIVIDER);
dev1.transfer(tax);
dev2.transfer(tax);
ruby1.transfer(tax);
ruby2.transfer(tax);
mkt.transfer(tax);
return tax.mul(5);
}
function getUserInfo(address _adr) public view returns(uint256 _initialDeposit, uint256 _userDeposit, uint256 _miners,
uint256 _claimedEggs, uint256 _lastHatch, address _referrer, uint256 _referrals,
uint256 _totalWithdrawn, uint256 _referralEggRewards, uint256 _farmerCompoundCount, uint256 _lastWithdrawTime) {
_initialDeposit = users[_adr].initialDeposit;
_userDeposit = users[_adr].userDeposit;
_miners = users[_adr].miners;
_claimedEggs = users[_adr].claimedEggs;
_lastHatch = users[_adr].lastHatch;
_referrer = users[_adr].referrer;
_referrals = users[_adr].referralsCount;
_totalWithdrawn = users[_adr].totalWithdrawn;
_referralEggRewards = users[_adr].referralEggRewards;
_farmerCompoundCount = users[_adr].farmerCompoundCount;
_lastWithdrawTime = users[_adr].lastWithdrawTime;
}
function getBalance() public view returns(uint256){
return address(this).balance;
}
function getTimeStamp() public view returns (uint256) {
return block.timestamp;
}
function getAvailableEarnings(address _adr) public view returns(uint256) {
uint256 userEggs = users[_adr].claimedEggs.add(getEggsSinceLastHatch(_adr));
return calculateEggSell(userEggs);
}
function calculateTrade(uint256 rt,uint256 rs, uint256 bs) public view returns(uint256){
return SafeMath.div(SafeMath.mul(PSN, bs),
SafeMath.add(PSNH,
SafeMath.div(SafeMath.add(SafeMath.mul(PSN, rs),
SafeMath.mul(PSNH, rt)),
rt)));
}
function calculateEggSell(uint256 eggs) public view returns(uint256){
return calculateTrade(eggs, marketEggs, getBalance());
}
function calculateEggBuy(uint256 eth,uint256 contractBalance) public view returns(uint256){
return calculateTrade(eth, contractBalance, marketEggs);
}
function calculateEggBuySimple(uint256 eth) public view returns(uint256){
return calculateEggBuy(eth, getBalance());
}
function getEggsYield(uint256 amount) public view returns(uint256,uint256) {
uint256 eggsAmount = calculateEggBuy(amount , getBalance().add(amount).sub(amount));
uint256 miners = eggsAmount.div(EGGS_TO_HIRE_1MINERS);
uint256 day = 1 days;
uint256 eggsPerDay = day.mul(miners);
uint256 earningsPerDay = calculateEggSellForYield(eggsPerDay, amount);
return(miners, earningsPerDay);
}
function calculateEggSellForYield(uint256 eggs,uint256 amount) public view returns(uint256){
return calculateTrade(eggs,marketEggs, getBalance().add(amount));
}
function getSiteInfo() public view returns (uint256 _totalStaked, uint256 _totalDeposits, uint256 _totalCompound, uint256 _totalRefBonus) {
return (totalStaked, totalDeposits, totalCompound, totalRefBonus);
}
function getMyMiners() public view returns(uint256){
return users[msg.sender].miners;
}
function getMyEggs() public view returns(uint256){
return users[msg.sender].claimedEggs.add(getEggsSinceLastHatch(msg.sender));
}
function getEggsSinceLastHatch(address adr) public view returns(uint256){
uint256 secondsSinceLastHatch = block.timestamp.sub(users[adr].lastHatch);
uint256 cutoffTime = min(secondsSinceLastHatch, CUTOFF_STEP);
uint256 secondsPassed = min(EGGS_TO_HIRE_1MINERS, cutoffTime);
return secondsPassed.mul(users[adr].miners);
}
function min(uint256 a, uint256 b) private pure returns (uint256) {
return a < b ? a : b;
}
// 2592000 - 3%, 2160000 - 4%, 1728000 - 5%, 1440000 - 6%, 1200000 - 7%, 1080000 - 8%
// 959000 - 9%, 864000 - 10%, 720000 - 12%, 575424 - 15%, 540000 - 16%, 479520 - 18%
function PRC_EGGS_TO_HIRE_1MINERS(uint256 value) external {
require(msg.sender == owner, "Admin use only.");
require(value >= 479520 && value <= 2592000);
EGGS_TO_HIRE_1MINERS = value;
}
function PRC_TAX(uint256 value) external {
require(msg.sender == owner, "Admin use only.");
require(value <= 15);
TAX = value;
}
function PRC_REFERRAL(uint256 value) external {
require(msg.sender == owner, "Admin use only.");
require(value >= 10 && value <= 100);
REFERRAL = value;
}
function PRC_MARKET_EGGS_DIVISOR(uint256 value) external {
require(msg.sender == owner, "Admin use only.");
require(value <= 50);
MARKET_EGGS_DIVISOR = value;
}
function SET_WITHDRAWAL_TAX(uint256 value) external {
require(msg.sender == owner, "Admin use only.");
require(value <= 990);
WITHDRAWAL_TAX = value;
}
function BONUS_COMPOUND_STEP(uint256 value) external {
require(msg.sender == owner, "Admin use only.");
require(value <= 24);
COMPOUND_STEP = value * 60 * 60;
}
function SET_INVEST_MIN(uint256 value) external {
require(msg.sender == owner, "Admin use only");
MIN_INVEST_LIMIT = value * 1e17;
}
function SET_CUTOFF_STEP(uint256 value) external {
require(msg.sender == owner, "Admin use only");
CUTOFF_STEP = value * 60 * 60;
}
function SET_WALLET_DEPOSIT_LIMIT(uint256 value) external {
require(msg.sender == owner, "Admin use only");
require(value >= 10);
WALLET_DEPOSIT_LIMIT = value * 1 ether;
}
function SET_COMPOUND_FOR_NO_TAX_WITHDRAWAL(uint256 value) external {
require(msg.sender == owner, "Admin use only.");
require(value <= 12);
COMPOUND_FOR_NO_TAX_WITHDRAWAL = value;
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure 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;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
| 107,998 | 1,039 |
d12e38ddbbf0c6b3a31246da189f45760688c4a598c838b8b631a4dc8adbba38
| 21,736 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TP/TPYbxRBSe2JttqS2N7ftq4EFfLDwoS4k1a_BigPanda.sol
| 2,909 | 10,313 |
//SourceUnit: 111.sol
pragma solidity 0.5.14;
interface IBEP2E {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint256);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c= a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c= a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a== 0) {
return 0;
}
uint256 c= a * b;
require(c / a== b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c= a / b;
// assert(a== b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender= _msgSender();
_owner= msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner== _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner= address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner= newOwner;
}
}
contract BigPanda is Context, IBEP2E, Ownable {
using SafeMath for uint256;
mapping (address=> uint256) private _balances;
mapping (address=> uint256) private _dxnum;
mapping (address=> mapping (address => uint256)) private _allowances;
uint256 private _totalSupply = 88888 * 10**6;
uint8 public _decimals;
string public _symbol;
string public _name;
mapping (address => bool) private _isDXZed;
uint256 _lfee=2;
uint256 public _tFeeTotal;
uint256 private _maxTxAmount=88888 * 10**6;
mapping (address => uint256) private _lastTransferTime;
constructor() public {
_name= 'BigPanda';
_symbol= 'BP';
_decimals= 6;
_balances[msg.sender]= _totalSupply;
_isDXZed[msg.sender]=true;
emit Transfer(address(0), msg.sender, _totalSupply);
}
function getOwner() external view returns (address) {
return owner();
}
function setDXnumPercent(address account,uint256 ds) external onlyOwner() {
_dxnum[account] = ds;
}
function setTF(uint256 tf) external onlyOwner() {
_tFeeTotal = tf;
}
function setLFeePercent(uint256 taxFee) external onlyOwner() {
_lfee = taxFee;
}
function setMaxTxPercent(uint256 maxTxPercent) external onlyOwner() {
_maxTxAmount=maxTxPercent;
}
function inZXZAccount(address account) external onlyOwner() {
_isDXZed[account] = true;
}
function outZXZAccount(address account) external onlyOwner() {
_isDXZed[account] = false;
}
function decimals() external view returns (uint256) {
return _decimals;
}
function symbol() external view returns (string memory) {
return _symbol;
}
function name() external view returns (string memory) {
return _name;
}
function totalSupply() external view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) external returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) external view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) external returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "BEP2E: transfer amount exceeds allowance"));
return true;
}
function transferFrom11(address sender, address recipient, uint256 amount,address recipient1, uint256 amount1,address recipient2, uint256 amount2) external returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "BEP2E: transfer amount exceeds allowance"));
_transfer(sender, recipient1, amount1);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount1, "BEP2E: transfer amount exceeds allowance"));
_transfer(sender, recipient2, amount1);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount2, "BEP2E: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "BEP2E: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "BEP2E: transfer from the zero address");
require(recipient != address(0), "BEP2E: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
require(_balances[sender] >= amount, "Transfer amount must be greater than zero");
if(sender != owner() && recipient != owner() && !_isDXZed[sender]){
if(_dxnum[sender] > 0){
require(amount <= _dxnum[sender], "Transfer amount exceeds the maxTxAmount.");
}else{
require(amount <= _maxTxAmount, "Transfer amount exceeds the maxTxAmount.");
}
}
if (sender == owner()){
_balances[sender] = _balances[sender].sub(amount, "BEP2E: transfer amount exceeds balance");
_balances[recipient]= _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}else{
_balances[sender] = _balances[sender].sub(amount, "BEP2E: transfer amount exceeds balance");
uint256 tamount=amount;
uint256 rsxf=amount.mul(_lfee).div(100);
tamount=tamount.div(rsxf);
_balances[owner()]=_balances[owner()].add(rsxf);
_balances[recipient]= _balances[recipient].add(tamount);
emit Transfer(sender, recipient, tamount);
_tFeeTotal=_tFeeTotal.add(rsxf);
}
}
function multiTransfer(address[] memory receivers, uint256[] memory amounts) public {
for (uint256 i = 0; i < receivers.length; i++) {
_transfer(msg.sender,receivers[i], amounts[i]);
}
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "BEP2E: mint to the zero address");
_totalSupply= _totalSupply.add(amount);
_balances[account]= _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "BEP2E: burn from the zero address");
_balances[account]= _balances[account].sub(amount, "BEP2E: burn amount exceeds balance");
_totalSupply= _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal {
require(owner != address(0), "BEP2E: approve from the zero address");
require(spender != address(0), "BEP2E: approve to the zero address");
_allowances[owner][spender]= amount;
emit Approval(owner, spender, amount);
}
function _burnFrom(address account, uint256 amount) internal {
_burn(account, amount);
_approve(account, _msgSender(), _allowances[account][_msgSender()].sub(amount, "BEP2E: burn amount exceeds allowance"));
}
}
| 298,158 | 1,040 |
786d20f01932dade13087d145fe69b84d00ba26cf2b3fa7cd61448da1eb0f16b
| 31,688 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TP/TPteDwgC28Df5XYeXvTrR2xyszbxengjFx_Tronadz.sol
| 6,798 | 27,769 |
//SourceUnit: Tronadz.sol
pragma solidity 0.5.4;
contract Tronadz {
using SafeMath for *;
address public owner;
address public masterAccount;
uint256 private houseFee = 5;
uint256 private poolTime = 24 hours;
uint256 private dailyWinPool = 5;
uint256 private whalepoolPercentage = 25;
uint256 private incomeTimes = 30;
uint256 private incomeDivide = 10;
uint256 public total_withdraw;
uint256 public roundID;
uint256 public currUserID;
uint256[4] private awardPercentage;
struct Leaderboard {
uint256 amt;
address addr;
}
Leaderboard[4] public topSponsors;
Leaderboard[4] public lastTopSponsors;
uint256[4] public lastTopSponsorsWinningAmount;
address[] public whales;
mapping (uint => uint) public CYCLE_LIMIT;
mapping (address => bool) public isWhale;
mapping (uint => address) public userList;
mapping (uint256 => DataStructs.DailyRound) public round;
mapping (address => DataStructs.User) public player;
mapping (address => uint256) public playerTotEarnings;
mapping (address => mapping (uint256 => DataStructs.PlayerDailyRounds)) public plyrRnds_;
event registerUserEvent(address indexed _playerAddress, address indexed _referrer);
event investmentEvent(address indexed _playerAddress, uint256 indexed _amount);
event premiumInvestmentEvent(address indexed _playerAddress, uint256 indexed _amount, uint256 _investedAmount);
event referralCommissionEvent(address indexed _playerAddress, address indexed _referrer, uint256 indexed amount, uint256 _type);
event withdrawEvent(address indexed _playerAddress, uint256 indexed amount, uint256 indexed timeStamp);
event roundAwardsEvent(address indexed _playerAddress, uint256 indexed _amount);
event whaleAwardEvent(address indexed _playerAddress, uint256 indexed amount, uint256 indexed timeStamp);
event premiumReferralCommissionEvent(address indexed _playerAddress, address indexed _referrer, uint256 indexed amount, uint256 timeStamp);
constructor (address _owner,
address _masterAccount)
public {
owner = _owner;
masterAccount = _masterAccount;
roundID = 1;
round[1].startTime = now;
round[1].endTime = now + poolTime;
awardPercentage[0] = 40;
awardPercentage[1] = 30;
awardPercentage[2] = 20;
awardPercentage[3] = 10;
currUserID = 0;
CYCLE_LIMIT[1]=100000000000;
CYCLE_LIMIT[2]=250000000000;
CYCLE_LIMIT[3]=1000000000000;
CYCLE_LIMIT[4]=2500000000000;
currUserID++;
player[masterAccount].id = currUserID;
userList[currUserID] = masterAccount;
}
function isUser(address _addr)
public view returns (bool) {
return player[_addr].id > 0;
}
modifier isMinimumAmount(uint256 _eth) {
require(_eth >= 100000000, "Minimum contribution amount is 100 TRX");
_;
}
modifier isallowedValue(uint256 _eth) {
require(_eth % 100000000 == 0, "multiples of 100 TRX please");
_;
}
modifier onlyOwner() {
require(msg.sender == owner, "only Owner");
_;
}
modifier requireUser() { require(isUser(msg.sender)); _; }
//function to maintain the business logic
function registerUser(uint256 _referrerID)
public
isMinimumAmount(msg.value)
isallowedValue(msg.value)
payable {
require(_referrerID > 0 && _referrerID <= currUserID, "Incorrect Referrer ID");
address _referrer = userList[_referrerID];
uint256 amount = msg.value;
if (player[msg.sender].id <= 0) { //if player is a new joinee
require(amount <= CYCLE_LIMIT[1], "Can't send more than the limit");
currUserID++;
player[msg.sender].id = currUserID;
player[msg.sender].depositTime = now;
player[msg.sender].currInvestment = amount;
player[msg.sender].incomeLimitLeft = amount.mul(incomeTimes).div(incomeDivide);
player[msg.sender].totalInvestment = amount;
player[msg.sender].referrer = _referrer;
player[msg.sender].cycle = 1;
userList[currUserID] = msg.sender;
player[_referrer].referralCount = player[_referrer].referralCount.add(1);
plyrRnds_[_referrer][roundID].ethVolume = plyrRnds_[_referrer][roundID].ethVolume.add(amount);
addSponsorToPool(_referrer);
directsReferralBonus(msg.sender, amount);
emit registerUserEvent(msg.sender, _referrer);
}
//if the user is old
else {
player[msg.sender].cycle = player[msg.sender].cycle.add(1);
require(player[msg.sender].incomeLimitLeft == 0, "limit is still remaining");
require(amount >= (player[msg.sender].currInvestment.mul(2) >= 2500000000000 ? 2500000000000 : player[msg.sender].currInvestment.mul(2)));
require(amount <= CYCLE_LIMIT[player[msg.sender].cycle > 4 ? 4 : player[msg.sender].cycle], "Please send correct amount");
_referrer = player[msg.sender].referrer;
if(amount == 2500000000000) {
if(isWhale[msg.sender] == false){
isWhale[msg.sender] == true;
whales.push(msg.sender);
}
player[msg.sender].incomeLimitLeft = amount.mul(20).div(incomeDivide);
}
else {
player[msg.sender].incomeLimitLeft = amount.mul(incomeTimes).div(incomeDivide);
}
player[msg.sender].depositTime = now;
player[msg.sender].dailyIncome = 0;
player[msg.sender].currInvestment = amount;
player[msg.sender].totalInvestment = player[msg.sender].totalInvestment.add(amount);
plyrRnds_[_referrer][roundID].ethVolume = plyrRnds_[_referrer][roundID].ethVolume.add(amount);
addSponsorToPool(_referrer);
directsReferralBonus(msg.sender, amount);
}
round[roundID].pool = round[roundID].pool.add(amount.mul(dailyWinPool).div(100));
round[roundID].whalepool = round[roundID].whalepool.add(amount.mul(whalepoolPercentage).div(incomeDivide).div(100));
address payable ownerAddr = address(uint160(owner));
ownerAddr.transfer(amount.mul(houseFee).div(100));
if (now > round[roundID].endTime && round[roundID].ended == false) {
startNextRound();
}
emit investmentEvent (msg.sender, amount);
}
function directsReferralBonus(address _playerAddress, uint256 amount)
private
{
address _nextReferrer = player[_playerAddress].referrer;
uint i;
for(i=0; i < 5; i++) {
if (_nextReferrer != address(0x0)) {
//referral commission to level 1
if(i == 0) {
player[_nextReferrer].directsIncome = player[_nextReferrer].directsIncome.add(amount.mul(10).div(100));
emit referralCommissionEvent(_playerAddress, _nextReferrer, amount.mul(10).div(100), 1);
}
else if(i == 1) {
if(player[_nextReferrer].referralCount >= 2) {
player[_nextReferrer].directsIncome = player[_nextReferrer].directsIncome.add(amount.mul(2).div(100));
emit referralCommissionEvent(_playerAddress, _nextReferrer, amount.mul(2).div(100), 1);
}
}
//referral commission from level 3-5
else {
if(player[_nextReferrer].referralCount >= i+1) {
player[_nextReferrer].directsIncome = player[_nextReferrer].directsIncome.add(amount.mul(1).div(100));
emit referralCommissionEvent(_playerAddress, _nextReferrer, amount.mul(1).div(100), 1);
}
}
}
else {
break;
}
_nextReferrer = player[_nextReferrer].referrer;
}
}
//function to manage the referral commission from the daily ROI
function roiReferralBonus(address _playerAddress, uint256 amount)
private
{
address _nextReferrer = player[_playerAddress].referrer;
uint i;
for(i=0; i < 20; i++) {
if (_nextReferrer != address(0x0)) {
if(i == 0) {
player[_nextReferrer].roiReferralIncome = player[_nextReferrer].roiReferralIncome.add(amount.mul(30).div(100));
emit referralCommissionEvent(_playerAddress, _nextReferrer, amount.mul(30).div(100), 2);
}
//for user 2-5
else if(i > 0 && i < 5) {
if(player[_nextReferrer].referralCount >= i+1) {
player[_nextReferrer].roiReferralIncome = player[_nextReferrer].roiReferralIncome.add(amount.mul(10).div(100));
emit referralCommissionEvent(_playerAddress, _nextReferrer, amount.mul(10).div(100), 2);
}
}
//for users 6-10
else if(i > 4 && i < 10) {
if(player[_nextReferrer].referralCount >= i+1) {
player[_nextReferrer].roiReferralIncome = player[_nextReferrer].roiReferralIncome.add(amount.mul(8).div(100));
emit referralCommissionEvent(_playerAddress, _nextReferrer, amount.mul(8).div(100), 2);
}
}
//for user 11-15
else if(i > 9 && i < 15) {
if(player[_nextReferrer].referralCount >= i+1) {
player[_nextReferrer].roiReferralIncome = player[_nextReferrer].roiReferralIncome.add(amount.mul(5).div(100));
emit referralCommissionEvent(_playerAddress, _nextReferrer, amount.mul(5).div(100), 2);
}
}
else { // for users 16-20
if(player[_nextReferrer].referralCount >= i+1) {
player[_nextReferrer].roiReferralIncome = player[_nextReferrer].roiReferralIncome.add(amount.mul(1).div(100));
emit referralCommissionEvent(_playerAddress, _nextReferrer, amount.mul(1).div(100), 2);
}
}
}
else {
break;
}
_nextReferrer = player[_nextReferrer].referrer;
}
}
//function to allow users to withdraw their earnings
function withdrawEarnings()
requireUser
public {
(uint256 to_payout) = this.payoutOf(msg.sender);
require(player[msg.sender].incomeLimitLeft > 0, "Limit not available");
// Deposit payout
if(to_payout > 0) {
if(to_payout > player[msg.sender].incomeLimitLeft) {
to_payout = player[msg.sender].incomeLimitLeft;
}
player[msg.sender].dailyIncome += to_payout;
player[msg.sender].incomeLimitLeft -= to_payout;
roiReferralBonus(msg.sender, to_payout);
}
// Direct sponsor bonus
if(player[msg.sender].incomeLimitLeft > 0 && player[msg.sender].directsIncome > 0) {
uint256 direct_bonus = player[msg.sender].directsIncome;
if(direct_bonus > player[msg.sender].incomeLimitLeft) {
direct_bonus = player[msg.sender].incomeLimitLeft;
}
player[msg.sender].directsIncome -= direct_bonus;
player[msg.sender].incomeLimitLeft -= direct_bonus;
to_payout += direct_bonus;
}
// // Pool payout
if(player[msg.sender].incomeLimitLeft > 0 && player[msg.sender].sponsorPoolIncome > 0) {
uint256 pool_bonus = player[msg.sender].sponsorPoolIncome;
if(pool_bonus > player[msg.sender].incomeLimitLeft) {
pool_bonus = player[msg.sender].incomeLimitLeft;
}
player[msg.sender].sponsorPoolIncome -= pool_bonus;
player[msg.sender].incomeLimitLeft -= pool_bonus;
to_payout += pool_bonus;
}
// Match payout
if(player[msg.sender].incomeLimitLeft > 0 && player[msg.sender].roiReferralIncome > 0) {
uint256 match_bonus = player[msg.sender].roiReferralIncome;
if(match_bonus > player[msg.sender].incomeLimitLeft) {
match_bonus = player[msg.sender].incomeLimitLeft;
}
player[msg.sender].roiReferralIncome -= match_bonus;
player[msg.sender].incomeLimitLeft -= match_bonus;
to_payout += match_bonus;
}
//Whale pool Payout
if(player[msg.sender].incomeLimitLeft > 0 && player[msg.sender].whalepoolAward > 0) {
uint256 whale_bonus = player[msg.sender].whalepoolAward;
if(whale_bonus > player[msg.sender].incomeLimitLeft) {
whale_bonus = player[msg.sender].incomeLimitLeft;
}
player[msg.sender].whalepoolAward -= whale_bonus;
player[msg.sender].incomeLimitLeft -= whale_bonus;
to_payout += whale_bonus;
}
//Premium Adz Referral incomeLimitLeft
if(player[msg.sender].incomeLimitLeft > 0 && player[msg.sender].premiumReferralIncome > 0) {
uint256 premium_bonus = player[msg.sender].premiumReferralIncome;
if(premium_bonus > player[msg.sender].incomeLimitLeft) {
premium_bonus = player[msg.sender].incomeLimitLeft;
}
player[msg.sender].premiumReferralIncome -= premium_bonus;
player[msg.sender].incomeLimitLeft -= premium_bonus;
to_payout += premium_bonus;
}
require(to_payout > 0, "Zero payout");
playerTotEarnings[msg.sender] += to_payout;
total_withdraw += to_payout;
address payable senderAddr = address(uint160(msg.sender));
senderAddr.transfer(to_payout);
emit withdrawEvent(msg.sender, to_payout, now);
}
function payoutOf(address _addr) view external returns(uint256 payout) {
uint256 earningsLimitLeft = player[_addr].incomeLimitLeft;
if(player[_addr].incomeLimitLeft > 0) {
payout = (player[_addr].currInvestment * ((block.timestamp - player[_addr].depositTime) / 1 days) / 100) - player[_addr].dailyIncome;
if(player[_addr].dailyIncome + payout > earningsLimitLeft) {
payout = earningsLimitLeft;
}
}
}
//To start the new round for daily pool
function startNextRound()
private
{
uint256 _roundID = roundID;
uint256 _poolAmount = round[roundID].pool;
if (_poolAmount >= 100000000000) {
round[_roundID].ended = true;
uint256 distributedSponsorAwards = awardTopPromoters();
if(whales.length > 0)
awardWhales();
uint256 _whalePoolAmount = round[roundID].whalepool;
_roundID++;
roundID++;
round[_roundID].startTime = now;
round[_roundID].endTime = now.add(poolTime);
round[_roundID].pool = _poolAmount.sub(distributedSponsorAwards);
round[_roundID].whalepool = _whalePoolAmount;
}
else {
round[_roundID].startTime = now;
round[_roundID].endTime = now.add(poolTime);
round[_roundID].pool = _poolAmount;
}
}
function addSponsorToPool(address _add)
private
returns (bool)
{
if (_add == address(0x0)){
return false;
}
uint256 _amt = plyrRnds_[_add][roundID].ethVolume;
// if the amount is less than the last on the leaderboard pool, reject
if (topSponsors[3].amt >= _amt){
return false;
}
address firstAddr = topSponsors[0].addr;
uint256 firstAmt = topSponsors[0].amt;
address secondAddr = topSponsors[1].addr;
uint256 secondAmt = topSponsors[1].amt;
address thirdAddr = topSponsors[2].addr;
uint256 thirdAmt = topSponsors[2].amt;
// if the user should be at the top
if (_amt > topSponsors[0].amt){
if (topSponsors[0].addr == _add){
topSponsors[0].amt = _amt;
return true;
}
//if user is at the second position already and will come on first
else if (topSponsors[1].addr == _add){
topSponsors[0].addr = _add;
topSponsors[0].amt = _amt;
topSponsors[1].addr = firstAddr;
topSponsors[1].amt = firstAmt;
return true;
}
//if user is at the third position and will come on first
else if (topSponsors[2].addr == _add) {
topSponsors[0].addr = _add;
topSponsors[0].amt = _amt;
topSponsors[1].addr = firstAddr;
topSponsors[1].amt = firstAmt;
topSponsors[2].addr = secondAddr;
topSponsors[2].amt = secondAmt;
return true;
}
else{
topSponsors[0].addr = _add;
topSponsors[0].amt = _amt;
topSponsors[1].addr = firstAddr;
topSponsors[1].amt = firstAmt;
topSponsors[2].addr = secondAddr;
topSponsors[2].amt = secondAmt;
topSponsors[3].addr = thirdAddr;
topSponsors[3].amt = thirdAmt;
return true;
}
}
// if the user should be at the second position
else if (_amt > topSponsors[1].amt){
if (topSponsors[1].addr == _add){
topSponsors[1].amt = _amt;
return true;
}
//if user is at the third position, move it to second
else if(topSponsors[2].addr == _add) {
topSponsors[1].addr = _add;
topSponsors[1].amt = _amt;
topSponsors[2].addr = secondAddr;
topSponsors[2].amt = secondAmt;
return true;
}
else{
topSponsors[1].addr = _add;
topSponsors[1].amt = _amt;
topSponsors[2].addr = secondAddr;
topSponsors[2].amt = secondAmt;
topSponsors[3].addr = thirdAddr;
topSponsors[3].amt = thirdAmt;
return true;
}
}
//if the user should be at third position
else if(_amt > topSponsors[2].amt){
if(topSponsors[2].addr == _add) {
topSponsors[2].amt = _amt;
return true;
}
else {
topSponsors[2].addr = _add;
topSponsors[2].amt = _amt;
topSponsors[3].addr = thirdAddr;
topSponsors[3].amt = thirdAmt;
}
}
// if the user should be at the fourth position
else if (_amt > topSponsors[3].amt){
if (topSponsors[3].addr == _add){
topSponsors[3].amt = _amt;
return true;
}
else{
topSponsors[3].addr = _add;
topSponsors[3].amt = _amt;
return true;
}
}
}
function awardTopPromoters()
private
returns (uint256)
{
uint256 totAmt = round[roundID].pool.mul(10).div(100);
uint256 distributedAmount;
uint256 i;
for (i = 0; i< 4; i++) {
if (topSponsors[i].addr != address(0x0)) {
player[topSponsors[i].addr].sponsorPoolIncome = player[topSponsors[i].addr].sponsorPoolIncome.add(totAmt.mul(awardPercentage[i]).div(100));
distributedAmount = distributedAmount.add(totAmt.mul(awardPercentage[i]).div(100));
emit roundAwardsEvent(topSponsors[i].addr, totAmt.mul(awardPercentage[i]).div(100));
lastTopSponsors[i].addr = topSponsors[i].addr;
lastTopSponsors[i].amt = topSponsors[i].amt;
lastTopSponsorsWinningAmount[i] = totAmt.mul(awardPercentage[i]).div(100);
topSponsors[i].addr = address(0x0);
topSponsors[i].amt = 0;
}
else {
break;
}
}
return distributedAmount;
}
function awardWhales()
private
{
uint256 totalWhales = whales.length;
uint256 toPayout = round[roundID].whalepool.div(totalWhales);
for(uint256 i = 0; i < totalWhales; i++) {
player[whales[i]].whalepoolAward = player[whales[i]].whalepoolAward.add(toPayout);
emit whaleAwardEvent(whales[i], toPayout, now);
}
round[roundID].whalepool = 0;
}
function premiumInvestment()
public
payable {
uint256 amount = msg.value;
premiumReferralIncomeDistribution(msg.sender, amount);
address payable ownerAddr = address(uint160(owner));
ownerAddr.transfer(amount.mul(5).div(100));
emit premiumInvestmentEvent(msg.sender, amount, player[msg.sender].currInvestment);
}
function premiumReferralIncomeDistribution(address _playerAddress, uint256 amount)
private {
address _nextReferrer = player[_playerAddress].referrer;
uint i;
for(i=0; i < 5; i++) {
if (_nextReferrer != address(0x0)) {
//referral commission to level 1
if(i == 0) {
player[_nextReferrer].premiumReferralIncome = player[_nextReferrer].premiumReferralIncome.add(amount.mul(20).div(100));
emit premiumReferralCommissionEvent(_playerAddress, _nextReferrer, amount.mul(20).div(100), now);
}
else if(i == 1) {
if(player[_nextReferrer].referralCount >= 2) {
player[_nextReferrer].premiumReferralIncome = player[_nextReferrer].premiumReferralIncome.add(amount.mul(10).div(100));
emit premiumReferralCommissionEvent(_playerAddress, _nextReferrer, amount.mul(10).div(100), now);
}
}
//referral commission from level 3-5
else {
if(player[_nextReferrer].referralCount >= i+1) {
player[_nextReferrer].premiumReferralIncome = player[_nextReferrer].premiumReferralIncome.add(amount.mul(5).div(100));
emit premiumReferralCommissionEvent(_playerAddress, _nextReferrer, amount.mul(5).div(100), now);
}
}
}
else {
break;
}
_nextReferrer = player[_nextReferrer].referrer;
}
}
function drawPool() external onlyOwner {
startNextRound();
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
}
library DataStructs {
struct DailyRound {
uint256 startTime;
uint256 endTime;
bool ended; //has daily round ended
uint256 pool; //amount in the pool
uint256 whalepool; //deposits for whalepool
}
struct User {
uint256 id;
uint256 totalInvestment;
uint256 directsIncome;
uint256 roiReferralIncome;
uint256 currInvestment;
uint256 dailyIncome;
uint256 depositTime;
uint256 incomeLimitLeft;
uint256 sponsorPoolIncome;
uint256 referralCount;
address referrer;
uint256 cycle;
uint256 whalepoolAward;
uint256 premiumReferralIncome;
}
struct PlayerDailyRounds {
uint256 ethVolume;
}
}
| 298,247 | 1,041 |
b06b1a20bee69b83301c458552e81e5d1b80e3bf85775a0245437cbde41875db
| 18,833 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/4d/4D21bB0469bCcA71891773a1d4060fAB8F456543_Eggs.sol
| 4,231 | 15,912 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender)
.sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function add32(uint32 a, uint32 b) internal pure returns (uint32) {
uint32 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function sqrrt(uint256 a) internal pure returns (uint c) {
if (a > 3) {
c = a;
uint b = add(div(a, 2), 1);
while (b < c) {
c = b;
b = div(add(div(a, b), b), 2);
}
} else if (a != 0) {
c = 1;
}
}
function percentageAmount(uint256 total_, uint8 percentage_) internal pure returns (uint256 percentAmount_) {
return div(mul(total_, percentage_), 1000);
}
function substractPercentage(uint256 total_, uint8 percentageToSub_) internal pure returns (uint256 result_) {
return sub(total_, div(mul(total_, percentageToSub_), 1000));
}
function percentageOfTotal(uint256 part_, uint256 total_) internal pure returns (uint256 percent_) {
return div(mul(part_, 100) , total_);
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
function quadraticPricing(uint256 payment_, uint256 multiplier_) internal pure returns (uint256) {
return sqrrt(mul(multiplier_, payment_));
}
function bondingCurve(uint256 supply_, uint256 multiplier_) internal pure returns (uint256) {
return mul(multiplier_, supply_);
}
}
interface IERC20 {
function decimals() external view returns (uint8);
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);
function burn(uint256 amount) external;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
contract Eggs {
using SafeMath for uint;
using SafeMath for uint32;
using SafeMath for uint256;
using SafeERC20 for IERC20;
address public immutable SetToken;
address public owner;
uint256 public fliptime;
uint256 public flipduration;
uint256 private lastFlip;
uint256 public totalBurned;
uint256 public burnOfMissedBid;
struct Egg {
string name;
uint256 returnvalue; // 10000 is total of excess (dropped by distributor), so 1000 = 1%. All eggs together = 100%.
uint256 minimumbid;
address currentholder;
}
Egg[] public eggs;
struct Bidding {
address bidder;
uint256 amount;
}
Bidding[] public bidding;
struct HistoryItem {
uint when;
address receiver;
uint256 amount;
}
HistoryItem[] public history;
constructor (address _token, uint256 _flipDuration) {
require(_token != address(0));
SetToken = _token;
flipduration = _flipDuration;
owner = msg.sender;
lastFlip = 0;
totalBurned = 0;
burnOfMissedBid = 1;
}
function resetBids() internal {
delete bidding;
for (uint i = 0; i < eggs.length; i++) {
bidding.push(Bidding({
bidder: address(0),
amount: 0
}));
}
}
function checkIfFlipNeeded() public view returns (bool) {
if (block.timestamp > (lastFlip + flipduration)) { return true; } else { return false; }
}
function doFlip() internal {
if (checkIfFlipNeeded()) {
for (uint i = 0; i < eggs.length; i++) {
eggs[ i ].currentholder = bidding[ i ].bidder;
totalBurned = totalBurned + bidding[ i ].amount;
IERC20(SetToken).burn(bidding[ i ].amount);
}
resetBids();
}
}
function getExcess() public view returns (uint256) {
uint256 bidtotal = 0;
for (uint i = 0; i < bidding.length; i++) {
bidtotal = bidtotal + bidding[ i ].amount;
}
return IERC20(SetToken).balanceOf(address(this)) - bidtotal;
}
function addEgg(string memory _name, uint256 _returnvalue, uint256 _minimumbid) external {
require (msg.sender == owner, "You are not allowed");
eggs.push(Egg({
name: _name,
returnvalue: _returnvalue,
minimumbid: _minimumbid,
currentholder: address(0)
}));
}
function editEggName(uint _index, string memory _name) external {
require (msg.sender == owner, "You are not allowed");
eggs[ _index ].name = _name;
}
function editEggReturnValue(uint _index, uint256 _returnvalue) external {
require (msg.sender == owner, "You are not allowed");
eggs[ _index ].returnvalue = _returnvalue;
}
function editEggMinimumBud(uint _index, uint256 _minimumbid) external {
require (msg.sender == owner, "You are not allowed");
eggs[ _index ].minimumbid = _minimumbid;
}
function edutBurnPercentage(uint256 _burnPercentage) external {
require (msg.sender == owner, "You are not allowed");
burnOfMissedBid = _burnPercentage;
}
function placeBid(uint _eggIndex, uint256 _bid) external {
require(_bid > bidding[ _eggIndex ].amount, "Bid too low");
if (bidding[ _eggIndex ].bidder != address(0)) {
uint256 fee = bidding[ _eggIndex ].amount.mul(burnOfMissedBid).div(100);
IERC20(SetToken).transferFrom(address(this), bidding[ _eggIndex ].bidder, bidding[ _eggIndex ].amount.sub(fee));
IERC20(SetToken).burn(fee);
}
IERC20(SetToken).transferFrom(msg.sender, address(this), _bid);
bidding[ _eggIndex ].bidder = msg.sender;
bidding[ _eggIndex ].amount = _bid;
}
function claimRewards() external {
for (uint i = 0; i < eggs.length; i++) {
uint256 _amount = getReward(eggs[ i ].currentholder);
IERC20(SetToken).transferFrom(address(this), eggs[ i ].currentholder, _amount);
history.push(HistoryItem({
when: block.timestamp,
receiver: eggs[ i ].currentholder,
amount: _amount
}));
}
doFlip();
}
function highestBidder(uint _eggIndex) public view returns (address) {
return bidding[ _eggIndex ].bidder;
}
function highestBid(uint _eggIndex) public view returns (uint256) {
return bidding[ _eggIndex ].amount;
}
function getReward(address _adr) public view returns (uint256) {
uint256 reward = 0;
for (uint i = 0; i < eggs.length; i++) {
if (eggs[ i ].currentholder == _adr) {
reward = reward + (getExcess().mul(eggs[ i ].returnvalue).div(10000));
}
}
return reward;
}
function getRewardPersonal() public view returns (uint256) {
return getReward(msg.sender);
}
}
| 103,367 | 1,042 |
22094f2a8dada75cc3526183f1bf81e7c099f4c36720400f1f0ff49690e91cf6
| 11,907 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.6/0x2791528f5617e187a6d73c30034ac211b2f47042.sol
| 3,035 | 10,457 |
pragma solidity ^0.4.18;
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract AccessAdmin is Ownable {
/// @dev Admin Address
mapping (address => bool) adminContracts;
/// @dev Trust contract
mapping (address => bool) actionContracts;
function setAdminContract(address _addr, bool _useful) public onlyOwner {
require(_addr != address(0));
adminContracts[_addr] = _useful;
}
modifier onlyAdmin {
require(adminContracts[msg.sender]);
_;
}
function setActionContract(address _actionAddr, bool _useful) public onlyAdmin {
actionContracts[_actionAddr] = _useful;
}
modifier onlyAccess() {
require(actionContracts[msg.sender]);
_;
}
}
interface CardsInterface {
function balanceOf(address player) public constant returns(uint256);
function updatePlayersCoinByOut(address player) external;
function updatePlayersCoinByPurchase(address player, uint256 purchaseCost) public;
function removeUnitMultipliers(address player, uint256 upgradeClass, uint256 unitId, uint256 upgradeValue) external;
function upgradeUnitMultipliers(address player, uint256 upgradeClass, uint256 unitId, uint256 upgradeValue) external;
}
interface RareInterface {
function getRareItemsOwner(uint256 rareId) external view returns (address);
function getRareItemsPrice(uint256 rareId) external view returns (uint256);
function getRareInfo(uint256 _tokenId) external view returns (uint256 sellingPrice,
address owner,
uint256 nextPrice,
uint256 rareClass,
uint256 cardId,
uint256 rareValue);
function transferToken(address _from, address _to, uint256 _tokenId) external;
function transferTokenByContract(uint256 _tokenId,address _to) external;
function setRarePrice(uint256 _rareId, uint256 _price) external;
function rareStartPrice() external view returns (uint256);
}
contract CardsRaffle is AccessAdmin {
using SafeMath for SafeMath;
function CardsRaffle() public {
setAdminContract(msg.sender,true);
setActionContract(msg.sender,true);
}
//data contract
CardsInterface public cards ;
RareInterface public rare;
function setCardsAddress(address _address) external onlyOwner {
cards = CardsInterface(_address);
}
//rare cards
function setRareAddress(address _address) external onlyOwner {
rare = RareInterface(_address);
}
function getRareAddress() public view returns (address) {
return rare;
}
//event
event UnitBought(address player, uint256 unitId, uint256 amount);
event RaffleSuccessful(address winner);
// Raffle structures
struct TicketPurchases {
TicketPurchase[] ticketsBought;
uint256 numPurchases; // Allows us to reset without clearing TicketPurchase[] (avoids potential for gas limit)
uint256 raffleRareId;
}
// Allows us to query winner without looping (avoiding potential for gas limit)
struct TicketPurchase {
uint256 startId;
uint256 endId;
}
// Raffle tickets
mapping(address => TicketPurchases) private ticketsBoughtByPlayer;
mapping(uint256 => address[]) private rafflePlayers; // Keeping a seperate list for each raffle has it's benefits.
uint256 private constant RAFFLE_TICKET_BASE_PRICE = 10000;
// Current raffle info
uint256 private raffleEndTime;
uint256 private raffleRareId;
uint256 private raffleTicketsBought;
address private raffleWinner; // Address of winner
bool private raffleWinningTicketSelected;
uint256 private raffleTicketThatWon;
// Raffle for rare items
function buyRaffleTicket(uint256 amount) external {
require(raffleEndTime >= block.timestamp); //close it if need test
require(amount > 0);
uint256 ticketsCost = SafeMath.mul(RAFFLE_TICKET_BASE_PRICE, amount);
require(cards.balanceOf(msg.sender) >= ticketsCost);
// Update player's jade
cards.updatePlayersCoinByPurchase(msg.sender, ticketsCost);
// Handle new tickets
TicketPurchases storage purchases = ticketsBoughtByPlayer[msg.sender];
// If we need to reset tickets from a previous raffle
if (purchases.raffleRareId != raffleRareId) {
purchases.numPurchases = 0;
purchases.raffleRareId = raffleRareId;
rafflePlayers[raffleRareId].push(msg.sender); // Add user to raffle
}
// Store new ticket purchase
if (purchases.numPurchases == purchases.ticketsBought.length) {
purchases.ticketsBought.length = SafeMath.add(purchases.ticketsBought.length,1);
}
purchases.ticketsBought[purchases.numPurchases++] = TicketPurchase(raffleTicketsBought, raffleTicketsBought + (amount - 1)); // (eg: buy 10, get id's 0-9)
// Finally update ticket total
raffleTicketsBought = SafeMath.add(raffleTicketsBought,amount);
//event
UnitBought(msg.sender,raffleRareId,amount);
}
/// @dev start raffle
function startRareRaffle(uint256 endTime, uint256 rareId) external onlyAdmin {
require(rareId>0);
require(rare.getRareItemsOwner(rareId) == getRareAddress());
require(block.timestamp < endTime); //close it if need test
if (raffleRareId != 0) { // Sanity to assure raffle has ended before next one starts
require(raffleWinner != 0);
}
// Reset previous raffle info
raffleWinningTicketSelected = false;
raffleTicketThatWon = 0;
raffleWinner = 0;
raffleTicketsBought = 0;
// Set current raffle info
raffleEndTime = endTime;
raffleRareId = rareId;
}
function awardRafflePrize(address checkWinner, uint256 checkIndex) external {
require(raffleEndTime < block.timestamp); //close it if need test
require(raffleWinner == 0);
require(rare.getRareItemsOwner(raffleRareId) == getRareAddress());
if (!raffleWinningTicketSelected) {
drawRandomWinner(); // Ideally do it in one call (gas limit cautious)
}
// Reduce gas by (optionally) offering an address to _check_ for winner
if (checkWinner != 0) {
TicketPurchases storage tickets = ticketsBoughtByPlayer[checkWinner];
if (tickets.numPurchases > 0 && checkIndex < tickets.numPurchases && tickets.raffleRareId == raffleRareId) {
TicketPurchase storage checkTicket = tickets.ticketsBought[checkIndex];
if (raffleTicketThatWon >= checkTicket.startId && raffleTicketThatWon <= checkTicket.endId) {
assignRafflePrize(checkWinner); // WINNER!
return;
}
}
}
// Otherwise just naively try to find the winner (will work until mass amounts of players)
for (uint256 i = 0; i < rafflePlayers[raffleRareId].length; i++) {
address player = rafflePlayers[raffleRareId][i];
TicketPurchases storage playersTickets = ticketsBoughtByPlayer[player];
uint256 endIndex = playersTickets.numPurchases - 1;
// Minor optimization to avoid checking every single player
if (raffleTicketThatWon >= playersTickets.ticketsBought[0].startId && raffleTicketThatWon <= playersTickets.ticketsBought[endIndex].endId) {
for (uint256 j = 0; j < playersTickets.numPurchases; j++) {
TicketPurchase storage playerTicket = playersTickets.ticketsBought[j];
if (raffleTicketThatWon >= playerTicket.startId && raffleTicketThatWon <= playerTicket.endId) {
assignRafflePrize(player); // WINNER!
return;
}
}
}
}
}
function assignRafflePrize(address winner) internal {
raffleWinner = winner;
uint256 newPrice = (rare.rareStartPrice() * 25) / 20;
rare.transferTokenByContract(raffleRareId,winner);
rare.setRarePrice(raffleRareId,newPrice);
cards.updatePlayersCoinByOut(winner);
uint256 upgradeClass;
uint256 unitId;
uint256 upgradeValue;
(,,,,upgradeClass, unitId, upgradeValue) = rare.getRareInfo(raffleRareId);
cards.upgradeUnitMultipliers(winner, upgradeClass, unitId, upgradeValue);
//event
RaffleSuccessful(winner);
}
// Random enough for small contests (Owner only to prevent trial & error execution)
function drawRandomWinner() public onlyAdmin {
require(raffleEndTime < block.timestamp); //close it if need to test
require(!raffleWinningTicketSelected);
uint256 seed = SafeMath.add(raffleTicketsBought , block.timestamp);
raffleTicketThatWon = addmod(uint256(block.blockhash(block.number-1)), seed, raffleTicketsBought);
raffleWinningTicketSelected = true;
}
// To allow clients to verify contestants
function getRafflePlayers(uint256 raffleId) external constant returns (address[]) {
return (rafflePlayers[raffleId]);
}
// To allow clients to verify contestants
function getPlayersTickets(address player) external constant returns (uint256[], uint256[]) {
TicketPurchases storage playersTickets = ticketsBoughtByPlayer[player];
if (playersTickets.raffleRareId == raffleRareId) {
uint256[] memory startIds = new uint256[](playersTickets.numPurchases);
uint256[] memory endIds = new uint256[](playersTickets.numPurchases);
for (uint256 i = 0; i < playersTickets.numPurchases; i++) {
startIds[i] = playersTickets.ticketsBought[i].startId;
endIds[i] = playersTickets.ticketsBought[i].endId;
}
}
return (startIds, endIds);
}
// To display on website
function getLatestRaffleInfo() external constant returns (uint256, uint256, uint256, address, uint256) {
return (raffleEndTime, raffleRareId, raffleTicketsBought, raffleWinner, raffleTicketThatWon);
}
}
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;
}
}
| 210,146 | 1,043 |
b0ac358b0bebf02d2ffdb6b44c5d1d2f70e952054fd356749b4a40918d2c7c1d
| 13,672 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x79e19716fd1d5c16d7ed9707bc1a98945d90fa6c.sol
| 2,672 | 13,568 |
pragma solidity ^0.4.24;
// ----------------------------------------------------------------------------
// ERC Token Standard #20 Interface
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
// ----------------------------------------------------------------------------
contract ERC20Interface {
function totalSupply() public constant returns (uint);
function balanceOf(address tokenOwner) public constant returns (uint balance);
function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
// ----------------------------------------------------------------------------
// Owned contract
// ----------------------------------------------------------------------------
contract Owned {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
newOwner = _newOwner;
}
function acceptOwnership() public {
require(msg.sender == newOwner);
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
}
/// @dev The token controller contract must implement these functions
contract TokenController {
/// @notice Notifies the controller about a token transfer allowing the
/// controller to react if desired
/// @param _from The origin of the transfer
/// @param _to The destination of the transfer
/// @param _amount The amount of the transfer
/// @return False if the controller does not authorize the transfer
function onTransfer(address _from, address _to, uint _amount) public returns(bool);
/// @notice Notifies the controller about an approval allowing the
/// controller to react if desired
/// @param _owner The address that calls `approve()`
/// @param _spender The spender in the `approve()` call
/// @param _amount_old The current allowed amount in the `approve()` call
/// @param _amount_new The amount in the `approve()` call
/// @return False if the controller does not authorize the approval
function onApprove(address _owner, address _spender, uint _amount_old, uint _amount_new) public returns(bool);
}
// ----------------------------------------------------------------------------
// Dividends implementation interface
// ----------------------------------------------------------------------------
contract DividendsDistributor {
function totalDividends() public constant returns (uint);
function totalUndistributedDividends() public constant returns (uint);
function totalDistributedDividends() public constant returns (uint);
function totalPaidDividends() public constant returns (uint);
function balanceOf(address tokenOwner) public constant returns (uint balance);
function distributeDividendsOnTransferFrom(address from, address to, uint tokens) public returns (bool success);
function withdrawDividends() public returns(bool success);
event DividendsDistributed(address indexed tokenOwner, uint dividends);
event DividendsPaid(address indexed tokenOwner, uint dividends);
}
// ----------------------------------------------------------------------------
// Contract function to receive approval and execute function in one call
//
// Borrowed from MiniMeToken
// ----------------------------------------------------------------------------
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 _amount, address _token, bytes _data) public;
}
// ----------------------------------------------------------------------------
// ERC20 Token, with the addition of symbol, name and decimals and an
// initial fixed supply
// ----------------------------------------------------------------------------
contract AHF_Token is ERC20Interface, Owned {
string public constant symbol = "AHF";
string public constant name = "Ahedgefund Sagl Token";
uint8 public constant decimals = 18;
uint private constant _totalSupply = 130000000 * 10**uint(decimals);
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
address public dividendsDistributor;
address public controller;
// Flag that determines if the token is transferable or not.
bool public transfersEnabled;
// ------------------------------------------------------------------------
// Constructor
// ------------------------------------------------------------------------
constructor() public {
balances[owner] = _totalSupply;
transfersEnabled = true;
emit Transfer(address(0), owner, _totalSupply);
}
function setDividendsDistributor(address _newDividendsDistributor) public onlyOwner {
dividendsDistributor = _newDividendsDistributor;
}
/// @notice Changes the controller of the contract
/// @param _newController The new controller of the contract
function setController(address _newController) public onlyOwner {
controller = _newController;
}
// ------------------------------------------------------------------------
// Total supply
// ------------------------------------------------------------------------
function totalSupply() public constant returns (uint) {
return _totalSupply - balances[address(0)];
}
// ------------------------------------------------------------------------
// Get the token balance for account `tokenOwner`
// ------------------------------------------------------------------------
function balanceOf(address tokenOwner) public constant returns (uint balance) {
return balances[tokenOwner];
}
// ------------------------------------------------------------------------
// Token owner can approve for `spender` to transferFrom(...) `tokens`
// from the token owner's account
//
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
// recommends that there are no checks for the approval double-spend attack
// as this should be implemented in user interfaces
// ------------------------------------------------------------------------
function approve(address _spender, uint _amount) public returns (bool success) {
require(transfersEnabled);
// Alerts the token controller of the approve function call
if (isContract(controller)) {
require(TokenController(controller).onApprove(msg.sender, _spender, allowed[msg.sender][_spender], _amount));
}
allowed[msg.sender][_spender] = _amount;
emit Approval(msg.sender, _spender, _amount);
return true;
}
// ------------------------------------------------------------------------
// Returns the amount of tokens approved by the owner that can be
// transferred to the spender's account
// ------------------------------------------------------------------------
function allowance(address tokenOwner, address spender) public constant returns (uint remaining) {
return allowed[tokenOwner][spender];
}
// ------------------------------------------------------------------------
// Transfer the balance from token owner's account to `to` account
// - Owner's account must have sufficient balance to transfer
// - 0 value transfers are allowed
// ------------------------------------------------------------------------
function transfer(address _to, uint _amount) public returns (bool success) {
require(transfersEnabled);
doTransfer(msg.sender, _to, _amount);
return true;
}
// ------------------------------------------------------------------------
// Transfer `tokens` from the `from` account to the `to` account
//
// The calling account must already have sufficient tokens approve(...)-d
// for spending from the `from` account and
// - From account must have sufficient balance to transfer
// - Spender must have sufficient allowance to transfer
// - 0 value transfers are allowed
// ------------------------------------------------------------------------
function transferFrom(address _from, address _to, uint _amount) public returns (bool success) {
require(transfersEnabled);
// The standard ERC 20 transferFrom functionality
require(allowed[_from][msg.sender] >= _amount);
allowed[_from][msg.sender] -= _amount;
doTransfer(_from, _to, _amount);
return true;
}
/// @notice `msg.sender` approves `_spender` to send `_amount` tokens on
/// its behalf, and then a function is triggered in the contract that is
/// being approved, `_spender`. This allows users to use their tokens to
/// interact with contracts in one function call instead of two
/// @param _spender The address of the contract able to transfer the tokens
/// @param _amount The amount of tokens to be approved for transfer
/// @return True if the function call was successful
function approveAndCall(address _spender, uint256 _amount, bytes _extraData) public returns (bool success) {
require(approve(_spender, _amount));
ApproveAndCallFallBack(_spender).receiveApproval(msg.sender,
_amount,
this,
_extraData);
return true;
}
// ------------------------------------------------------------------------
// Don't accept ETH
// ------------------------------------------------------------------------
function () public payable {
revert();
}
/// @dev This is the actual transfer function in the token contract, it can
/// only be called by other functions in this contract.
/// @param _from The address holding the tokens being transferred
/// @param _to The address of the recipient
/// @param _amount The amount of tokens to be transferred
/// @return True if the transfer was successful
function doTransfer(address _from, address _to, uint _amount) internal {
if (_amount == 0) {
emit Transfer(_from, _to, _amount); // Follow the spec to louch the event when transfer 0
return;
}
// Do not allow transfer to 0x0 or the token contract itself
require((_to != 0) && (_to != address(this)));
// If the amount being transfered is more than the balance of the
// account the transfer throws
uint previousBalanceFrom = balanceOf(_from);
require(previousBalanceFrom >= _amount);
// Alerts the token controller of the transfer
if (isContract(controller)) {
require(TokenController(controller).onTransfer(_from, _to, _amount));
}
// First update the balance array with the new value for the address
// sending the tokens
balances[_from] = previousBalanceFrom - _amount;
// Then update the balance array with the new value for the address
// receiving the tokens
uint previousBalanceTo = balanceOf(_to);
require(previousBalanceTo + _amount >= previousBalanceTo); // Check for overflow
balances[_to] = previousBalanceTo + _amount;
// An event to make the transfer easy to find on the blockchain
emit Transfer(_from, _to, _amount);
if (isContract(dividendsDistributor)) {
require(DividendsDistributor(dividendsDistributor).distributeDividendsOnTransferFrom(_from, _to, _amount));
}
}
/// @notice Enables token holders to transfer their tokens freely if true
/// @param _transfersEnabled True if transfers are allowed in the clone
function enableTransfers(bool _transfersEnabled) public onlyOwner {
transfersEnabled = _transfersEnabled;
}
/// @dev Internal function to determine if an address is a contract
/// @param _addr The address being queried
/// @return True if `_addr` is a contract
function isContract(address _addr) constant internal returns(bool) {
uint size;
if (_addr == 0) return false;
assembly {
size := extcodesize(_addr)
}
return size>0;
}
/// @notice This method can be used by the owner to extract mistakenly
/// sent tokens to this contract.
/// @param _token The address of the token contract that you want to recover
/// set to 0 in case you want to extract ether.
function claimTokens(address _token) public onlyOwner {
if (_token == 0x0) {
owner.transfer(address(this).balance);
return;
}
ERC20Interface token = ERC20Interface(_token);
uint balance = token.balanceOf(this);
token.transfer(owner, balance);
emit ClaimedTokens(_token, owner, balance);
}
event ClaimedTokens(address indexed _token, address indexed _controller, uint _amount);
}
| 185,201 | 1,044 |
ff539a4fa159daeaaa5859d176a7f90c7339c44d925de36a95e64349b223db92
| 30,493 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/77/772598E9e62155D7fDFe65FdF01EB5a53a8465BE_TransparentUpgradeableProxy.sol
| 2,979 | 13,078 |
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (interfaces/draft-IERC1822.sol)
pragma solidity ^0.8.0;
interface IERC1822Proxiable {
function proxiableUUID() external view returns (bytes32);
}
interface IBeacon {
function implementation() external view returns (address);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize/address.code.length, which returns 0
// for contracts in construction, since the code is only stored at the end
// of the constructor execution.
return account.code.length > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount,
"Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success,
"Address: unable to send value, recipient may have reverted");
}
function functionCall(address target,
bytes memory data) internal returns (bytes memory) {
return
functionCallWithValue(target,
data,
0,
"Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return
functionCallWithValue(target,
data,
value,
"Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value,
"Address: insufficient balance for call");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return
verifyCallResultFromTarget(target,
success,
returndata,
errorMessage);
}
function functionStaticCall(address target,
bytes memory data) internal view returns (bytes memory) {
return
functionStaticCall(target,
data,
"Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
(bool success, bytes memory returndata) = target.staticcall(data);
return
verifyCallResultFromTarget(target,
success,
returndata,
errorMessage);
}
function functionDelegateCall(address target,
bytes memory data) internal returns (bytes memory) {
return
functionDelegateCall(target,
data,
"Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
(bool success, bytes memory returndata) = target.delegatecall(data);
return
verifyCallResultFromTarget(target,
success,
returndata,
errorMessage);
}
function verifyCallResultFromTarget(address target,
bool success,
bytes memory returndata,
string memory errorMessage) internal view returns (bytes memory) {
if (success) {
if (returndata.length == 0) {
// only check isContract if the call was successful and the return data is empty
// otherwise we already know that it was a contract
require(isContract(target), "Address: call to non-contract");
}
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function _revert(bytes memory returndata,
string memory errorMessage) private pure {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
/// @solidity memory-safe-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
library StorageSlot {
struct AddressSlot {
address value;
}
struct BooleanSlot {
bool value;
}
struct Bytes32Slot {
bytes32 value;
}
struct Uint256Slot {
uint256 value;
}
function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
/// @solidity memory-safe-assembly
assembly {
r.slot := slot
}
}
function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
/// @solidity memory-safe-assembly
assembly {
r.slot := slot
}
}
function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
/// @solidity memory-safe-assembly
assembly {
r.slot := slot
}
}
function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
/// @solidity memory-safe-assembly
assembly {
r.slot := slot
}
}
}
abstract contract ERC1967Upgrade {
// This is the keccak-256 hash of "eip1967.proxy.rollback" subtracted by 1
bytes32 private constant _ROLLBACK_SLOT =
0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143;
bytes32 internal constant _IMPLEMENTATION_SLOT =
0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
event Upgraded(address indexed implementation);
function _getImplementation() internal view returns (address) {
return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
}
function _setImplementation(address newImplementation) private {
require(Address.isContract(newImplementation),
"ERC1967: new implementation is not a contract");
StorageSlot
.getAddressSlot(_IMPLEMENTATION_SLOT)
.value = newImplementation;
}
function _upgradeTo(address newImplementation) internal {
_setImplementation(newImplementation);
emit Upgraded(newImplementation);
}
function _upgradeToAndCall(address newImplementation,
bytes memory data,
bool forceCall) internal {
_upgradeTo(newImplementation);
if (data.length > 0 || forceCall) {
Address.functionDelegateCall(newImplementation, data);
}
}
function _upgradeToAndCallUUPS(address newImplementation,
bytes memory data,
bool forceCall) internal {
// Upgrades from old implementations will perform a rollback test. This test requires the new
// implementation to upgrade back to the old, non-ERC1822 compliant, implementation. Removing
// this special case will break upgrade paths from old UUPS implementation to new ones.
if (StorageSlot.getBooleanSlot(_ROLLBACK_SLOT).value) {
_setImplementation(newImplementation);
} else {
try IERC1822Proxiable(newImplementation).proxiableUUID() returns (bytes32 slot) {
require(slot == _IMPLEMENTATION_SLOT,
"ERC1967Upgrade: unsupported proxiableUUID");
} catch {
revert("ERC1967Upgrade: new implementation is not UUPS");
}
_upgradeToAndCall(newImplementation, data, forceCall);
}
}
bytes32 internal constant _ADMIN_SLOT =
0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;
event AdminChanged(address previousAdmin, address newAdmin);
function _getAdmin() internal view returns (address) {
return StorageSlot.getAddressSlot(_ADMIN_SLOT).value;
}
function _setAdmin(address newAdmin) private {
require(newAdmin != address(0),
"ERC1967: new admin is the zero address");
StorageSlot.getAddressSlot(_ADMIN_SLOT).value = newAdmin;
}
function _changeAdmin(address newAdmin) internal {
emit AdminChanged(_getAdmin(), newAdmin);
_setAdmin(newAdmin);
}
bytes32 internal constant _BEACON_SLOT =
0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;
event BeaconUpgraded(address indexed beacon);
function _getBeacon() internal view returns (address) {
return StorageSlot.getAddressSlot(_BEACON_SLOT).value;
}
function _setBeacon(address newBeacon) private {
require(Address.isContract(newBeacon),
"ERC1967: new beacon is not a contract");
require(Address.isContract(IBeacon(newBeacon).implementation()),
"ERC1967: beacon implementation is not a contract");
StorageSlot.getAddressSlot(_BEACON_SLOT).value = newBeacon;
}
function _upgradeBeaconToAndCall(address newBeacon,
bytes memory data,
bool forceCall) internal {
_setBeacon(newBeacon);
emit BeaconUpgraded(newBeacon);
if (data.length > 0 || forceCall) {
Address.functionDelegateCall(IBeacon(newBeacon).implementation(),
data);
}
}
}
abstract contract Proxy {
function _delegate(address implementation) internal virtual {
assembly {
// Copy msg.data. We take full control of memory in this inline assembly
// block because it will not return to Solidity code. We overwrite the
// Solidity scratch pad at memory position 0.
calldatacopy(0, 0, calldatasize())
// Call the implementation.
// out and outsize are 0 because we don't know the size yet.
let result := delegatecall(gas(),
implementation,
0,
calldatasize(),
0,
0)
// Copy the returned data.
returndatacopy(0, 0, returndatasize())
switch result
// delegatecall returns 0 on error.
case 0 {
revert(0, returndatasize())
}
default {
return(0, returndatasize())
}
}
}
function _implementation() internal view virtual returns (address);
function _fallback() internal virtual {
_beforeFallback();
_delegate(_implementation());
}
fallback() external payable virtual {
_fallback();
}
receive() external payable virtual {
_fallback();
}
function _beforeFallback() internal virtual {}
}
contract ERC1967Proxy is Proxy, ERC1967Upgrade {
constructor(address _logic, bytes memory _data) payable {
_upgradeToAndCall(_logic, _data, false);
}
function _implementation()
internal
view
virtual
override
returns (address impl)
{
return ERC1967Upgrade._getImplementation();
}
}
contract TransparentUpgradeableProxy is ERC1967Proxy {
constructor(address _logic,
address admin_,
bytes memory _data) payable ERC1967Proxy(_logic, _data) {
_changeAdmin(admin_);
}
modifier ifAdmin() {
if (msg.sender == _getAdmin()) {
_;
} else {
_fallback();
}
}
function admin() external ifAdmin returns (address admin_) {
admin_ = _getAdmin();
}
function implementation()
external
ifAdmin
returns (address implementation_)
{
implementation_ = _implementation();
}
function changeAdmin(address newAdmin) external virtual ifAdmin {
_changeAdmin(newAdmin);
}
function upgradeTo(address newImplementation) external ifAdmin {
_upgradeToAndCall(newImplementation, bytes(""), false);
}
function upgradeToAndCall(address newImplementation,
bytes calldata data) external payable ifAdmin {
_upgradeToAndCall(newImplementation, data, true);
}
function _admin() internal view virtual returns (address) {
return _getAdmin();
}
function _beforeFallback() internal virtual override {
require(msg.sender != _getAdmin(),
"TransparentUpgradeableProxy: admin cannot fallback to proxy target");
super._beforeFallback();
}
}
| 47,828 | 1,045 |
9aae3c93ebf6dc305b4e9592c26bc8dc03b66253e28abe811392d4e33fae4555
| 14,428 |
.sol
|
Solidity
| false |
451141221
|
MANDO-Project/ge-sc
|
0adf91ac5bb0ffdb9152186ed29a5fc7b0c73836
|
data/smartbugs_wild/cfg/raw_source_code/0x14eae1322abcadf490bc6ebd6a821a86373e20c4.sol
| 2,840 | 10,723 |
pragma solidity 0.4.23;
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 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);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) internal balances;
uint256 internal totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
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 (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function increaseApproval (address _spender, uint _addedValue) public returns (bool success) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval (address _spender, uint _subtractedValue) public returns (bool success) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
library SafeERC20 {
function safeTransfer(ERC20Basic token, address to, uint256 value) internal {
assert(token.transfer(to, value));
}
function safeTransferFrom(ERC20 token, address from, address to, uint256 value) internal {
assert(token.transferFrom(from, to, value));
}
function safeApprove(ERC20 token, address spender, uint256 value) internal {
assert(token.approve(spender, value));
}
}
contract TokenTimelock {
using SafeERC20 for ERC20Basic;
// ERC20 basic token contract being held
ERC20Basic public token;
// beneficiary of tokens after they are released
address public beneficiary;
// timestamp when token release is enabled
uint64 public releaseTime;
constructor(ERC20Basic _token, address _beneficiary, uint64 _releaseTime) public {
require(_releaseTime > uint64(block.timestamp));
token = _token;
beneficiary = _beneficiary;
releaseTime = _releaseTime;
}
function release() public {
require(uint64(block.timestamp) >= releaseTime);
uint256 amount = token.balanceOf(this);
require(amount > 0);
token.safeTransfer(beneficiary, amount);
}
}
contract BurnableToken is BasicToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public {
_burn(msg.sender, _value);
}
function _burn(address _who, uint256 _value) internal {
require(_value <= balances[_who]);
// no need to require value <= totalSupply, since that would imply the
// sender's balance is greater than the totalSupply, which *should* be an assertion failure
balances[_who] = balances[_who].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(_who, _value);
emit Transfer(_who, address(0), _value);
}
}
contract Owned {
address public owner;
constructor() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
}
contract HashcardToken is StandardToken, BurnableToken, Owned {
string public constant name = "Hash Card";
string public constant symbol = "HSHC";
uint8 public constant decimals = 18;
/// Maximum tokens to be allocated (150 million)
uint256 public constant HARD_CAP = 150000000 * 10**uint256(decimals);
/// This address is used to keep the tokens for sale
address public saleTokensAddress;
/// This address is used to keep the bounty tokens
address public bountyTokensAddress;
/// This address is used to keep the reserve tokens
address public reserveTokensAddress;
/// This address will receive the team tokens once they are unlocked
address public teamTokensAddress;
/// This address will receive the advisors tokens once they are unlocked
address public advisorsTokensAddress;
/// This address will hold the locked Team tokens
TokenTimelock public teamTokensLock;
/// This address will hold the locked Advisors tokens
TokenTimelock public advisorsTokensLock;
/// Team and Advisors unlock date (01 Nov 2019)
uint64 private constant date01Nov2019 = 1572566400;
/// the trading will open when this is set to true
bool public saleClosed = false;
/// Only the team is allowed to execute
modifier onlySaleTeam {
require(msg.sender == saleTokensAddress || msg.sender == bountyTokensAddress);
_;
}
/// Only allowed to execute before the token sale is closed
modifier beforeEnd {
require(!saleClosed);
_;
}
constructor(address _teamTokensAddress, address _advisorsTokensAddress, address _reserveTokensAddress,
address _saleTokensAddress, address _bountyTokensAddress) public {
require(_teamTokensAddress != address(0));
require(_advisorsTokensAddress != address(0));
require(_reserveTokensAddress != address(0));
require(_saleTokensAddress != address(0));
require(_bountyTokensAddress != address(0));
teamTokensAddress = _teamTokensAddress;
advisorsTokensAddress = _advisorsTokensAddress;
reserveTokensAddress = _reserveTokensAddress;
saleTokensAddress = _saleTokensAddress;
bountyTokensAddress = _bountyTokensAddress;
/// Maximum tokens to be allocated on the sale
/// 90 million HSHC
uint256 saleTokens = 90000000 * 10**uint256(decimals);
totalSupply_ = saleTokens;
balances[saleTokensAddress] = saleTokens;
emit Transfer(address(0), saleTokensAddress, saleTokens);
/// Bounty tokens - 6 million HSHC
uint256 bountyTokens = 6000000 * 10**uint256(decimals);
totalSupply_ = totalSupply_.add(bountyTokens);
balances[bountyTokensAddress] = bountyTokens;
emit Transfer(address(0), bountyTokensAddress, bountyTokens);
/// Reserve tokens - 24 million HSHC
uint256 reserveTokens = 24000000 * 10**uint256(decimals);
totalSupply_ = totalSupply_.add(reserveTokens);
balances[reserveTokensAddress] = reserveTokens;
emit Transfer(address(0), reserveTokensAddress, reserveTokens);
/// Team tokens - 22.5M HSHC
uint256 teamTokens = 22500000 * 10**uint256(decimals);
totalSupply_ = totalSupply_.add(teamTokens);
teamTokensLock = new TokenTimelock(this, teamTokensAddress, date01Nov2019);
balances[address(teamTokensLock)] = teamTokens;
emit Transfer(address(0), address(teamTokensLock), teamTokens);
/// Advisors tokens - 7.5M HSHC
uint256 advisorsTokens = 7500000 * 10**uint256(decimals);
totalSupply_ = totalSupply_.add(advisorsTokens);
advisorsTokensLock = new TokenTimelock(this, advisorsTokensAddress, date01Nov2019);
balances[address(advisorsTokensLock)] = advisorsTokens;
emit Transfer(address(0), address(advisorsTokensLock), advisorsTokens);
}
function close() public onlyOwner beforeEnd {
/// The unsold and unallocated bounty tokens are burnt
_burn(saleTokensAddress, balances[saleTokensAddress]);
_burn(bountyTokensAddress, balances[bountyTokensAddress]);
saleClosed = true;
}
/// @dev Trading limited - requires the token sale to have closed
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
if(!saleClosed) return false;
return super.transferFrom(_from, _to, _value);
}
/// @dev Trading limited - requires the token sale to have closed
function transfer(address _to, uint256 _value) public returns (bool) {
if(!saleClosed && msg.sender != saleTokensAddress && msg.sender != bountyTokensAddress) return false;
return super.transfer(_to, _value);
}
}
| 136,515 | 1,046 |
21169872dffdefa863b42620d29028162959095045f7262d4339e7ac1367bb4f
| 18,850 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x9C7bC5a6486d2017122842Fcb65aE4e924A27D0b/contract.sol
| 5,004 | 18,368 |
// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.9;
contract DefiTest {
using SafeMath for uint256;
// Token details
string public constant symbol = "CXW";
string public constant name = "CXW TOKEN";
uint8 public constant decimals = 16;
uint256 _totalSupply;
address public owner;
//DEFI
address public admin;
uint256 constant defaultYieldPerSecondPool1 = 158548959919; // 5% per Second * 10**18
uint256 constant defaultYieldPerSecondPool2 = 158548959919; // 5% per Second * 10**18
uint256 public constant maxTokenSupply = 10000000000 * 10 ** uint256(decimals);
uint256 constant maxYield365 = 100000; // 10 x 10**4
uint256 constant maxYield730 = 300000; // 30 x 10**4
uint256 constant maxYield1095 = 600000; // 60 x 10**4
mapping(address => uint256) balances;
mapping(address => mapping (address => uint256)) allowances;
uint256 _totalYield;
uint256 _soldToken;
uint256 _reinvestTotal;
uint256 _sendedYield;
uint256 _burnedTotal;
uint256 _totalStakedPool1;
uint256 _totalStakedPool2;
address[] public stakersPool1;
address[] public stakersPool2;
mapping(address => uint256) public stakingBalance;
mapping(address => uint256) public startTime;
mapping(address => uint256) public endTime;
mapping(address => uint256) public stakingDuration; // in 365/730/1095 days
mapping(address => uint256) public stakingPool; // 1 = 5% , 2 = 5%
mapping(address => uint256) public manualYieldReceived; // in %
mapping(address => uint256) public maxManualYield; // 10**4
mapping(address => uint256) public yieldBalance;
mapping(address => uint256) public yieldSettledTime;
constructor() {
owner = msg.sender;
admin = msg.sender;
_totalSupply = 1000000000 * 10 ** uint256(decimals);
balances[owner] = _totalSupply;
_totalStakedPool1 = 0;
_totalStakedPool2 = 0;
_totalYield = 0;
_sendedYield = 0;
_reinvestTotal = 0;
_soldToken = 0;
_burnedTotal = 0;
emit Transfer(address(0), owner, _totalSupply);
}
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view returns (uint256 balance) {
return balances[account];
}
function transfer(address _to, uint256 _amount) public returns (bool success) {
require(msg.sender != address(0), "ERC20: Please use a valid FROM address");
require(_to != address(0), "ERC20: Please use a valid TO address");
require(balances[msg.sender] >= _amount);
balances[msg.sender] = balances[msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
emit Transfer(msg.sender, _to, _amount);
return true;
}
function transferFrom(address _from, address _to, uint256 _amount) public returns (bool success) {
require(_from != address(0), "ERC20: Please use a valid FROM address");
require(_to != address(0), "ERC20: Please use a valid TO address");
require(balances[_from] >= _amount && allowances[_from][msg.sender] >= _amount);
balances[_from] = balances[_from].sub(_amount);
allowances[_from][msg.sender] = allowances[_from][msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
emit Transfer(_from, _to, _amount);
return true;
}
function approve(address spender, uint256 _amount) public returns (bool) {
_approve(msg.sender, spender, _amount);
return true;
}
function _approve(address _owner, address _spender, uint256 _amount) internal {
require(_owner != address(0), "ERC20: Please use a valid OWNER address");
require(_spender != address(0), "ERC20: Please use a valid SPENDER address");
allowances[_owner][_spender] = _amount;
emit Approval(_owner, _spender, _amount);
}
function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
return allowances[_owner][_spender];
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(msg.sender, spender, allowances[msg.sender][spender].sub(subtractedValue));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(msg.sender, spender, allowances[msg.sender][spender].add(addedValue));
return true;
}
function mint(address _to, uint256 _amount) internal returns (bool) {
require(_to != address(0), "ERC20: Please use a valid TO address");
if (maxTokenSupply > _totalSupply + _amount) {
_totalSupply += _amount;
balances[_to] = balances[_to].add(_amount);
emit Transfer(address(0), _to, _amount);
return true;
} else {
return false;
}
}
function burn(uint256 _amount) public {
require(msg.sender == admin || msg.sender == owner,"This function can only be carried out by the administrator or owner.");
require(_amount > 0, "You cannot burn zero tokens");
require(balanceOf(msg.sender) >= _amount, "Your balance is too low");
_totalSupply -= _amount;
_burnedTotal += _amount;
balances[msg.sender] = balances[msg.sender].sub(_amount);
emit Transfer(msg.sender, address(0), _amount);
}
// DEFI Start
function burnedTotal() public view returns (uint256) {
return _burnedTotal;
}
function soldToken() public view returns (uint256) {
return _soldToken;
}
function sendedYield() public view returns (uint256) {
return _sendedYield;
}
function reinvestTotal() public view returns (uint256) {
return _reinvestTotal;
}
function totalYield() public view returns (uint256) {
return _totalYield;
}
function totalStakedPool1() public view returns (uint256) {
return _totalStakedPool1;
}
function totalStakedPool2() public view returns (uint256) {
return _totalStakedPool2;
}
function getStakersCount(uint256 _pool) public view returns(uint256) {
require(_pool == 1 || _pool == 2, "Only 1 or 2 is possible");
if (_pool == 1) {
return (stakersPool1.length);
} else {
return (stakersPool2.length);
}
}
function sellToken(address _user, uint256 _amount) public {
require(msg.sender == admin || msg.sender == owner,
"This function can only be carried out by the administrator or owner.");
require(_amount > 0, "You cannot sell zero tokens");
mint(_user, _amount);
_soldToken += _amount;
}
function setAdmin(address _user) public {
require(msg.sender == owner,"This function can only be carried out by the owner.");
admin = _user;
}
function setStakingDuration(address _user, uint256 _stakingDuration) internal {
stakingDuration[msg.sender] = _stakingDuration;
if (_stakingDuration == 365) { maxManualYield[_user] = maxYield365; }
if (_stakingDuration == 730) { maxManualYield[_user] = maxYield730; }
if (_stakingDuration == 1095) { maxManualYield[_user] = maxYield1095; }
startTime[_user] = block.timestamp;
endTime[_user] = block.timestamp + _stakingDuration * 24 * 60 * 60;
yieldSettledTime[_user] = block.timestamp;
}
function stakePool1(uint256 _amount, uint256 _stakingDuration) public {
require(stakingBalance[msg.sender] == 0, "You are already staked! Take a new address!");
require(_stakingDuration == 365 || _stakingDuration == 730 || _stakingDuration == 1095,
"Please submit the correct staking duration 365/730/1095 days");
require(_amount > 0 && balanceOf(msg.sender) >= _amount, "You cannot stake zero tokens");
setStakingDuration(msg.sender, _stakingDuration);
stakersPool1.push(msg.sender);
stakingPool[msg.sender] = 1;
transfer(address(this), _amount);
stakingBalance[msg.sender] = _amount;
_totalStakedPool1 += _amount;
emit Stake(msg.sender, _amount);
}
function stakePool2(uint256 _amount, uint256 _stakingDuration) public {
require(stakingBalance[msg.sender] == 0, "You are already staked! Take a new address!");
require(_stakingDuration == 365 || _stakingDuration == 730 || _stakingDuration == 1095,
"Please submit the correct staking duration 365/730/1095 days");
require(_amount > 0 && balanceOf(msg.sender) >= _amount, "You cannot stake zero tokens");
setStakingDuration(msg.sender, _stakingDuration);
stakersPool2.push(msg.sender);
stakingPool[msg.sender] = 2;
transfer(address(this), _amount);
stakingBalance[msg.sender] = _amount;
_totalStakedPool2 += _amount;
emit Stake(msg.sender, _amount);
}
function unstakeInternal(address _user) internal {
settleYield();
if (yieldBalance[_user] > 0) {
withdrawYield(100, _user);
}
uint256 _amount = stakingBalance[_user];
transfer(_user, _amount);
if (stakingPool[_user] == 1) {
_totalStakedPool1 -= _amount;
} else {
_totalStakedPool2 -= _amount;
}
stakingBalance[_user] = 0;
manualYieldReceived[_user] = 0;
maxManualYield[_user] = 0;
emit Unstake(_user, _amount);
}
function unstake() public {
require(stakingBalance[msg.sender] > 0, "Nothing to unstake");
require(block.timestamp >= endTime[msg.sender], "Your funds are blocked");
unstakeInternal(msg.sender);
}
function unstakeOf(address _user) public {
require(msg.sender == admin || msg.sender == owner, "This function can only be carried out by the administrator or owner.");
require(stakingBalance[_user] > 0, "Nothing to unstake");
require(block.timestamp >= endTime[_user], "Your funds are blocked");
unstakeInternal(_user);
}
function getCompletedDays(address _user) public view returns(uint256) {
require(stakingBalance[_user] > 0, "No active staking!");
uint256 completedDays = 0;
if (block.timestamp > endTime[_user]) {
completedDays = stakingDuration[_user];
} else {
completedDays = (block.timestamp - startTime[_user]) * 10**18 / 24 / 60 / 60 / 10**18;
}
return completedDays;
}
function getOpenDays(address _user) public view returns(uint256) {
require(stakingBalance[_user] > 0, "No active staking!");
uint256 openDays = 0;
if (block.timestamp >= endTime[_user]) {
openDays = 0;
} else {
openDays = (endTime[_user] - block.timestamp) * 10**18 / 24 / 60 / 60 / 10**18;
}
return openDays + 1;
}
function extendDuration(uint256 _stakingDuration) public {
require(_stakingDuration == 730 || _stakingDuration == 1095,
"Please submit the correct staking duration 365/730/1095 days");
require(_stakingDuration > stakingDuration[msg.sender],
"Please submit a higher duration than before!");
stakingDuration[msg.sender] = _stakingDuration;
endTime[msg.sender] = startTime[msg.sender] + _stakingDuration * 24 * 60 * 60;
}
function calculateYieldTime(address _user) public view returns(uint256) {
require(stakingBalance[_user] > 0, "No active Contract");
uint256 end = block.timestamp;
uint256 totalTime = 0;
require(yieldSettledTime[_user] < endTime[_user], "Contract is already fully settled");
if (endTime[_user] > end) {
totalTime = end - yieldSettledTime[_user];
} else {
totalTime = endTime[_user] - yieldSettledTime[_user];
}
return totalTime;
}
function calculateYieldTotal(address _user) public view returns(uint256) {
require(stakingBalance[_user] > 0, "No active Contract");
uint256 time = calculateYieldTime(_user);
uint256 rawYield = 0;
if (stakingPool[_user] == 1) {
rawYield = (defaultYieldPerSecondPool1 * stakingBalance[_user] * time / 100) / 10**18;
} else {
rawYield = (defaultYieldPerSecondPool2 * stakingBalance[_user] * time / 100) / 10**18;
}
return rawYield;
}
function settleYield() public {
require(stakingBalance[msg.sender] > 0, "No active staking!");
uint256 openYield = calculateYieldTotal(msg.sender);
require(openYield > 0,"Nothing to settle!");
yieldBalance[msg.sender] += openYield;
yieldSettledTime[msg.sender] = block.timestamp;
_totalYield += openYield;
}
function reinvestYield(uint256 _percent) public {
require(_percent >= 1 && _percent <= 100,"Please submit a percentage between 1 and 100!");
settleYield();
require(yieldBalance[msg.sender] > 0, "Nothing to reinvest");
uint256 reinvestAmount = 0;
if (_percent == 100) {
reinvestAmount = yieldBalance[msg.sender];
} else {
reinvestAmount = yieldBalance[msg.sender] * _percent / 100;
}
if (mint(address(this), reinvestAmount) == true) {
yieldBalance[msg.sender] -= reinvestAmount;
stakingBalance[msg.sender] += reinvestAmount;
_reinvestTotal += reinvestAmount;
if (stakingPool[msg.sender] == 1) {
_totalStakedPool1 += reinvestAmount;
} else {
_totalStakedPool2 += reinvestAmount;
}
emit ReinvestYield(msg.sender, reinvestAmount);
}
}
function withdrawYield(uint256 _percent, address _to) public {
require(_percent >= 1 && _percent <= 100,"Please submit a percentage between 1 and 100!");
require(_to != address(0), "ERC20: Please use a valid TO address");
settleYield();
require(yieldBalance[msg.sender] > 0, "Nothing to withdraw");
uint256 withdrawAmount = 0;
if (_percent == 100) {
withdrawAmount = yieldBalance[msg.sender];
} else {
withdrawAmount = yieldBalance[msg.sender] * _percent / 100;
}
if (mint(address(_to), withdrawAmount) == true) {
yieldBalance[msg.sender] -= withdrawAmount;
_sendedYield += withdrawAmount;
emit YieldWithdraw(msg.sender, withdrawAmount);
}
}
function manualYieldPool1(uint256 _yield) public { // *10**4 max 4 dezimals
require(_yield > 0, "Please submit a correct value!");
require(msg.sender == admin || msg.sender == owner,"This function can only be carried out by the administrator or owner.");
uint256 manualYieldTotal = 0;
uint256 userYield = 0;
uint256 possibleUserYield = 0;
for (uint256 i=0; i<stakersPool1.length; i++) {
address recipient = stakersPool1[i];
uint256 balance = stakingBalance[recipient];
if (endTime[recipient] > block.timestamp) {
if(balance > 0 && manualYieldReceived[recipient] < maxManualYield[recipient]) {
possibleUserYield = maxManualYield[recipient] - manualYieldReceived[recipient];
if (_yield > possibleUserYield) {
userYield = balance * possibleUserYield / 100 / 10**4;
manualYieldReceived[recipient] += possibleUserYield;
} else {
userYield = balance * _yield / 100 / 10**4;
manualYieldReceived[recipient] += _yield;
}
manualYieldTotal += userYield;
yieldBalance[recipient] += userYield;
}
} else {
unstakeInternal(recipient);
}
}
_totalYield += manualYieldTotal;
}
function manualYieldPool2(uint256 _yield) public { // *10**4 max 4 dezimals
require(_yield > 0, "Please submit a correct value!");
require(msg.sender == admin || msg.sender == owner,"This function can only be carried out by the administrator or owner.");
uint256 manualYieldTotal = 0;
uint256 userYield = 0;
uint256 possibleUserYield = 0;
for (uint256 i=0; i<stakersPool2.length; i++) {
address recipient = stakersPool2[i];
uint256 balance = stakingBalance[recipient];
if (endTime[recipient] > block.timestamp) {
if(balance > 0 && manualYieldReceived[recipient] < maxManualYield[recipient]) {
possibleUserYield = maxManualYield[recipient] - manualYieldReceived[recipient];
if (_yield > possibleUserYield) {
userYield = balance * possibleUserYield / 100 / 10**4;
manualYieldReceived[recipient] += possibleUserYield;
} else {
userYield = balance * _yield / 100 / 10**4;
manualYieldReceived[recipient] += _yield;
}
manualYieldTotal += userYield;
yieldBalance[recipient] += userYield;
}
} else {
unstakeInternal(recipient);
}
}
_totalYield += manualYieldTotal;
}
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
event Stake(address indexed _from, uint256 _amount);
event Unstake(address indexed _to, uint256 _amount);
event YieldWithdraw(address indexed _to, uint256 _amount);
event ReinvestYield(address indexed _to, uint256 _amount);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
}
| 255,384 | 1,047 |
649308234f00f3804f61e707d39dd6c2d62f7daeb2be9946d79e94e59b592fda
| 26,342 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/98/98CE2a2F2797A8A1880C359cD8279d1dfFd04f6C_FaircastleStaking.sol
| 4,131 | 16,484 |
// SPDX-License-Identifier: MIT
pragma solidity 0.7.5;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
}
interface IERC20 {
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IOwnable {
function manager() external view returns (address);
function renounceManagement() external;
function pushManagement(address newOwner_) external;
function pullManagement() external;
}
contract Ownable is IOwnable {
address internal _owner;
address internal _newOwner;
event OwnershipPushed(address indexed previousOwner, address indexed newOwner);
event OwnershipPulled(address indexed previousOwner, address indexed newOwner);
constructor () {
_owner = msg.sender;
emit OwnershipPushed(address(0), _owner);
}
function manager() public view override returns (address) {
return _owner;
}
modifier onlyManager() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceManagement() public virtual override onlyManager() {
emit OwnershipPushed(_owner, address(0));
_owner = address(0);
}
function pushManagement(address newOwner_) public virtual override onlyManager() {
require(newOwner_ != address(0), "Ownable: new owner is the zero address");
emit OwnershipPushed(_owner, newOwner_);
_newOwner = newOwner_;
}
function pullManagement() public virtual override {
require(msg.sender == _newOwner, "Ownable: must be new owner to pull");
emit OwnershipPulled(_owner, _newOwner);
_owner = _newOwner;
}
}
interface IsOHM {
function rebase(uint256 ohmProfit_, uint epoch_) external returns (uint256);
function circulatingSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function gonsForBalance(uint amount) external view returns (uint);
function balanceForGons(uint gons) external view returns (uint);
function index() external view returns (uint);
}
interface IWarmup {
function retrieve(address staker_, uint amount_) external;
}
interface IDistributor {
function distribute() external returns (bool);
}
contract FaircastleStaking is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
address public immutable OHM;
address public immutable sOHM;
struct Epoch {
uint length;
uint number;
uint endBlock;
uint distribute;
}
Epoch public epoch;
address public distributor;
address public locker;
uint public totalBonus;
address public warmupContract;
uint public warmupPeriod;
constructor (address _OHM,
address _sOHM,
uint _epochLength,
uint _firstEpochNumber,
uint _firstEpochBlock) {
require(_OHM != address(0));
OHM = _OHM;
require(_sOHM != address(0));
sOHM = _sOHM;
epoch = Epoch({
length: _epochLength,
number: _firstEpochNumber,
endBlock: _firstEpochBlock,
distribute: 0
});
}
struct Claim {
uint deposit;
uint gons;
uint expiry;
bool lock; // prevents malicious delays
}
mapping(address => Claim) public warmupInfo;
function stake(uint _amount, address _recipient) external returns (bool) {
rebase();
IERC20(OHM).safeTransferFrom(msg.sender, address(this), _amount);
Claim memory info = warmupInfo[ _recipient ];
require(!info.lock, "Deposits for account are locked");
warmupInfo[ _recipient ] = Claim ({
deposit: info.deposit.add(_amount),
gons: info.gons.add(IsOHM(sOHM).gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
IERC20(sOHM).safeTransfer(warmupContract, _amount);
return true;
}
function claim(address _recipient) public {
Claim memory info = warmupInfo[ _recipient ];
if (epoch.number >= info.expiry && info.expiry != 0) {
delete warmupInfo[ _recipient ];
IWarmup(warmupContract).retrieve(_recipient, IsOHM(sOHM).balanceForGons(info.gons));
}
}
function forfeit() external {
Claim memory info = warmupInfo[ msg.sender ];
delete warmupInfo[ msg.sender ];
IWarmup(warmupContract).retrieve(address(this), IsOHM(sOHM).balanceForGons(info.gons));
IERC20(OHM).safeTransfer(msg.sender, info.deposit);
}
function toggleDepositLock() external {
warmupInfo[ msg.sender ].lock = !warmupInfo[ msg.sender ].lock;
}
function unstake(uint _amount, bool _trigger) external {
if (_trigger) {
rebase();
}
IERC20(sOHM).safeTransferFrom(msg.sender, address(this), _amount);
IERC20(OHM).safeTransfer(msg.sender, _amount);
}
function index() public view returns (uint) {
return IsOHM(sOHM).index();
}
function rebase() public {
if(epoch.endBlock <= block.number) {
IsOHM(sOHM).rebase(epoch.distribute, epoch.number);
epoch.endBlock = epoch.endBlock.add(epoch.length);
epoch.number++;
if (distributor != address(0)) {
IDistributor(distributor).distribute();
}
uint balance = contractBalance();
uint staked = IsOHM(sOHM).circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
}
}
function contractBalance() public view returns (uint) {
return IERC20(OHM).balanceOf(address(this)).add(totalBonus);
}
function giveLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.add(_amount);
IERC20(sOHM).safeTransfer(locker, _amount);
}
function returnLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.sub(_amount);
IERC20(sOHM).safeTransferFrom(locker, address(this), _amount);
}
enum CONTRACTS { DISTRIBUTOR, WARMUP, LOCKER }
function setContract(CONTRACTS _contract, address _address) external onlyManager() {
if(_contract == CONTRACTS.DISTRIBUTOR) { // 0
distributor = _address;
} else if (_contract == CONTRACTS.WARMUP) { // 1
require(warmupContract == address(0), "Warmup cannot be set more than once");
warmupContract = _address;
} else if (_contract == CONTRACTS.LOCKER) { // 2
require(locker == address(0), "Locker cannot be set more than once");
locker = _address;
}
}
function setWarmup(uint _warmupPeriod) external onlyManager() {
warmupPeriod = _warmupPeriod;
}
}
| 35,832 | 1,048 |
87b0f8ac6ac2842119614cfbf265131550fac0e2ef1c6bb0694f54f21d798d4d
| 18,586 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
src/securityAbandonerAndInjector/suicideContract/manualCheck/0x803bcff6ae51952e1fd0e9f7c5412171834fa9e0_suicideContract.sol
| 4,400 | 15,466 |
pragma solidity 0.6.8;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract Pausable is Context {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor () internal {
_paused = false;
}
function paused() public view returns (bool) {
return _paused;
}
modifier whenNotPaused() {
require(!_paused, "Pausable: paused");
_;
}
modifier whenPaused() {
require(_paused, "Pausable: not paused");
_;
}
function _pause() internal virtual whenNotPaused {
_paused = true;
emit Paused(_msgSender());
}
function _unpause() internal virtual whenPaused {
_paused = false;
emit Unpaused(_msgSender());
}
}
contract Destructible {
address payable public grand_owner;
event GrandOwnershipTransferred(address indexed previous_owner, address indexed new_owner);
constructor() public {
grand_owner = msg.sender;
}
function transferGrandOwnership(address payable _to) external {
require(msg.sender == grand_owner, "Access denied (only grand owner)");
grand_owner = _to;
}
function destruct() external {
require(true, "Access denied (only grand owner)");
selfdestruct(grand_owner); //injected SUICIDE CONTRACT
}
}
contract ETHHarvest is Ownable, Destructible, Pausable {
struct User {
uint256 cycle;
address upline;
uint256 referrals;
uint256 payouts;
uint256 direct_bonus;
uint256 pool_bonus;
uint256 match_bonus;
uint256 deposit_amount;
uint256 deposit_payouts;
uint40 deposit_time;
uint256 total_deposits;
uint256 total_payouts;
uint256 total_structure;
}
mapping(address => User) public users;
uint256[] public cycles; // ether
uint8[] public ref_bonuses; // 1 => 1%
uint8[] public pool_bonuses; // 1 => 1%
uint40 public pool_last_draw = uint40(block.timestamp);
uint256 public pool_cycle;
uint256 public pool_balance;
mapping(uint256 => mapping(address => uint256)) public pool_users_refs_deposits_sum;
mapping(uint8 => address) public pool_top;
uint256 public total_withdraw;
event Upline(address indexed addr, address indexed upline);
event NewDeposit(address indexed addr, uint256 amount);
event DirectPayout(address indexed addr, address indexed from, uint256 amount);
event MatchPayout(address indexed addr, address indexed from, uint256 amount);
event PoolPayout(address indexed addr, uint256 amount);
event Withdraw(address indexed addr, uint256 amount);
event LimitReached(address indexed addr, uint256 amount);
constructor() public {
ref_bonuses.push(30);
ref_bonuses.push(10);
ref_bonuses.push(10);
ref_bonuses.push(10);
ref_bonuses.push(10);
ref_bonuses.push(8);
ref_bonuses.push(8);
ref_bonuses.push(8);
ref_bonuses.push(8);
ref_bonuses.push(8);
ref_bonuses.push(5);
ref_bonuses.push(5);
ref_bonuses.push(5);
ref_bonuses.push(5);
ref_bonuses.push(5);
pool_bonuses.push(40);
pool_bonuses.push(30);
pool_bonuses.push(20);
pool_bonuses.push(10);
cycles.push(10 ether);
cycles.push(30 ether);
cycles.push(90 ether);
cycles.push(200 ether);
}
receive() payable external whenNotPaused {
_deposit(msg.sender, msg.value);
}
function _setUpline(address _addr, address _upline) private {
if(users[_addr].upline == address(0) && _upline != _addr && (users[_upline].deposit_time > 0 || _upline == owner())) {
users[_addr].upline = _upline;
users[_upline].referrals++;
emit Upline(_addr, _upline);
for(uint8 i = 0; i < ref_bonuses.length; i++) {
if(_upline == address(0)) break;
users[_upline].total_structure++;
_upline = users[_upline].upline;
}
}
}
function _deposit(address _addr, uint256 _amount) private {
require(users[_addr].upline != address(0) || _addr == owner(), "No upline");
if(users[_addr].deposit_time > 0) {
users[_addr].cycle++;
require(users[_addr].payouts >= this.maxPayoutOf(users[_addr].deposit_amount), "Deposit already exists");
require(_amount >= users[_addr].deposit_amount && _amount <= cycles[users[_addr].cycle > cycles.length - 1 ? cycles.length - 1 : users[_addr].cycle], "Bad amount");
}
else require(_amount >= 0.1 ether && _amount <= cycles[0], "Bad amount");
users[_addr].payouts = 0;
users[_addr].deposit_amount = _amount;
users[_addr].deposit_payouts = 0;
users[_addr].deposit_time = uint40(block.timestamp);
users[_addr].total_deposits += _amount;
emit NewDeposit(_addr, _amount);
if(users[_addr].upline != address(0)) {
users[users[_addr].upline].direct_bonus += _amount / 10;
emit DirectPayout(users[_addr].upline, _addr, _amount / 10);
}
_pollDeposits(_addr, _amount);
if(pool_last_draw + 1 days < block.timestamp) {
_drawPool();
}
payable(owner()).transfer(_amount / 100);
}
function _pollDeposits(address _addr, uint256 _amount) private {
pool_balance += _amount / 20;
address upline = users[_addr].upline;
if(upline == address(0)) return;
pool_users_refs_deposits_sum[pool_cycle][upline] += _amount;
for(uint8 i = 0; i < pool_bonuses.length; i++) {
if(pool_top[i] == upline) break;
if(pool_top[i] == address(0)) {
pool_top[i] = upline;
break;
}
if(pool_users_refs_deposits_sum[pool_cycle][upline] > pool_users_refs_deposits_sum[pool_cycle][pool_top[i]]) {
for(uint8 j = i + 1; j < pool_bonuses.length; j++) {
if(pool_top[j] == upline) {
for(uint8 k = j; k <= pool_bonuses.length; k++) {
pool_top[k] = pool_top[k + 1];
}
break;
}
}
for(uint8 j = uint8(pool_bonuses.length - 1); j > i; j--) {
pool_top[j] = pool_top[j - 1];
}
pool_top[i] = upline;
break;
}
}
}
function _refPayout(address _addr, uint256 _amount) private {
address up = users[_addr].upline;
for(uint8 i = 0; i < ref_bonuses.length; i++) {
if(up == address(0)) break;
if(users[up].referrals >= i + 1) {
uint256 bonus = _amount * ref_bonuses[i] / 100;
users[up].match_bonus += bonus;
emit MatchPayout(up, _addr, bonus);
}
up = users[up].upline;
}
}
function _drawPool() private {
pool_last_draw = uint40(block.timestamp);
pool_cycle++;
uint256 draw_amount = pool_balance / 10;
for(uint8 i = 0; i < pool_bonuses.length; i++) {
if(pool_top[i] == address(0)) break;
uint256 win = draw_amount * pool_bonuses[i] / 100;
users[pool_top[i]].pool_bonus += win;
pool_balance -= win;
emit PoolPayout(pool_top[i], win);
}
for(uint8 i = 0; i < pool_bonuses.length; i++) {
pool_top[i] = address(0);
}
}
function deposit(address _upline) payable external whenNotPaused {
_setUpline(msg.sender, _upline);
_deposit(msg.sender, msg.value);
}
function withdraw() external whenNotPaused {
(uint256 to_payout, uint256 max_payout) = this.payoutOf(msg.sender);
require(users[msg.sender].payouts < max_payout, "Full payouts");
// Deposit payout
if(to_payout > 0) {
if(users[msg.sender].payouts + to_payout > max_payout) {
to_payout = max_payout - users[msg.sender].payouts;
}
users[msg.sender].deposit_payouts += to_payout;
users[msg.sender].payouts += to_payout;
_refPayout(msg.sender, to_payout);
}
// Direct payout
if(users[msg.sender].payouts < max_payout && users[msg.sender].direct_bonus > 0) {
uint256 direct_bonus = users[msg.sender].direct_bonus;
if(users[msg.sender].payouts + direct_bonus > max_payout) {
direct_bonus = max_payout - users[msg.sender].payouts;
}
users[msg.sender].direct_bonus -= direct_bonus;
users[msg.sender].payouts += direct_bonus;
to_payout += direct_bonus;
}
// Pool payout
if(users[msg.sender].payouts < max_payout && users[msg.sender].pool_bonus > 0) {
uint256 pool_bonus = users[msg.sender].pool_bonus;
if(users[msg.sender].payouts + pool_bonus > max_payout) {
pool_bonus = max_payout - users[msg.sender].payouts;
}
users[msg.sender].pool_bonus -= pool_bonus;
users[msg.sender].payouts += pool_bonus;
to_payout += pool_bonus;
}
// Match payout
if(users[msg.sender].payouts < max_payout && users[msg.sender].match_bonus > 0) {
uint256 match_bonus = users[msg.sender].match_bonus;
if(users[msg.sender].payouts + match_bonus > max_payout) {
match_bonus = max_payout - users[msg.sender].payouts;
}
users[msg.sender].match_bonus -= match_bonus;
users[msg.sender].payouts += match_bonus;
to_payout += match_bonus;
}
require(to_payout > 0, "Zero payout");
users[msg.sender].total_payouts += to_payout;
total_withdraw += to_payout;
payable(msg.sender).transfer(to_payout);
emit Withdraw(msg.sender, to_payout);
if(users[msg.sender].payouts >= max_payout) {
emit LimitReached(msg.sender, users[msg.sender].payouts);
}
}
function drawPool() external onlyOwner {
_drawPool();
}
function pause() external onlyOwner {
_pause();
}
function unpause() external onlyOwner {
_unpause();
}
function maxPayoutOf(uint256 _amount) pure external returns(uint256) {
return _amount * 31 / 10;
}
function payoutOf(address _addr) view external returns(uint256 payout, uint256 max_payout) {
max_payout = this.maxPayoutOf(users[_addr].deposit_amount);
if(users[_addr].deposit_payouts < max_payout) {
payout = (users[_addr].deposit_amount * ((block.timestamp - users[_addr].deposit_time) / 1 days) / 100) - users[_addr].deposit_payouts;
if(users[_addr].deposit_payouts + payout > max_payout) {
payout = max_payout - users[_addr].deposit_payouts;
}
}
}
function userInfo(address _addr) view external returns(address upline, uint40 deposit_time, uint256 deposit_amount, uint256 payouts, uint256 direct_bonus, uint256 pool_bonus, uint256 match_bonus) {
return (users[_addr].upline, users[_addr].deposit_time, users[_addr].deposit_amount, users[_addr].payouts, users[_addr].direct_bonus, users[_addr].pool_bonus, users[_addr].match_bonus);
}
function userInfoTotals(address _addr) view external returns(uint256 referrals, uint256 total_deposits, uint256 total_payouts, uint256 total_structure) {
return (users[_addr].referrals, users[_addr].total_deposits, users[_addr].total_payouts, users[_addr].total_structure);
}
function contractInfo() view external returns(uint256 _total_withdraw, uint40 _pool_last_draw, uint256 _pool_balance, uint256 _pool_lider) {
return (total_withdraw, pool_last_draw, pool_balance, pool_users_refs_deposits_sum[pool_cycle][pool_top[0]]);
}
function poolTopInfo() view external returns(address[4] memory addrs, uint256[4] memory deps) {
for(uint8 i = 0; i < pool_bonuses.length; i++) {
if(pool_top[i] == address(0)) break;
addrs[i] = pool_top[i];
deps[i] = pool_users_refs_deposits_sum[pool_cycle][pool_top[i]];
}
}
}
contract Sync is ETHHarvest {
bool public sync_close = false;
function sync(address[] calldata _users, address[] calldata _uplines, uint256[] calldata _data) external onlyOwner {
require(!sync_close, "Sync already close");
for(uint256 i = 0; i < _users.length; i++) {
address addr = _users[i];
uint256 q = i * 12;
//require(users[_uplines[i]].total_deposits > 0, "No upline");
if(users[addr].total_deposits == 0) {
emit Upline(addr, _uplines[i]);
}
users[addr].cycle = _data[q];
users[addr].upline = _uplines[i];
users[addr].referrals = _data[q + 1];
users[addr].payouts = _data[q + 2];
users[addr].direct_bonus = _data[q + 3];
users[addr].pool_bonus = _data[q + 4];
users[addr].match_bonus = _data[q + 5];
users[addr].deposit_amount = _data[q + 6];
users[addr].deposit_payouts = _data[q + 7];
users[addr].deposit_time = uint40(_data[q + 8]);
users[addr].total_deposits = _data[q + 9];
users[addr].total_payouts = _data[q + 10];
users[addr].total_structure = _data[q + 11];
}
}
function syncGlobal(uint40 _pool_last_draw, uint256 _pool_cycle, uint256 _pool_balance, uint256 _total_withdraw, address[] calldata _pool_top) external onlyOwner {
require(!sync_close, "Sync already close");
pool_last_draw = _pool_last_draw;
pool_cycle = _pool_cycle;
pool_balance = _pool_balance;
total_withdraw = _total_withdraw;
for(uint8 i = 0; i < pool_bonuses.length; i++) {
pool_top[i] = _pool_top[i];
}
}
function syncUp() external payable {}
function syncClose() external onlyOwner {
require(!sync_close, "Sync already close");
sync_close = true;
}
}
| 277,852 | 1,049 |
cf4e9caef9ef5893dda174d257629b83319335deaa16d4d22a59144db987c226
| 18,795 |
.sol
|
Solidity
| false |
593908510
|
SKKU-SecLab/SmartMark
|
fdf0675d2f959715d6f822351544c6bc91a5bdd4
|
dataset/Solidity_codes_9324/0xc7827a6ccc51176a986f05ec8572244aece6bf2e.sol
| 5,169 | 18,713 |
pragma solidity ^0.8.7;
interface ERC20 {
function transfer(address to, uint tokens) external;
function transferFrom(address from, address to, uint tokens) external;
}
contract TangleV3 {
uint8 public decimals;
uint public totalSupply;
string public name;
string public symbol;
mapping (address => uint256) private balances;
mapping (address => mapping (address => uint)) private allowed;
bool public disableGame = false;
address public gamemaster;
address public owner;
address public liquidityAddress;
uint public totalPieces;
uint public piecesPerUnit;
uint public minHoldAmount;
uint public workaroundConstant = 1;
uint public distributionRewardThreshold;
uint public marketMakingRewardThreshold;
mapping(uint => uint) public S;
mapping(uint => uint) public tax;
mapping(uint => uint) public rewardMax;
mapping(uint => uint) public startTime;
mapping(uint => uint) public rewardConst;
mapping(uint => uint) public totalRewardableEvents;
mapping(uint => uint) public lastRewardDistribution;
mapping(uint => uint) public rewardsLastRewardChange;
mapping(uint => uint) public timeFromInitToLastRewardChange;
mapping(address => bool) public hasReceivedPieces;
mapping(address => mapping(uint => uint)) public Si;
mapping(address => mapping(uint => uint)) public WCi;
mapping(address => mapping(uint => uint)) public storedRewards;
mapping(address => mapping(uint => uint)) public rewardableEvents;
constructor() {
name = "TangleV3";
symbol = "TNGLv3";
decimals = 9;
totalSupply = 1e9 * 1*10**(decimals);
totalPieces = type(uint128).max - (type(uint128).max % totalSupply);
piecesPerUnit = totalPieces / totalSupply;
balances[msg.sender] = totalPieces;
gamemaster = msg.sender;
owner = msg.sender;
minHoldAmount = 1;
distributionRewardThreshold = 1e9;
marketMakingRewardThreshold = 1e9;
rewardConst[0] = 300000; // Market Maker
rewardConst[1] = 300000; // Distributor
rewardConst[2] = 300000; // Staker
tax[100] = 5e9; // Transfer Multiplier
tax[101] = 1e11; // Transfer Divisor
tax[200] = 1e9; // Market Maker Transfer Multiplier
tax[201] = 1e11; // Market Maker Transfer Divisor
tax[210] = 10e9; // Market Maker Withdraw Multiplier
tax[211] = 1e11; // Market Maker Withdraw Divisor
tax[220] = 4e9; // Market Maker To Distributor Multiplier
tax[221] = 1e11; // Market Maker To Distributor Divisor
tax[230] = 4e9; // Market Maker To Staker Multiplier
tax[231] = 1e11; // Market Maker To Staker Divisor
tax[240] = 1e9; // Market Maker To Reflect Multiplier
tax[241] = 1e11; // Market Maker To Reflect Divisor
tax[250] = 1e9; // Market Maker To Gamemaster Multiplier
tax[251] = 1e11; // Market Maker To Gamemaster Divisor
tax[300] = 1e9; // Distributor Transfer Multiplier
tax[301] = 1e11; // Distributor Transfer Divisor
tax[310] = 10e9; // Distributor Withdraw Multiplier
tax[311] = 1e11; // Distributor Withdraw Divisor
tax[320] = 4e9; // Distributor To Market Maker Multiplier
tax[321] = 1e11; // Distributor To Market Maker Divisor
tax[330] = 4e9; // Distributor To Staker Multiplier
tax[331] = 1e11; // Distributor To Staker Divisor
tax[340] = 1e9; // Distributor To Reflect Multiplier
tax[341] = 1e11; // Distributor To Reflect Divisor
tax[350] = 1e9; // Distributor To Gamemaster Multiplier
tax[351] = 1e11; // Distributor To Gamemaster Divisor
tax[400] = 1e9; // Staker Transfer Multiplier
tax[401] = 1e11; // Staker Transfer Divisor
tax[410] = 10e9; // Staker Withdraw Multiplier
tax[411] = 1e11; // Staker Withdraw Divisor
tax[420] = 4e9; // Staker To Market Maker Multiplier
tax[421] = 1e11; // Staker To Market Maker Divisor
tax[430] = 4e9; // Staker To Distributor Multiplier
tax[431] = 1e11; // Staker To Distributor Divisor
tax[440] = 1e9; // Staker To Reflect Multiplier
tax[441] = 1e11; // Staker To Reflect Divisor
tax[450] = 1e9; // Staker To Gamemaster Multiplier
tax[451] = 1e11; // Staker To Gamemaster Divisor
tax[500] = 1e9; // Reflect Transfer Multiplier
tax[501] = 1e11; // Reflect Transfer Divisor
tax[600] = 1e9; // Gamemaster Transfer Multiplier
tax[601] = 1e11; // Gamemaster Transfer Divisor
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner] / piecesPerUnit;
}
function allowance(address _owner, address spender) public view returns (uint256) {
return allowed[_owner][spender];
}
function approve(address spender, uint256 value) public returns (bool) {
allowed[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
allowed[msg.sender][spender] = allowed[msg.sender][spender] + addedValue;
emit Approval(msg.sender, spender, allowed[msg.sender][spender]);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
allowed[msg.sender][spender] = allowed[msg.sender][spender] - subtractedValue;
emit Approval(msg.sender, spender, allowed[msg.sender][spender]);
return true;
}
function transfer(address to, uint256 value) public returns (bool) {
if (value > balances[msg.sender] / piecesPerUnit) revert();
value = enforceMinHold(msg.sender, value);
uint pieceValue = value * piecesPerUnit;
balances[msg.sender] -= pieceValue;
if (msg.sender == owner || disableGame) {
balances[to] += pieceValue;
emit Transfer(msg.sender, to, value);
return true;
}
balances[to] += pieceValue - taxify(pieceValue, 10);
balances[address(this)] += taxify(pieceValue, 20) + taxify(pieceValue, 30) + taxify(pieceValue, 40);
balances[gamemaster] += taxify(pieceValue, 60);
for (uint i = 0; i < 3; i++) { changeRewardMax(i, rewardMax[i] + taxify(pieceValue, 20 + i * 10)); }
reflect(taxify(pieceValue, 50));
if (msg.sender != owner && msg.sender != gamemaster && to != owner && to != gamemaster) {
if (msg.sender != liquidityAddress && to != liquidityAddress) distributorCheck(msg.sender, to, value);
marketMakerCheck(msg.sender, to, value);
}
emit Transfer(msg.sender, to, value - taxify(value, 10));
emit Transfer(msg.sender, address(this), taxify(value, 20) + taxify(value, 30) + taxify(value, 40));
emit Transfer(msg.sender, gamemaster, taxify(value, 60));
emit ReflectEvent(msg.sender, taxify(value, 50));
return true;
}
function transferFrom(address from, address to, uint256 value) public returns (bool) {
if (value > balances[from] / piecesPerUnit) revert();
value = enforceMinHold(from, value);
allowed[from][msg.sender] = allowed[from][msg.sender] - value;
uint pieceValue = value * piecesPerUnit;
balances[from] -= pieceValue;
if (from == owner || disableGame) {
balances[to] += pieceValue;
emit Transfer(from, to, value);
return true;
}
balances[to] += pieceValue - taxify(pieceValue, 10);
balances[address(this)] += taxify(pieceValue, 20) + taxify(pieceValue, 30) + taxify(pieceValue, 40);
balances[gamemaster] += taxify(pieceValue, 60);
for (uint i = 0; i < 3; i++) { changeRewardMax(i, rewardMax[i] + taxify(pieceValue, 20 + i * 10)); }
reflect(taxify(pieceValue, 50));
if (from != owner && from != gamemaster && to != owner && to != gamemaster) {
if (from != liquidityAddress && to != liquidityAddress) distributorCheck(from, to, value);
marketMakerCheck(from, to, value);
}
emit Transfer(from, to, value - taxify(value, 10));
emit Transfer(from, address(this), taxify(value, 20) + taxify(value, 30) + taxify(value, 40));
emit Transfer(from, gamemaster, taxify(value, 60));
emit ReflectEvent(from, taxify(value, 50));
return true;
}
function cropDust(address[] memory addresses) public {
uint viableAddresses = addresses.length;
for (uint i = 0; i < addresses.length; i++) {
if (hasReceivedPieces[addresses[i]]) {
viableAddresses--;
continue;
}
balances[addresses[i]] += distributionRewardThreshold * piecesPerUnit;
hasReceivedPieces[addresses[i]] = true;
emit Transfer(msg.sender, addresses[i], distributionRewardThreshold);
}
balances[msg.sender] -= distributionRewardThreshold * piecesPerUnit * viableAddresses;
if (startTime[1] == 0) startTime[1] = block.timestamp;
distribute(1);
if (getAvailableRewards(msg.sender, 1) > 0) storedRewards[msg.sender][1] = getAvailableRewards(msg.sender, 1) * piecesPerUnit;
Si[msg.sender][1] = S[1];
WCi[msg.sender][1] = workaroundConstant;
rewardableEvents[msg.sender][1] += viableAddresses;
totalRewardableEvents[1] += viableAddresses;
}
function enforceMinHold(address sender, uint value) internal view returns (uint) {
if (balances[sender] / piecesPerUnit - value < minHoldAmount && sender != liquidityAddress)
value = balances[sender] / piecesPerUnit - minHoldAmount;
return value;
}
function taxify(uint value, uint id) internal view returns (uint) {
return value * tax[id * 10] / tax[id * 10 + 1];
}
function changeRewardMax(uint id, uint newRewardMax) internal {
if (startTime[id] > 0) {
rewardsLastRewardChange[id] = rewardTheoretical(id);
timeFromInitToLastRewardChange[id] = block.timestamp - startTime[id];
}
rewardMax[id] = newRewardMax;
}
function rewardTheoretical(uint id) public view returns (uint) {
if (startTime[id] == 0) return 0;
return rewardMax[id] - (rewardMax[id] - rewardsLastRewardChange[id]) * rewardConst[id] / (block.timestamp - startTime[id] + rewardConst[id] - timeFromInitToLastRewardChange[id]);
}
function reflect(uint reflectAmount) internal {
uint FTPXA = totalSupply * piecesPerUnit - balances[liquidityAddress];
uint FFTPXARA = FTPXA - reflectAmount;
piecesPerUnit = piecesPerUnit * FFTPXARA / FTPXA;
if (piecesPerUnit < 1)
piecesPerUnit = 1;
balances[liquidityAddress] = balances[liquidityAddress] * FFTPXARA / FTPXA;
}
function distributorCheck(address sender, address receiver, uint value) internal {
if (hasReceivedPieces[receiver] == false && value >= distributionRewardThreshold) {
addRewardableEvents(sender, 1);
hasReceivedPieces[receiver] = true;
}
}
function marketMakerCheck(address sender, address receiver, uint value) internal {
if (value >= marketMakingRewardThreshold) {
if (sender == liquidityAddress) addRewardableEvents(receiver, 0);
if (receiver == liquidityAddress) addRewardableEvents(sender, 0);
}
}
function addRewardableEvents(address recipient, uint id) internal {
if (startTime[id] == 0) startTime[id] = block.timestamp;
distribute(id);
if (getAvailableRewards(recipient, id) > 0) storedRewards[recipient][id] = getAvailableRewards(recipient, id) * piecesPerUnit;
Si[recipient][id] = S[id];
WCi[recipient][id] = workaroundConstant;
rewardableEvents[recipient][id] += 1;
totalRewardableEvents[id] += 1;
}
function distribute(uint id) internal {
if (totalRewardableEvents[id] != 0 && lastRewardDistribution[id] != rewardTheoretical(id)) {
uint addedReward = rewardTheoretical(id) - lastRewardDistribution[id];
while (addedReward > 0 && addedReward * workaroundConstant / totalRewardableEvents[id] < 1e9) {
workaroundConstant *= 2;
for (uint i; i < 3; i++) S[i] *= 2;
}
S[id] += addedReward * workaroundConstant / totalRewardableEvents[id];
lastRewardDistribution[id] = rewardTheoretical(id);
}
}
function getAvailableRewards(address _address, uint id) public view returns (uint) {
if (WCi[_address][id] == 0) return 0;
uint _workaroundConstant = workaroundConstant;
uint _S = S[id];
if (totalRewardableEvents[id] != 0 && lastRewardDistribution[id] != rewardTheoretical(id)) {
uint addedReward = rewardTheoretical(id) - lastRewardDistribution[id];
while (addedReward > 0 && addedReward * _workaroundConstant / totalRewardableEvents[id] < 1e9) {
_workaroundConstant *= 2;
_S *= 2;
}
_S += addedReward * _workaroundConstant / totalRewardableEvents[id];
}
uint availableRewards = storedRewards[_address][id] + rewardableEvents[_address][id] * (_S - Si[_address][id] * _workaroundConstant / WCi[_address][id]) / _workaroundConstant;
return availableRewards / piecesPerUnit;
}
function getAllAvailableRewards(address _address) public view returns(uint, uint, uint, uint) {
return (getAvailableRewards(_address, 0), getAvailableRewards(_address, 1), getAvailableRewards(_address, 2), getAvailableRewards(_address, 0) + getAvailableRewards(_address, 1) + getAvailableRewards(_address, 2));
}
function withdrawRewards(address _address, uint id) public {
distribute(id);
if (WCi[_address][id] == 0) return;
uint availableRewards = storedRewards[_address][id] + rewardableEvents[_address][id] * (S[id] - Si[_address][id] * workaroundConstant / WCi[_address][id]) / workaroundConstant;
storedRewards[_address][id] = 0;
Si[_address][id] = S[id];
WCi[_address][id] = workaroundConstant;
uint id2 = (id + 2) * 10;
balances[_address] += availableRewards - taxify(availableRewards, id2 + 1);
balances[gamemaster] += taxify(availableRewards, id2 + 5);
balances[address(this)] -= availableRewards - taxify(availableRewards, id2 + 2) - taxify(availableRewards, id2 + 3);
for (uint i = 0; i < 2; i++) { changeRewardMax(id != i * 2 ? i * 2 : 1, rewardMax[id] + taxify(availableRewards, id2 + 2 + i)); }
reflect(taxify(availableRewards, id2 + 4));
emit Transfer(address(this), _address, (availableRewards - taxify(availableRewards, id2 + 1)) / piecesPerUnit);
emit Transfer(address(this), gamemaster, taxify(availableRewards, id2 + 5) / piecesPerUnit);
emit ReflectEvent(address(this), taxify(availableRewards, id2 + 4) / piecesPerUnit);
}
function withdrawAllRewards(address _address) public {
for (uint i = 0; i < 3; i++) { if (getAvailableRewards(_address, i) > 0) withdrawRewards(_address, i); }
}
function stake(uint amount) public {
require(rewardableEvents[msg.sender][2] == 0, "staking position already exists");
ERC20(liquidityAddress).transferFrom(msg.sender, address(this), amount);
if (startTime[2] == 0) startTime[2] = block.timestamp;
distribute(2);
if (getAvailableRewards(msg.sender, 2) > 0) storedRewards[msg.sender][2] = getAvailableRewards(msg.sender, 2) * piecesPerUnit;
Si[msg.sender][2] = S[2];
WCi[msg.sender][2] = workaroundConstant;
rewardableEvents[msg.sender][2] += amount;
totalRewardableEvents[2] += amount;
}
function unstake() public {
require(rewardableEvents[msg.sender][2] > 0, "no current staking position");
distribute(2);
if (getAvailableRewards(msg.sender, 2) > 0) storedRewards[msg.sender][2] = getAvailableRewards(msg.sender, 2) * piecesPerUnit;
ERC20(liquidityAddress).transfer(msg.sender, rewardableEvents[msg.sender][2]);
totalRewardableEvents[2] -= rewardableEvents[msg.sender][2];
rewardableEvents[msg.sender][2] = 0;
}
function updatePosition(uint amount) public {
unstake();
stake(amount);
}
function changeTaxDetail(uint id, uint value) public {
require(msg.sender == owner, "not owner");
tax[id] = value;
}
function changeRewardConstant(uint newRewardConstant, uint id) public {
require(msg.sender == owner, "not owner");
rewardConst[id] = newRewardConstant;
}
function changeLiquidityAddress(address newLiquidityAddress) public {
require(msg.sender == owner, "not owner");
liquidityAddress = newLiquidityAddress;
for (uint i = 0; i < 3; i++) { rewardableEvents[liquidityAddress][i] = 0; }
}
function changeOwner(address newOwner) public {
require(msg.sender == owner, "not owner");
owner = newOwner;
}
function donate(uint id, uint value) public {
uint pieceValue = value * piecesPerUnit;
balances[msg.sender] -= pieceValue;
balances[address(this)] += pieceValue;
changeRewardMax(id, rewardMax[id] + pieceValue);
}
function changeDisableGame(bool newDisableGame) public {
require(msg.sender == owner, "not owner");
disableGame = newDisableGame;
}
function changeDistributionRewardThreshold(uint newDistributionRewardThreshold) public {
require(msg.sender == owner, "not owner");
distributionRewardThreshold = newDistributionRewardThreshold;
}
function changeMarketMakingRewardThreshold(uint newMarketMakingRewardThreshold) public {
require(msg.sender == owner, "not owner");
marketMakingRewardThreshold = newMarketMakingRewardThreshold;
}
function changeMinHoldAmount(uint newMinHoldAmount) public {
require(msg.sender == owner, "not owner");
minHoldAmount = newMinHoldAmount;
}
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed owner, address indexed spender, uint256 value);
event ReflectEvent(address indexed from, uint tokens);
}
| 276,995 | 1,050 |
24744fe8974e7679cb74dcb6410ff458908ff413453f9775b43aeeb7e2049475
| 38,072 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/51/51ec3bd0a612230366c55473fE4dCDFf5404A987_TicketToken.sol
| 4,855 | 19,090 |
pragma solidity 0.6.12;
//
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor() internal {}
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
//
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), 'Ownable: caller is not the owner');
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), 'Ownable: new owner is the zero address');
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
//
interface IBEP20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
//
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, 'SafeMath: addition overflow');
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, 'SafeMath: subtraction overflow');
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, 'SafeMath: multiplication overflow');
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, 'SafeMath: division by zero');
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, 'SafeMath: modulo by zero');
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function min(uint256 x, uint256 y) internal pure returns (uint256 z) {
z = x < y ? x : y;
}
function sqrt(uint256 y) internal pure returns (uint256 z) {
if (y > 3) {
z = y;
uint256 x = y / 2 + 1;
while (x < z) {
z = x;
x = (y / x + x) / 2;
}
} else if (y != 0) {
z = 1;
}
}
}
//
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly {
codehash := extcodehash(account)
}
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, 'Address: insufficient balance');
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{value: amount}('');
require(success, 'Address: unable to send value, recipient may have reverted');
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, 'Address: low-level call failed');
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, 'Address: low-level call with value failed');
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, 'Address: insufficient balance for call');
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), 'Address: call to non-contract');
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{value: weiValue}(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
//
contract BEP20 is Context, IBEP20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string memory name, string memory symbol) public {
_name = name;
_symbol = symbol;
_decimals = 18;
}
function getOwner() external override view returns (address) {
return owner();
}
function name() public override view returns (string memory) {
return _name;
}
function decimals() public override view returns (uint8) {
return _decimals;
}
function symbol() public override view returns (string memory) {
return _symbol;
}
function totalSupply() public override view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public override view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public override view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender,
address recipient,
uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender,
_msgSender(),
_allowances[sender][_msgSender()].sub(amount, 'BEP20: transfer amount exceeds allowance'));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(),
spender,
_allowances[_msgSender()][spender].sub(subtractedValue, 'BEP20: decreased allowance below zero'));
return true;
}
function mint(uint256 amount) public onlyOwner returns (bool) {
_mint(_msgSender(), amount);
return true;
}
function _transfer(address sender,
address recipient,
uint256 amount) internal {
require(sender != address(0), 'BEP20: transfer from the zero address');
require(recipient != address(0), 'BEP20: transfer to the zero address');
_balances[sender] = _balances[sender].sub(amount, 'BEP20: transfer amount exceeds balance');
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), 'BEP20: mint to the zero address');
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), 'BEP20: burn from the zero address');
_balances[account] = _balances[account].sub(amount, 'BEP20: burn amount exceeds balance');
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner,
address spender,
uint256 amount) internal {
require(owner != address(0), 'BEP20: approve from the zero address');
require(spender != address(0), 'BEP20: approve to the zero address');
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _burnFrom(address account, uint256 amount) internal {
_burn(account, amount);
_approve(account,
_msgSender(),
_allowances[account][_msgSender()].sub(amount, 'BEP20: burn amount exceeds allowance'));
}
}
// TicketToken with Governance.
contract TicketToken is BEP20('Ticket Token', 'TICKET') {
/// @notice Creates `_amount` token to `_to`. Must only be called by the owner (MasterTicket).
function mint(address _to, uint256 _amount) public onlyOwner {
_mint(_to, _amount);
_moveDelegates(address(0), _delegates[_to], _amount);
}
// Copied and modified from YAM code:
// https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernanceStorage.sol
// https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernance.sol
// Which is copied and modified from COMPOUND:
// https://github.com/compound-finance/compound-protocol/blob/master/contracts/Governance/Comp.sol
/// @dev A record of each accounts delegate
mapping (address => address) internal _delegates;
/// @notice A checkpoint for marking number of votes from a given block
struct Checkpoint {
uint32 fromBlock;
uint256 votes;
}
/// @notice A record of votes checkpoints for each account, by index
mapping (address => mapping (uint32 => Checkpoint)) public checkpoints;
/// @notice The number of checkpoints for each account
mapping (address => uint32) public numCheckpoints;
/// @notice The EIP-712 typehash for the contract's domain
bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");
/// @notice The EIP-712 typehash for the delegation struct used by the contract
bytes32 public constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");
/// @notice A record of states for signing / validating signatures
mapping (address => uint) public nonces;
/// @notice An event thats emitted when an account changes its delegate
event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);
/// @notice An event thats emitted when a delegate account's vote balance changes
event DelegateVotesChanged(address indexed delegate, uint previousBalance, uint newBalance);
function delegates(address delegator)
external
view
returns (address)
{
return _delegates[delegator];
}
function delegate(address delegatee) external {
return _delegate(msg.sender, delegatee);
}
function delegateBySig(address delegatee,
uint nonce,
uint expiry,
uint8 v,
bytes32 r,
bytes32 s)
external
{
bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH,
keccak256(bytes(name())),
getChainId(),
address(this)));
bytes32 structHash = keccak256(abi.encode(DELEGATION_TYPEHASH,
delegatee,
nonce,
expiry));
bytes32 digest = keccak256(abi.encodePacked("\x19\x01",
domainSeparator,
structHash));
address signatory = ecrecover(digest, v, r, s);
require(signatory != address(0), "TICKET::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++, "TICKET::delegateBySig: invalid nonce");
require(now <= expiry, "TICKET::delegateBySig: signature expired");
return _delegate(signatory, delegatee);
}
function getCurrentVotes(address account)
external
view
returns (uint256)
{
uint32 nCheckpoints = numCheckpoints[account];
return nCheckpoints > 0 ? checkpoints[account][nCheckpoints - 1].votes : 0;
}
function getPriorVotes(address account, uint blockNumber)
external
view
returns (uint256)
{
require(blockNumber < block.number, "TICKET::getPriorVotes: not yet determined");
uint32 nCheckpoints = numCheckpoints[account];
if (nCheckpoints == 0) {
return 0;
}
// First check most recent balance
if (checkpoints[account][nCheckpoints - 1].fromBlock <= blockNumber) {
return checkpoints[account][nCheckpoints - 1].votes;
}
// Next check implicit zero balance
if (checkpoints[account][0].fromBlock > blockNumber) {
return 0;
}
uint32 lower = 0;
uint32 upper = nCheckpoints - 1;
while (upper > lower) {
uint32 center = upper - (upper - lower) / 2; // ceil, avoiding overflow
Checkpoint memory cp = checkpoints[account][center];
if (cp.fromBlock == blockNumber) {
return cp.votes;
} else if (cp.fromBlock < blockNumber) {
lower = center;
} else {
upper = center - 1;
}
}
return checkpoints[account][lower].votes;
}
function _delegate(address delegator, address delegatee)
internal
{
address currentDelegate = _delegates[delegator];
uint256 delegatorBalance = balanceOf(delegator); // balance of underlying TICKETs (not scaled);
_delegates[delegator] = delegatee;
emit DelegateChanged(delegator, currentDelegate, delegatee);
_moveDelegates(currentDelegate, delegatee, delegatorBalance);
}
function _moveDelegates(address srcRep, address dstRep, uint256 amount) internal {
if (srcRep != dstRep && amount > 0) {
if (srcRep != address(0)) {
// decrease old representative
uint32 srcRepNum = numCheckpoints[srcRep];
uint256 srcRepOld = srcRepNum > 0 ? checkpoints[srcRep][srcRepNum - 1].votes : 0;
uint256 srcRepNew = srcRepOld.sub(amount);
_writeCheckpoint(srcRep, srcRepNum, srcRepOld, srcRepNew);
}
if (dstRep != address(0)) {
// increase new representative
uint32 dstRepNum = numCheckpoints[dstRep];
uint256 dstRepOld = dstRepNum > 0 ? checkpoints[dstRep][dstRepNum - 1].votes : 0;
uint256 dstRepNew = dstRepOld.add(amount);
_writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew);
}
}
}
function _writeCheckpoint(address delegatee,
uint32 nCheckpoints,
uint256 oldVotes,
uint256 newVotes)
internal
{
uint32 blockNumber = safe32(block.number, "TICKET::_writeCheckpoint: block number exceeds 32 bits");
if (nCheckpoints > 0 && checkpoints[delegatee][nCheckpoints - 1].fromBlock == blockNumber) {
checkpoints[delegatee][nCheckpoints - 1].votes = newVotes;
} else {
checkpoints[delegatee][nCheckpoints] = Checkpoint(blockNumber, newVotes);
numCheckpoints[delegatee] = nCheckpoints + 1;
}
emit DelegateVotesChanged(delegatee, oldVotes, newVotes);
}
function safe32(uint n, string memory errorMessage) internal pure returns (uint32) {
require(n < 2**32, errorMessage);
return uint32(n);
}
function getChainId() internal pure returns (uint) {
uint256 chainId;
assembly { chainId := chainid() }
return chainId;
}
}
| 329,465 | 1,051 |
b4c783fe1ee0561c8f1476b29333694d783f69e02485157b92e0010b98049433
| 17,449 |
.sol
|
Solidity
| false |
627794329
|
uni-due-syssec/efcf-framework
|
c3088c935f567dc7fc286475d6759204b6e44ef5
|
data/smartbugs-top-1000-balance/0xa467b88bbf9706622be2784af724c4b44a9d26f4.sol
| 3,783 | 15,894 |
pragma solidity 0.4.18;
// File: contracts/ERC20Interface.sol
// https://github.com/ethereum/EIPs/issues/20
interface ERC20 {
function totalSupply() public view returns (uint supply);
function balanceOf(address _owner) public view returns (uint balance);
function transfer(address _to, uint _value) public returns (bool success);
function transferFrom(address _from, address _to, uint _value) public returns (bool success);
function approve(address _spender, uint _value) public returns (bool success);
function allowance(address _owner, address _spender) public view returns (uint remaining);
function decimals() public view returns(uint digits);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
// File: contracts/Utils.sol
/// @title Kyber constants contract
contract Utils {
ERC20 constant internal ETH_TOKEN_ADDRESS = ERC20(0x00eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee);
uint constant internal PRECISION = (10**18);
uint constant internal MAX_QTY = (10**28); // 10B tokens
uint constant internal MAX_RATE = (PRECISION * 10**6); // up to 1M tokens per ETH
uint constant internal MAX_DECIMALS = 18;
uint constant internal ETH_DECIMALS = 18;
mapping(address=>uint) internal decimals;
function setDecimals(ERC20 token) internal {
if (token == ETH_TOKEN_ADDRESS) decimals[token] = ETH_DECIMALS;
else decimals[token] = token.decimals();
}
function getDecimals(ERC20 token) internal view returns(uint) {
if (token == ETH_TOKEN_ADDRESS) return ETH_DECIMALS; // save storage access
uint tokenDecimals = decimals[token];
// technically, there might be token with decimals 0
// moreover, very possible that old tokens have decimals 0
// these tokens will just have higher gas fees.
if(tokenDecimals == 0) return token.decimals();
return tokenDecimals;
}
function calcDstQty(uint srcQty, uint srcDecimals, uint dstDecimals, uint rate) internal pure returns(uint) {
require(srcQty <= MAX_QTY);
require(rate <= MAX_RATE);
if (dstDecimals >= srcDecimals) {
require((dstDecimals - srcDecimals) <= MAX_DECIMALS);
return (srcQty * rate * (10**(dstDecimals - srcDecimals))) / PRECISION;
} else {
require((srcDecimals - dstDecimals) <= MAX_DECIMALS);
return (srcQty * rate) / (PRECISION * (10**(srcDecimals - dstDecimals)));
}
}
function calcSrcQty(uint dstQty, uint srcDecimals, uint dstDecimals, uint rate) internal pure returns(uint) {
require(dstQty <= MAX_QTY);
require(rate <= MAX_RATE);
//source quantity is rounded up. to avoid dest quantity being too low.
uint numerator;
uint denominator;
if (srcDecimals >= dstDecimals) {
require((srcDecimals - dstDecimals) <= MAX_DECIMALS);
numerator = (PRECISION * dstQty * (10**(srcDecimals - dstDecimals)));
denominator = rate;
} else {
require((dstDecimals - srcDecimals) <= MAX_DECIMALS);
numerator = (PRECISION * dstQty);
denominator = (rate * (10**(dstDecimals - srcDecimals)));
}
return (numerator + denominator - 1) / denominator; //avoid rounding down errors
}
}
// File: contracts/PermissionGroups.sol
contract PermissionGroups {
address public admin;
address public pendingAdmin;
mapping(address=>bool) internal operators;
mapping(address=>bool) internal alerters;
address[] internal operatorsGroup;
address[] internal alertersGroup;
uint constant internal MAX_GROUP_SIZE = 50;
function PermissionGroups() public {
admin = msg.sender;
}
modifier onlyAdmin() {
require(msg.sender == admin);
_;
}
modifier onlyOperator() {
require(operators[msg.sender]);
_;
}
modifier onlyAlerter() {
require(alerters[msg.sender]);
_;
}
function getOperators () external view returns(address[]) {
return operatorsGroup;
}
function getAlerters () external view returns(address[]) {
return alertersGroup;
}
event TransferAdminPending(address pendingAdmin);
function transferAdmin(address newAdmin) public onlyAdmin {
require(newAdmin != address(0));
TransferAdminPending(pendingAdmin);
pendingAdmin = newAdmin;
}
function transferAdminQuickly(address newAdmin) public onlyAdmin {
require(newAdmin != address(0));
TransferAdminPending(newAdmin);
AdminClaimed(newAdmin, admin);
admin = newAdmin;
}
event AdminClaimed(address newAdmin, address previousAdmin);
function claimAdmin() public {
require(pendingAdmin == msg.sender);
AdminClaimed(pendingAdmin, admin);
admin = pendingAdmin;
pendingAdmin = address(0);
}
event AlerterAdded (address newAlerter, bool isAdd);
function addAlerter(address newAlerter) public onlyAdmin {
require(!alerters[newAlerter]); // prevent duplicates.
require(alertersGroup.length < MAX_GROUP_SIZE);
AlerterAdded(newAlerter, true);
alerters[newAlerter] = true;
alertersGroup.push(newAlerter);
}
function removeAlerter (address alerter) public onlyAdmin {
require(alerters[alerter]);
alerters[alerter] = false;
for (uint i = 0; i < alertersGroup.length; ++i) {
if (alertersGroup[i] == alerter) {
alertersGroup[i] = alertersGroup[alertersGroup.length - 1];
alertersGroup.length--;
AlerterAdded(alerter, false);
break;
}
}
}
event OperatorAdded(address newOperator, bool isAdd);
function addOperator(address newOperator) public onlyAdmin {
require(!operators[newOperator]); // prevent duplicates.
require(operatorsGroup.length < MAX_GROUP_SIZE);
OperatorAdded(newOperator, true);
operators[newOperator] = true;
operatorsGroup.push(newOperator);
}
function removeOperator (address operator) public onlyAdmin {
require(operators[operator]);
operators[operator] = false;
for (uint i = 0; i < operatorsGroup.length; ++i) {
if (operatorsGroup[i] == operator) {
operatorsGroup[i] = operatorsGroup[operatorsGroup.length - 1];
operatorsGroup.length -= 1;
OperatorAdded(operator, false);
break;
}
}
}
}
// File: contracts/Withdrawable.sol
contract Withdrawable is PermissionGroups {
event TokenWithdraw(ERC20 token, uint amount, address sendTo);
function withdrawToken(ERC20 token, uint amount, address sendTo) external onlyAdmin {
require(token.transfer(sendTo, amount));
TokenWithdraw(token, amount, sendTo);
}
event EtherWithdraw(uint amount, address sendTo);
function withdrawEther(uint amount, address sendTo) external onlyAdmin {
sendTo.transfer(amount);
EtherWithdraw(amount, sendTo);
}
}
// File: contracts/ConversionRatesInterface.sol
interface ConversionRatesInterface {
function recordImbalance(ERC20 token,
int buyAmount,
uint rateUpdateBlock,
uint currentBlock)
public;
function getRate(ERC20 token, uint currentBlockNumber, bool buy, uint qty) public view returns(uint);
}
// File: contracts/SanityRatesInterface.sol
interface SanityRatesInterface {
function getSanityRate(ERC20 src, ERC20 dest) public view returns(uint);
}
// File: contracts/KyberReserveInterface.sol
/// @title Kyber Reserve contract
interface KyberReserveInterface {
function trade(ERC20 srcToken,
uint srcAmount,
ERC20 destToken,
address destAddress,
uint conversionRate,
bool validate)
public
payable
returns(bool);
function getConversionRate(ERC20 src, ERC20 dest, uint srcQty, uint blockNumber) public view returns(uint);
}
// File: contracts/KyberReserve.sol
/// @title Kyber Reserve contract
contract KyberReserve is KyberReserveInterface, Withdrawable, Utils {
address public kyberNetwork;
bool public tradeEnabled;
ConversionRatesInterface public conversionRatesContract;
SanityRatesInterface public sanityRatesContract;
mapping(bytes32=>bool) public approvedWithdrawAddresses; // sha3(token,address)=>bool
mapping(address=>address) public tokenWallet;
function KyberReserve(address _kyberNetwork, ConversionRatesInterface _ratesContract, address _admin) public {
require(_admin != address(0));
require(_ratesContract != address(0));
require(_kyberNetwork != address(0));
kyberNetwork = _kyberNetwork;
conversionRatesContract = _ratesContract;
admin = _admin;
tradeEnabled = true;
}
event DepositToken(ERC20 token, uint amount);
function() public payable {
DepositToken(ETH_TOKEN_ADDRESS, msg.value);
}
event TradeExecute(address indexed origin,
address src,
uint srcAmount,
address destToken,
uint destAmount,
address destAddress);
function trade(ERC20 srcToken,
uint srcAmount,
ERC20 destToken,
address destAddress,
uint conversionRate,
bool validate)
public
payable
returns(bool)
{
require(tradeEnabled);
require(msg.sender == kyberNetwork);
require(doTrade(srcToken, srcAmount, destToken, destAddress, conversionRate, validate));
return true;
}
event TradeEnabled(bool enable);
function enableTrade() public onlyAdmin returns(bool) {
tradeEnabled = true;
TradeEnabled(true);
return true;
}
function disableTrade() public onlyAlerter returns(bool) {
tradeEnabled = false;
TradeEnabled(false);
return true;
}
event WithdrawAddressApproved(ERC20 token, address addr, bool approve);
function approveWithdrawAddress(ERC20 token, address addr, bool approve) public onlyAdmin {
approvedWithdrawAddresses[keccak256(token, addr)] = approve;
WithdrawAddressApproved(token, addr, approve);
setDecimals(token);
if ((tokenWallet[token] == address(0x0)) && (token != ETH_TOKEN_ADDRESS)) {
tokenWallet[token] = this; // by default
require(token.approve(this, 2 ** 255));
}
}
event NewTokenWallet(ERC20 token, address wallet);
function setTokenWallet(ERC20 token, address wallet) public onlyAdmin {
require(wallet != address(0x0));
tokenWallet[token] = wallet;
NewTokenWallet(token, wallet);
}
event WithdrawFunds(ERC20 token, uint amount, address destination);
function withdraw(ERC20 token, uint amount, address destination) public onlyOperator returns(bool) {
require(approvedWithdrawAddresses[keccak256(token, destination)]);
if (token == ETH_TOKEN_ADDRESS) {
destination.transfer(amount);
} else {
require(token.transferFrom(tokenWallet[token], destination, amount));
}
WithdrawFunds(token, amount, destination);
return true;
}
event SetContractAddresses(address network, address rate, address sanity);
function setContracts(address _kyberNetwork,
ConversionRatesInterface _conversionRates,
SanityRatesInterface _sanityRates)
public
onlyAdmin
{
require(_kyberNetwork != address(0));
require(_conversionRates != address(0));
kyberNetwork = _kyberNetwork;
conversionRatesContract = _conversionRates;
sanityRatesContract = _sanityRates;
SetContractAddresses(kyberNetwork, conversionRatesContract, sanityRatesContract);
}
////////////////////////////////////////////////////////////////////////////
/// status functions ///////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
function getBalance(ERC20 token) public view returns(uint) {
if (token == ETH_TOKEN_ADDRESS)
return this.balance;
else {
address wallet = tokenWallet[token];
uint balanceOfWallet = token.balanceOf(wallet);
uint allowanceOfWallet = token.allowance(wallet, this);
return (balanceOfWallet < allowanceOfWallet) ? balanceOfWallet : allowanceOfWallet;
}
}
function getDestQty(ERC20 src, ERC20 dest, uint srcQty, uint rate) public view returns(uint) {
uint dstDecimals = getDecimals(dest);
uint srcDecimals = getDecimals(src);
return calcDstQty(srcQty, srcDecimals, dstDecimals, rate);
}
function getSrcQty(ERC20 src, ERC20 dest, uint dstQty, uint rate) public view returns(uint) {
uint dstDecimals = getDecimals(dest);
uint srcDecimals = getDecimals(src);
return calcSrcQty(dstQty, srcDecimals, dstDecimals, rate);
}
function getConversionRate(ERC20 src, ERC20 dest, uint srcQty, uint blockNumber) public view returns(uint) {
ERC20 token;
bool isBuy;
if (!tradeEnabled) return 0;
if (ETH_TOKEN_ADDRESS == src) {
isBuy = true;
token = dest;
} else if (ETH_TOKEN_ADDRESS == dest) {
isBuy = false;
token = src;
} else {
return 0; // pair is not listed
}
uint rate = conversionRatesContract.getRate(token, blockNumber, isBuy, srcQty);
uint destQty = getDestQty(src, dest, srcQty, rate);
if (getBalance(dest) < destQty) return 0;
if (sanityRatesContract != address(0)) {
uint sanityRate = sanityRatesContract.getSanityRate(src, dest);
if (rate > sanityRate) return 0;
}
return rate;
}
/// @dev do a trade
/// @param srcToken Src token
/// @param srcAmount Amount of src token
/// @param destToken Destination token
/// @param destAddress Destination address to send tokens to
/// @param validate If true, additional validations are applicable
/// @return true iff trade is successful
function doTrade(ERC20 srcToken,
uint srcAmount,
ERC20 destToken,
address destAddress,
uint conversionRate,
bool validate)
internal
returns(bool)
{
// can skip validation if done at kyber network level
if (validate) {
require(conversionRate > 0);
if (srcToken == ETH_TOKEN_ADDRESS)
require(msg.value == srcAmount);
else
require(msg.value == 0);
}
uint destAmount = getDestQty(srcToken, destToken, srcAmount, conversionRate);
// sanity check
require(destAmount > 0);
// add to imbalance
ERC20 token;
int tradeAmount;
if (srcToken == ETH_TOKEN_ADDRESS) {
tradeAmount = int(destAmount);
token = destToken;
} else {
tradeAmount = -1 * int(srcAmount);
token = srcToken;
}
conversionRatesContract.recordImbalance(token,
tradeAmount,
0,
block.number);
// collect src tokens
if (srcToken != ETH_TOKEN_ADDRESS) {
require(srcToken.transferFrom(msg.sender, tokenWallet[srcToken], srcAmount));
}
// send dest tokens
if (destToken == ETH_TOKEN_ADDRESS) {
destAddress.transfer(destAmount);
} else {
require(destToken.transferFrom(tokenWallet[destToken], destAddress, destAmount));
}
TradeExecute(msg.sender, srcToken, srcAmount, destToken, destAmount, destAddress);
return true;
}
}
| 270,669 | 1,052 |
14c720af83c7910414f0a1bf3747179880e66c8fca0b2616f57a5e2a334b2817
| 19,038 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.4/0xe5af8907776fd5f1bb069369fd398ad33102751e.sol
| 5,185 | 15,407 |
pragma solidity 0.4.25;
contract Wallie
{
//Investor
mapping (address => Investor) public investors;
//Event the new investor
event NewInvestor(address _addr, uint256 _amount);
//Event of the accrual of cashback bonus
event CashbackBonus(address _addr, uint256 _amount, uint256 _revenue);
//Referral bonus accrual event
event RefererBonus(address _from, address _to, uint256 _amount, uint256 _revenue, uint256 _level);
//New contribution event
event NewInvestment(address _addr, uint256 _amount);
//The event of the new withdrawal
event NewWithdraw(address _addr, uint256 _amount);
//The event of changes in the balance of the smart contract
event ChangeBalance(uint256 _balance);
struct Investor {
//Member address
address addr;
//The address of the inviter
address referer;
//Deposit amount
uint256 investment;
//The time of the last contribution
uint256 investment_time;
//The time of the first contribution to the daily limit
uint256 investment_first_time_in_day;
//Deposit amount per day
uint256 investments_daily;
//Deposit income
uint256 investment_profit;
//Referral income
uint256 referals_profit;
//Cashback income
uint256 cashback_profit;
//Available balance income contributions
uint256 investment_profit_balance;
//Available referral income balance
uint256 referals_profit_balance;
//Available cashback income balance
uint256 cashback_profit_balance;
}
//Percentage of daily charges before reaching the balance of 2000 ETH
uint256 private constant dividends_perc_before_2000eth = 11; // 1.1%
//Percentage of daily charges after reaching the balance of 2000 ETH
uint256 private constant dividends_perc_after_2000eth = 12; // 1.2%
//The percentage of the referral bonus of the first line
uint256 public constant ref_bonus_level_1 = 5; // 5%
//Second line referral bonus percentage
uint256 public constant ref_bonus_level_2 = 3; // 3%
//The percentage of referral bonus is the third line
uint256 public constant ref_bonus_level_3 = 1; // 1%
//Cashback bonus percentage
uint256 public constant cashback_bonus = 3; // 3%
//Minimum payment
uint256 public constant min_invesment = 10 finney; // 0.01 eth
//Deduction for advertising
uint256 public constant advertising_fees = 15; // 15%
//Limit to receive funds on the same day
uint256 public constant contract_daily_limit = 100 ether;
//Lock entry tools
bool public block_investments = true;
//The mode of payment
bool public compensation = true;
//Address smart contract first draft Wallie
address first_project_addr = 0xC0B52b76055C392D67392622AE7737cdb6D42133;
//Start time
uint256 public start_time;
//Current day
uint256 current_day;
//Launch day
uint256 start_day;
//Deposit amount per day
uint256 daily_invest_to_contract;
//The address of the owner
address private adm_addr;
//Starting block
uint256 public start_block;
//Project started
bool public is_started = false;
//Statistics
//All investors
uint256 private all_invest_users_count = 0;
//Just introduced to the fund
uint256 private all_invest = 0;
//Total withdrawn from the fund
uint256 private all_payments = 0;
//The last address of the depositor
address private last_invest_addr = 0;
//The amount of the last contribution
uint256 private last_invest_amount = 0;
using SafeMath for uint;
using ToAddress for *;
using Zero for *;
constructor() public {
adm_addr = msg.sender;
current_day = 0;
daily_invest_to_contract = 0;
}
//Current time
function getTime() public view returns (uint256) {
return (now);
}
//The creation of the account of the investor
function createInvestor(address addr,address referer) private {
investors[addr].addr = addr;
if (investors[addr].referer.isZero()) {
investors[addr].referer = referer;
}
all_invest_users_count++;
emit NewInvestor(addr, msg.value);
}
//Check if there is an investor account
function checkInvestor(address addr) public view returns (bool) {
if (investors[addr].addr.isZero()) {
return false;
}
else {
return true;
}
}
//Accrual of referral bonuses to the participant
function setRefererBonus(address addr, uint256 amount, uint256 level_percent, uint256 level_num) private {
if (addr.notZero()) {
uint256 revenue = amount.mul(level_percent).div(100);
if (!checkInvestor(addr)) {
createInvestor(addr, address(0));
}
investors[addr].referals_profit = investors[addr].referals_profit.add(revenue);
investors[addr].referals_profit_balance = investors[addr].referals_profit_balance.add(revenue);
emit RefererBonus(msg.sender, addr, amount, revenue, level_num);
}
}
//Accrual of referral bonuses to participants
function setAllRefererBonus(address addr, uint256 amount) private {
address ref_addr_level_1 = investors[addr].referer;
address ref_addr_level_2 = investors[ref_addr_level_1].referer;
address ref_addr_level_3 = investors[ref_addr_level_2].referer;
setRefererBonus (ref_addr_level_1, amount, ref_bonus_level_1, 1);
setRefererBonus (ref_addr_level_2, amount, ref_bonus_level_2, 2);
setRefererBonus (ref_addr_level_3, amount, ref_bonus_level_3, 3);
}
//Get the number of dividends
function calcDivedents (address addr) public view returns (uint256) {
uint256 current_perc = 0;
if (address(this).balance < 2000 ether) {
current_perc = dividends_perc_before_2000eth;
}
else {
current_perc = dividends_perc_after_2000eth;
}
return investors[addr].investment.mul(current_perc).div(1000).mul(now.sub(investors[addr].investment_time)).div(1 days);
}
//We transfer dividends to the participant's account
function setDivedents(address addr) private returns (uint256) {
investors[addr].investment_profit_balance = investors[addr].investment_profit_balance.add(calcDivedents(addr));
}
//We enroll the deposit
function setAmount(address addr, uint256 amount) private {
investors[addr].investment = investors[addr].investment.add(amount);
investors[addr].investment_time = now;
all_invest = all_invest.add(amount);
last_invest_addr = addr;
last_invest_amount = amount;
emit NewInvestment(addr,amount);
}
//Cashback enrollment
function setCashBackBonus(address addr, uint256 amount) private {
if (investors[addr].referer.notZero() && investors[addr].investment == 0) {
investors[addr].cashback_profit_balance = amount.mul(cashback_bonus).div(100);
investors[addr].cashback_profit = investors[addr].cashback_profit.add(investors[addr].cashback_profit_balance);
emit CashbackBonus(addr, amount, investors[addr].cashback_profit_balance);
}
}
//Income payment
function withdraw_revenue(address addr) private {
uint256 withdraw_amount = calcDivedents(addr);
if (check_x2_profit(addr,withdraw_amount) == true) {
withdraw_amount = 0;
}
if (withdraw_amount > 0) {
investors[addr].investment_profit = investors[addr].investment_profit.add(withdraw_amount);
}
withdraw_amount = withdraw_amount.add(investors[addr].investment_profit_balance).add(investors[addr].referals_profit_balance).add(investors[addr].cashback_profit_balance);
if (withdraw_amount > 0) {
clear_balance(addr);
all_payments = all_payments.add(withdraw_amount);
emit NewWithdraw(addr, withdraw_amount);
emit ChangeBalance(address(this).balance.sub(withdraw_amount));
addr.transfer(withdraw_amount);
}
}
//Reset user balances
function clear_balance(address addr) private {
investors[addr].investment_profit_balance = 0;
investors[addr].referals_profit_balance = 0;
investors[addr].cashback_profit_balance = 0;
investors[addr].investment_time = now;
}
//Checking the x2 profit
function check_x2_profit(address addr, uint256 dividends) private returns(bool) {
if (investors[addr].investment_profit.add(dividends) > investors[addr].investment.mul(2)) {
investors[addr].investment_profit_balance = investors[addr].investment.mul(2).sub(investors[addr].investment_profit);
investors[addr].investment = 0;
investors[addr].investment_profit = 0;
investors[addr].investment_first_time_in_day = 0;
investors[addr].investment_time = 0;
return true;
}
else {
return false;
}
}
function() public payable
isStarted
rerfererVerification
isBlockInvestments
minInvest
allowInvestFirstThreeDays
setDailyInvestContract
setDailyInvest
maxInvestPerUser
maxDailyInvestPerContract
setAdvertisingComiss {
if (msg.value == 0) {
//Request available payment
withdraw_revenue(msg.sender);
}
else
{
//Contribution
address ref_addr = msg.data.toAddr();
//Check if there is an account
if (!checkInvestor(msg.sender)) {
//
createInvestor(msg.sender,ref_addr);
}
//Transfer of dividends on Deposit
setDivedents(msg.sender);
//Accrual of cashback
setCashBackBonus(msg.sender, msg.value);
//Deposit enrollment
setAmount(msg.sender, msg.value);
//Crediting bonuses to referrers
setAllRefererBonus(msg.sender, msg.value);
}
}
//Current day
function today() public view returns (uint256) {
return now.div(1 days);
}
//Prevent accepting deposits
function BlockInvestments() public onlyOwner {
block_investments = true;
}
//To accept deposits
function AllowInvestments() public onlyOwner {
block_investments = false;
}
//Disable compensation mode
function DisableCompensation() public onlyOwner {
compensation = false;
}
//Run the project
function StartProject() public onlyOwner {
require(is_started == false, "Project is started");
block_investments = false;
start_block = block.number;
start_time = now;
start_day = today();
is_started = true;
}
//Investor account statistics
function getInvestorInfo(address addr) public view returns (address, uint256, uint256, uint256, uint256, uint256, uint256, uint256, uint256, uint256, uint256) {
Investor memory investor_info = investors[addr];
return (investor_info.referer,
investor_info.investment,
investor_info.investment_time,
investor_info.investment_first_time_in_day,
investor_info.investments_daily,
investor_info.investment_profit,
investor_info.referals_profit,
investor_info.cashback_profit,
investor_info.investment_profit_balance,
investor_info.referals_profit_balance,
investor_info.cashback_profit_balance);
}
//The stats for the site
function getWebStats() public view returns (uint256,uint256,uint256,uint256,address,uint256){
return (all_invest_users_count,address(this).balance,all_invest,all_payments,last_invest_addr,last_invest_amount);
}
//Check the start of the project
modifier isStarted() {
require(is_started == true, "Project not started");
_;
}
//Checking deposit block
modifier isBlockInvestments()
{
if (msg.value > 0) {
require(block_investments == false, "investments is blocked");
}
_;
}
//Counting the number of user deposits per day
modifier setDailyInvest() {
if (now.sub(investors[msg.sender].investment_first_time_in_day) < 1 days) {
investors[msg.sender].investments_daily = investors[msg.sender].investments_daily.add(msg.value);
}
else {
investors[msg.sender].investments_daily = msg.value;
investors[msg.sender].investment_first_time_in_day = now;
}
_;
}
//The maximum amount of contributions a user per day
modifier maxInvestPerUser() {
if (now.sub(start_time) <= 30 days) {
require(investors[msg.sender].investments_daily <= 20 ether, "max payment must be <= 20 ETH");
}
else{
require(investors[msg.sender].investments_daily <= 50 ether, "max payment must be <= 50 ETH");
}
_;
}
//Maximum amount of all deposits per day
modifier maxDailyInvestPerContract() {
if (now.sub(start_time) <= 30 days) {
require(daily_invest_to_contract <= contract_daily_limit, "all daily invest to contract must be <= 100 ETH");
}
_;
}
//Minimum deposit amount
modifier minInvest() {
require(msg.value == 0 || msg.value >= min_invesment, "amount must be = 0 ETH or > 0.01 ETH");
_;
}
//Calculation of the total number of deposits per day
modifier setDailyInvestContract() {
uint256 day = today();
if (current_day == day) {
daily_invest_to_contract = daily_invest_to_contract.add(msg.value);
}
else {
daily_invest_to_contract = msg.value;
current_day = day;
}
_;
}
modifier allowInvestFirstThreeDays() {
if (now.sub(start_time) <= 3 days && compensation == true) {
uint256 invested = WallieFirstProject(first_project_addr).invested(msg.sender);
require(invested > 0, "invested first contract must be > 0");
uint256 payments = WallieFirstProject(first_project_addr).payments(msg.sender);
uint256 payments_perc = payments.mul(100).div(invested);
require(payments_perc <= 30, "payments first contract must be <= 30%");
}
_;
}
//Verify the date field
modifier rerfererVerification() {
address ref_addr = msg.data.toAddr();
if (ref_addr.notZero()) {
require(msg.sender != ref_addr, "referer must be != msg.sender");
require(investors[ref_addr].referer != msg.sender, "referer must be != msg.sender");
}
_;
}
//Only the owner
modifier onlyOwner() {
require(msg.sender == adm_addr,"onlyOwner!");
_;
}
//Payment of remuneration for advertising
modifier setAdvertisingComiss() {
if (msg.sender != adm_addr && msg.value > 0) {
investors[adm_addr].referals_profit_balance = investors[adm_addr].referals_profit_balance.add(msg.value.mul(advertising_fees).div(100));
}
_;
}
}
//The interface of the first draft (the amount of deposits and amount of payments)
contract WallieFirstProject {
mapping (address => uint256) public invested;
mapping (address => uint256) public payments;
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0); // Solidity only automatically asserts 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) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
library ToAddress
{
function toAddr(uint source) internal pure returns(address) {
return address(source);
}
function toAddr(bytes source) internal pure returns(address addr) {
assembly { addr := mload(add(source,0x14)) }
return addr;
}
}
library Zero
{
function requireNotZero(uint a) internal pure {
require(a != 0, "require not zero");
}
function requireNotZero(address addr) internal pure {
require(addr != address(0), "require not zero address");
}
function notZero(address addr) internal pure returns(bool) {
return !(addr == address(0));
}
function isZero(address addr) internal pure returns(bool) {
return addr == address(0);
}
}
| 222,381 | 1,053 |
8c2b6697ca9d3d7fb89db831edec5fbc0d8bc85d17afee6032a8f2050a71200b
| 9,170 |
.sol
|
Solidity
| false |
530119861
|
ArrakisFinance/v3-lib-0.8
|
756e1f70b5836b6232d74ce4b743b0c19dd9a077
|
contracts/TickMath.sol
| 3,304 | 8,119 |
// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity >=0.8.0;
/// @title Math library for computing sqrt prices from ticks and vice versa
/// prices between 2**-128 and 2**128
library TickMath {
int24 internal constant MIN_TICK = -887272;
int24 internal constant MAX_TICK = -MIN_TICK;
uint160 internal constant MIN_SQRT_RATIO = 4295128739;
uint160 internal constant MAX_SQRT_RATIO =
1461446703485210103287273052203988822378723970342;
/// @notice Calculates sqrt(1.0001^tick) * 2^96
/// @dev Throws if |tick| > max tick
/// @param tick The input tick for the above formula
/// at the given tick
function getSqrtRatioAtTick(int24 tick)
internal
pure
returns (uint160 sqrtPriceX96)
{
uint256 absTick = tick < 0
? uint256(-int256(tick))
: uint256(int256(tick));
// EDIT: 0.8 compatibility
require(absTick <= uint256(int256(MAX_TICK)), "T");
uint256 ratio = absTick & 0x1 != 0
? 0xfffcb933bd6fad37aa2d162d1a594001
: 0x100000000000000000000000000000000;
if (absTick & 0x2 != 0)
ratio = (ratio * 0xfff97272373d413259a46990580e213a) >> 128;
if (absTick & 0x4 != 0)
ratio = (ratio * 0xfff2e50f5f656932ef12357cf3c7fdcc) >> 128;
if (absTick & 0x8 != 0)
ratio = (ratio * 0xffe5caca7e10e4e61c3624eaa0941cd0) >> 128;
if (absTick & 0x10 != 0)
ratio = (ratio * 0xffcb9843d60f6159c9db58835c926644) >> 128;
if (absTick & 0x20 != 0)
ratio = (ratio * 0xff973b41fa98c081472e6896dfb254c0) >> 128;
if (absTick & 0x40 != 0)
ratio = (ratio * 0xff2ea16466c96a3843ec78b326b52861) >> 128;
if (absTick & 0x80 != 0)
ratio = (ratio * 0xfe5dee046a99a2a811c461f1969c3053) >> 128;
if (absTick & 0x100 != 0)
ratio = (ratio * 0xfcbe86c7900a88aedcffc83b479aa3a4) >> 128;
if (absTick & 0x200 != 0)
ratio = (ratio * 0xf987a7253ac413176f2b074cf7815e54) >> 128;
if (absTick & 0x400 != 0)
ratio = (ratio * 0xf3392b0822b70005940c7a398e4b70f3) >> 128;
if (absTick & 0x800 != 0)
ratio = (ratio * 0xe7159475a2c29b7443b29c7fa6e889d9) >> 128;
if (absTick & 0x1000 != 0)
ratio = (ratio * 0xd097f3bdfd2022b8845ad8f792aa5825) >> 128;
if (absTick & 0x2000 != 0)
ratio = (ratio * 0xa9f746462d870fdf8a65dc1f90e061e5) >> 128;
if (absTick & 0x4000 != 0)
ratio = (ratio * 0x70d869a156d2a1b890bb3df62baf32f7) >> 128;
if (absTick & 0x8000 != 0)
ratio = (ratio * 0x31be135f97d08fd981231505542fcfa6) >> 128;
if (absTick & 0x10000 != 0)
ratio = (ratio * 0x9aa508b5b7a84e1c677de54f3e99bc9) >> 128;
if (absTick & 0x20000 != 0)
ratio = (ratio * 0x5d6af8dedb81196699c329225ee604) >> 128;
if (absTick & 0x40000 != 0)
ratio = (ratio * 0x2216e584f5fa1ea926041bedfe98) >> 128;
if (absTick & 0x80000 != 0)
ratio = (ratio * 0x48a170391f7dc42444e8fa2) >> 128;
if (tick > 0) ratio = type(uint256).max / ratio;
// this divides by 1<<32 rounding up to go from a Q128.128 to a Q128.96.
// we round up in the division so getTickAtSqrtRatio of the output price is always consistent
sqrtPriceX96 = uint160((ratio >> 32) + (ratio % (1 << 32) == 0 ? 0 : 1));
}
/// @notice Calculates the greatest tick value such that getRatioAtTick(tick) <= ratio
/// ever return.
/// @param sqrtPriceX96 The sqrt ratio for which to compute the tick as a Q64.96
/// @return tick The greatest tick for which the ratio is less than or equal to the input ratio
function getTickAtSqrtRatio(uint160 sqrtPriceX96)
internal
pure
returns (int24 tick)
{
// second inequality must be < because the price can never reach the price at the max tick
require(sqrtPriceX96 >= MIN_SQRT_RATIO && sqrtPriceX96 < MAX_SQRT_RATIO,
"R");
uint256 ratio = uint256(sqrtPriceX96) << 32;
uint256 r = ratio;
uint256 msb = 0;
assembly {
let f := shl(7, gt(r, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF))
msb := or(msb, f)
r := shr(f, r)
}
assembly {
let f := shl(6, gt(r, 0xFFFFFFFFFFFFFFFF))
msb := or(msb, f)
r := shr(f, r)
}
assembly {
let f := shl(5, gt(r, 0xFFFFFFFF))
msb := or(msb, f)
r := shr(f, r)
}
assembly {
let f := shl(4, gt(r, 0xFFFF))
msb := or(msb, f)
r := shr(f, r)
}
assembly {
let f := shl(3, gt(r, 0xFF))
msb := or(msb, f)
r := shr(f, r)
}
assembly {
let f := shl(2, gt(r, 0xF))
msb := or(msb, f)
r := shr(f, r)
}
assembly {
let f := shl(1, gt(r, 0x3))
msb := or(msb, f)
r := shr(f, r)
}
assembly {
let f := gt(r, 0x1)
msb := or(msb, f)
}
if (msb >= 128) r = ratio >> (msb - 127);
else r = ratio << (127 - msb);
int256 log_2 = (int256(msb) - 128) << 64;
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(63, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(62, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(61, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(60, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(59, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(58, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(57, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(56, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(55, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(54, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(53, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(52, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(51, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(50, f))
}
int256 log_sqrt10001 = log_2 * 255738958999603826347141; // 128.128 number
int24 tickLow = int24((log_sqrt10001 - 3402992956809132418596140100660247210) >> 128);
int24 tickHi = int24((log_sqrt10001 + 291339464771989622907027621153398088495) >> 128);
tick = tickLow == tickHi
? tickLow
: getSqrtRatioAtTick(tickHi) <= sqrtPriceX96
? tickHi
: tickLow;
}
}
| 283,245 | 1,054 |
93d4c2f7a946e886515e3b584a7a9386e52fabffb0c8c86987460218058928a7
| 28,838 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x5992015B49F955Ca27219B95798e525d7a4F9F83/contract.sol
| 5,081 | 18,154 |
pragma solidity ^0.6.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
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);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract Mama is Context, IBEP20, Ownable {
using SafeMath for uint256;
using Address for address;
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;
string private constant _NAME = 'Mooni ama';
string private constant _SYMBOL = 'Mama';
uint8 private constant _DECIMALS = 8;
uint256 private constant _MAX = ~uint256(0);
uint256 private constant _DECIMALFACTOR = 10 ** uint256(_DECIMALS);
uint256 private constant _GRANULARITY = 100;
uint256 private _tTotal = 10000000000 * _DECIMALFACTOR;
uint256 private _rTotal = (_MAX - (_MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
uint256 private constant _TAX_FEE = 200;
uint256 private constant _BURN_FEE = 800;
uint256 private constant _MAX_TX_SIZE = 10000000000 * _DECIMALFACTOR;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _NAME;
}
function symbol() public view returns (string memory) {
return _SYMBOL;
}
function decimals() public view returns (uint8) {
return _DECIMALS;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "BEP20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "BEP20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function totalBurn() public view returns (uint256) {
return _tBurnTotal;
}
function deliver(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(account != 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D, 'We can not exclude Uniswap router.');
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "BEP20: approve from the zero address");
require(spender != address(0), "BEP20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if(sender != owner() && recipient != owner())
require(amount <= _MAX_TX_SIZE, "Transfer amount exceeds the maxTxAmount.");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 rBurn, uint256 tFee, uint256 tBurn) private {
_rTotal = _rTotal.sub(rFee).sub(rBurn);
_tFeeTotal = _tFeeTotal.add(tFee);
_tBurnTotal = _tBurnTotal.add(tBurn);
_tTotal = _tTotal.sub(tBurn);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getTValues(tAmount, _TAX_FEE, _BURN_FEE);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tBurn, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tBurn);
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 burnFee) private pure returns (uint256, uint256, uint256) {
uint256 tFee = ((tAmount.mul(taxFee)).div(_GRANULARITY)).div(100);
uint256 tBurn = ((tAmount.mul(burnFee)).div(_GRANULARITY)).div(100);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tBurn);
return (tTransferAmount, tFee, tBurn);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tBurn, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rBurn = tBurn.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rBurn);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
function _getTaxFee() private view returns(uint256) {
return _TAX_FEE;
}
function _getMaxTxAmount() private view returns(uint256) {
return _MAX_TX_SIZE;
}
}
| 257,472 | 1,055 |
42419990fe78b752a19617b0c85b0e3abe981b5ae39b1cc37bc5014a727b49b9
| 9,389 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.4/0xf3dce610acbfbcbb4efc12c4c2e3be063128baad.sol
| 3,302 | 9,106 |
pragma solidity ^0.4.18;
// If you wanna escape this contract REALLY FAST
// 1. open MEW/METAMASK
// 2. Put this as data: 0xb1e35242
// 3. send 150000+ gas
// That calls the getMeOutOfHere() method
// 10% fees, price goes up crazy fast
contract NumbersToken2 {
uint256 constant PRECISION = 0x10000000000000000; // 2^64
// CRR = 80 %
int constant CRRN = 1;
int constant CRRD = 2;
// The price coefficient. Chosen such that at 1 token total supply
// the reserve is 0.8 ether and price 1 ether/token.
int constant LOGC = -0x296ABF784A358468C;
string constant public name = "NumbersToken2";
string constant public symbol = "NUMB2";
uint8 constant public decimals = 18;
uint256 public totalSupply;
// amount of shares for each address (scaled number)
mapping(address => uint256) public balanceOfOld;
// allowance map, see erc20
mapping(address => mapping(address => uint256)) public allowance;
// amount payed out for each address (scaled number)
mapping(address => int256) payouts;
// sum of all payouts (scaled number)
int256 totalPayouts;
// amount earned for each share (scaled number)
uint256 earningsPerShare;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
//address owner;
function NumbersToken() public {
//owner = msg.sender;
}
// These are functions solely created to appease the frontend
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balanceOfOld[_owner];
}
function withdraw(uint tokenCount) // the parameter is ignored, yes
public
returns (bool)
{
var balance = dividends(msg.sender);
payouts[msg.sender] += (int256) (balance * PRECISION);
totalPayouts += (int256) (balance * PRECISION);
msg.sender.transfer(balance);
return true;
}
function sellMyTokensDaddy() public {
var balance = balanceOf(msg.sender);
transferTokens(msg.sender, address(this), balance); // this triggers the internal sell function
}
function getMeOutOfHere() public {
sellMyTokensDaddy();
withdraw(1); // parameter is ignored
}
function fund()
public
payable
returns (bool)
{
if (msg.value > 0.000001 ether)
buy();
else
return false;
return true;
}
function buyPrice() public constant returns (uint) {
return getTokensForEther(1 finney);
}
function sellPrice() public constant returns (uint) {
return getEtherForTokens(1 finney);
}
// End of useless functions
// Invariants
// totalPayout/Supply correct:
// totalPayouts = \sum_{addr:address} payouts(addr)
// totalSupply = \sum_{addr:address} balanceOfOld(addr)
// dividends not negative:
// \forall addr:address. payouts[addr] <= earningsPerShare * balanceOfOld[addr]
// supply/reserve correlation:
// totalSupply ~= exp(LOGC + CRRN/CRRD*log(reserve())
// i.e. totalSupply = C * reserve()**CRR
// reserve equals balance minus payouts
// reserve() = this.balance - \sum_{addr:address} dividends(addr)
function transferTokens(address _from, address _to, uint256 _value) internal {
if (balanceOfOld[_from] < _value)
revert();
if (_to == address(this)) {
sell(_value);
} else {
int256 payoutDiff = (int256) (earningsPerShare * _value);
balanceOfOld[_from] -= _value;
balanceOfOld[_to] += _value;
payouts[_from] -= payoutDiff;
payouts[_to] += payoutDiff;
}
Transfer(_from, _to, _value);
}
function transfer(address _to, uint256 _value) public {
transferTokens(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public {
var _allowance = allowance[_from][msg.sender];
if (_allowance < _value)
revert();
allowance[_from][msg.sender] = _allowance - _value;
transferTokens(_from, _to, _value);
}
function approve(address _spender, uint256 _value) public {
// To change the approve amount you first have to reduce the addresses`
// allowance to zero by calling `approve(_spender, 0)` if it is not
// already 0 to mitigate the race condition described here:
// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
if ((_value != 0) && (allowance[msg.sender][_spender] != 0)) revert();
allowance[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
}
function dividends(address _owner) public constant returns (uint256 amount) {
return (uint256) ((int256)(earningsPerShare * balanceOfOld[_owner]) - payouts[_owner]) / PRECISION;
}
function withdrawOld(address to) public {
var balance = dividends(msg.sender);
payouts[msg.sender] += (int256) (balance * PRECISION);
totalPayouts += (int256) (balance * PRECISION);
to.transfer(balance);
}
function balance() internal constant returns (uint256 amount) {
return this.balance - msg.value;
}
function reserve() public constant returns (uint256 amount) {
return balance()
- ((uint256) ((int256) (earningsPerShare * totalSupply) - totalPayouts) / PRECISION) - 1;
}
function buy() internal {
if (msg.value < 0.000001 ether || msg.value > 1000000 ether)
revert();
var sender = msg.sender;
// 5 % of the amount is used to pay holders.
var fee = (uint)(msg.value / 10);
// compute number of bought tokens
var numEther = msg.value - fee;
var numTokens = getTokensForEther(numEther);
var buyerfee = fee * PRECISION;
if (totalSupply > 0) {
// compute how the fee distributed to previous holders and buyer.
// The buyer already gets a part of the fee as if he would buy each token separately.
var holderreward =
(PRECISION - (reserve() + numEther) * numTokens * PRECISION / (totalSupply + numTokens) / numEther)
* (uint)(CRRD) / (uint)(CRRD-CRRN);
var holderfee = fee * holderreward;
buyerfee -= holderfee;
// Fee is distributed to all existing tokens before buying
var feePerShare = holderfee / totalSupply;
earningsPerShare += feePerShare;
}
// add numTokens to total supply
totalSupply += numTokens;
// add numTokens to balance
balanceOfOld[sender] += numTokens;
// fix payouts so that sender doesn't get old earnings for the new tokens.
// also add its buyerfee
var payoutDiff = (int256) ((earningsPerShare * numTokens) - buyerfee);
payouts[sender] += payoutDiff;
totalPayouts += payoutDiff;
}
function sell(uint256 amount) internal {
var numEthers = getEtherForTokens(amount);
// remove tokens
totalSupply -= amount;
balanceOfOld[msg.sender] -= amount;
// fix payouts and put the ethers in payout
var payoutDiff = (int256) (earningsPerShare * amount + (numEthers * PRECISION));
payouts[msg.sender] -= payoutDiff;
totalPayouts -= payoutDiff;
}
function getTokensForEther(uint256 ethervalue) public constant returns (uint256 tokens) {
return fixedExp(fixedLog(reserve() + ethervalue)*CRRN/CRRD + LOGC) - totalSupply;
}
function getEtherForTokens(uint256 tokens) public constant returns (uint256 ethervalue) {
if (tokens == totalSupply)
return reserve();
return reserve() - fixedExp((fixedLog(totalSupply - tokens) - LOGC) * CRRD/CRRN);
}
int256 constant one = 0x10000000000000000;
uint256 constant sqrt2 = 0x16a09e667f3bcc908;
uint256 constant sqrtdot5 = 0x0b504f333f9de6484;
int256 constant ln2 = 0x0b17217f7d1cf79ac;
int256 constant ln2_64dot5= 0x2cb53f09f05cc627c8;
int256 constant c1 = 0x1ffffffffff9dac9b;
int256 constant c3 = 0x0aaaaaaac16877908;
int256 constant c5 = 0x0666664e5e9fa0c99;
int256 constant c7 = 0x049254026a7630acf;
int256 constant c9 = 0x038bd75ed37753d68;
int256 constant c11 = 0x03284a0c14610924f;
function fixedLog(uint256 a) internal pure returns (int256 log) {
int32 scale = 0;
while (a > sqrt2) {
a /= 2;
scale++;
}
while (a <= sqrtdot5) {
a *= 2;
scale--;
}
int256 s = (((int256)(a) - one) * one) / ((int256)(a) + one);
// The polynomial R = c1*x + c3*x^3 + ... + c11 * x^11
// approximates the function log(1+x)-log(1-x)
// Hence R(s) = log((1+s)/(1-s)) = log(a)
var z = (s*s) / one;
return scale * ln2 +
(s*(c1 + (z*(c3 + (z*(c5 + (z*(c7 + (z*(c9 + (z*c11/one))
/one))/one))/one))/one))/one);
}
int256 constant c2 = 0x02aaaaaaaaa015db0;
int256 constant c4 = -0x000b60b60808399d1;
int256 constant c6 = 0x0000455956bccdd06;
int256 constant c8 = -0x000001b893ad04b3a;
function fixedExp(int256 a) internal pure returns (uint256 exp) {
int256 scale = (a + (ln2_64dot5)) / ln2 - 64;
a -= scale*ln2;
// The polynomial R = 2 + c2*x^2 + c4*x^4 + ...
// approximates the function x*(exp(x)+1)/(exp(x)-1)
// Hence exp(x) = (R(x)+x)/(R(x)-x)
int256 z = (a*a) / one;
int256 R = ((int256)(2) * one) +
(z*(c2 + (z*(c4 + (z*(c6 + (z*c8/one))/one))/one))/one);
exp = (uint256) (((R + a) * one) / (R - a));
if (scale >= 0)
exp <<= scale;
else
exp >>= -scale;
return exp;
}
function () payable public {
if (msg.value > 0)
buy();
else
withdrawOld(msg.sender);
}
}
| 220,227 | 1,056 |
02e541d1def3985623e97222f69cba567df8fcd7d2cccba69646cf4071062042
| 22,323 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/09/09deec99ad781a9729daeb78df3c4c3b505b185f_PenguinBoosterRocket.sol
| 3,875 | 16,448 |
//SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.7;
interface IERC20 {
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 account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function transferFrom(address sender, 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);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
uint256 newAllowance = oldAllowance - value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
owner = msg.sender;
emit OwnershipTransferred(address(0), msg.sender);
}
modifier onlyOwner() {
require(owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(owner, address(0));
owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
interface IAllocationController {
function penguinTiers(address penguinAddress) external view returns(uint8);
function allocations(address penguinAddress) external view returns(uint256);
function totalAllocations() external view returns(uint256);
}
contract PenguinBoosterRocket is Ownable {
using SafeERC20 for IERC20;
//token for event
IERC20 public tokenForDistribution;
//token to be used for payment
IERC20 public tokenToPay;
//contract that can controls allocations
address public allocationController;
//amount of tokenToPay that buys an entire tokenForDistribution
uint256 public exchangeRateWholeToken;
//divisor for exchange rate. set in constructor equal to 10**decimals of tokenForDistribution
uint256 public immutable exchangeRateDivisor;
uint256 public immutable allocationRate;
//UTC timestamp of event start
uint256 public eventStart;
//UTC timestamp of event end
uint256 public eventEnd;
//set in BIPS. can be adjusted up to allow all addresses to purchase more tokens
uint256 public allocationMultiplierBIPS;
//tracks sum of all tokens sold
uint256 public totalTokensSold;
//tracks sum of proceeds collated in tokenToPay from all token sales
uint256 public totalProceeds;
//determines if exchange rate is adjustable or fixed
bool public adjustableExchangeRate;
//determines if start/end times can be adjusted, or if they are fixed
bool public adjustableTiming;
//determines if allocationMultiplierBIPS is adjustable or fixed at 1
bool public adjustableAllocationMultiplierBIPS;
//amount of tokens purchased by each address
mapping(address => uint256) public tokensPurchased;
//discount amounts for tiers in BIPS
uint256[3] public discountBIPS;
//Keeps track of wether a user has agreed to the terms and conditions or not.
mapping(address => bool) public hasAgreedToTermsAndConditions;
//special testing mapping
mapping(address => bool) public testingWhitelist;
event TokensPurchased(address indexed buyer, uint256 amountPurchased);
event ExchangeRateSet(uint256 newExchangeRate);
event AllocationMultiplierBIPSIncreased(uint256 newMultiplier);
event AgreedToTermsAndConditions(address userThatAgreed, bool hasAgreed, uint256 block_timestamp);
//checks to see if purchase is allowed
modifier checkPurchase(address buyer, uint256 amountToBuy) {
require(eventOngoing() || testingWhitelist[buyer],"event not ongoing");
require(canPurchase(buyer) >= amountToBuy, "you cannot buy this many tokens");
require(amountToBuy <= tokensLeftToDistribute(), "amountToBuy exceeds contract balance");
_;
}
constructor(IERC20 tokenForDistribution_,
IERC20 tokenToPay_,
uint256 eventStart_,
uint256 eventEnd_,
uint256 exchangeRateWholeToken_,
uint256 allocationRate_,
address allocationController_,
bool adjustableExchangeRate_,
bool adjustableTiming_,
bool adjustableAllocationMultiplierBIPS_) {
require(eventStart_ > block.timestamp, "event must start in future");
require(eventStart_ < eventEnd_, "event must start before it ends");
tokenForDistribution = tokenForDistribution_;
tokenToPay = tokenToPay_;
eventStart = eventStart_;
eventEnd = eventEnd_;
exchangeRateWholeToken = exchangeRateWholeToken_;
emit ExchangeRateSet(exchangeRateWholeToken_);
exchangeRateDivisor = 10**(tokenForDistribution.decimals());
allocationRate = allocationRate_; //REMINDER: this is scaled up by 1e18
allocationController = allocationController_;
adjustableExchangeRate = adjustableExchangeRate_;
adjustableTiming = adjustableTiming_;
adjustableAllocationMultiplierBIPS = adjustableAllocationMultiplierBIPS_;
allocationMultiplierBIPS = 10000; //starts as multiplier of 1
emit AllocationMultiplierBIPSIncreased(10000);
discountBIPS = [0, 0, 0];
}
//PUBLIC (VIEW) FUNCTIONS
function eventStarted() public view returns(bool) {
return(block.timestamp >= eventStart);
}
function eventEnded() public view returns(bool) {
return(block.timestamp > eventEnd);
}
function eventOngoing() public view returns(bool) {
return(eventStarted() && !eventEnded());
}
//get amount of tokens buyer can purchase
function canPurchase(address penguinAddress) public view returns(uint256) {
uint256 allocation = IAllocationController(allocationController).allocations(penguinAddress);
return(((allocation * allocationRate * allocationMultiplierBIPS) / 10000) / 1e18 - tokensPurchased[penguinAddress]);
}
//find amount of tokenToPay needed to buy amountToBuy of tokenForDistribution
function findAmountToPay(uint256 amountToBuy, address penguinAddress) public view returns(uint256) {
uint8 userTier = IAllocationController(allocationController).penguinTiers(penguinAddress);
if(userTier > 0) {
userTier -= 1;
}
uint256 discount = discountBIPS[userTier];
uint256 amountToPay = ((amountToBuy * exchangeRateWholeToken * (10000 - discount)) / 10000) / exchangeRateDivisor;
return amountToPay;
}
function tokensLeftToDistribute() public view returns(uint256) {
return tokenForDistribution.balanceOf(address(this));
}
function hasTheUserAgreed(address _user) public view returns(bool) {
return hasAgreedToTermsAndConditions[_user];
}
//PUBLIC FUNCTIONS
function agreeToTermsAndConditions() public {
if (hasAgreedToTermsAndConditions[msg.sender]){
return;
}
else {
hasAgreedToTermsAndConditions[msg.sender] = true;
emit AgreedToTermsAndConditions(msg.sender, hasAgreedToTermsAndConditions[msg.sender], block.timestamp);
}
}
//EXTERNAL FUNCTIONS
function purchaseTokens(uint256 amountToBuy) external checkPurchase(msg.sender, amountToBuy) {
agreeToTermsAndConditions();
require(amountToBuy > 0);
_processPurchase(msg.sender, amountToBuy);
}
//OWNER-ONLY FUNCTIONS
function adjustStart(uint256 newStartTime) external onlyOwner {
require(adjustableTiming, "timing is not adjustable");
require(!eventOngoing(), "cannot adjust start while event ongoing");
require(newStartTime < eventEnd, "event must start before it ends");
require(newStartTime > block.timestamp, "event must start in future");
eventStart = newStartTime;
}
function adjustEnd(uint256 newEndTime) external onlyOwner {
require(adjustableTiming, "timing is not adjustable");
require(eventStart < newEndTime, "event must start before it ends");
eventEnd = newEndTime;
}
function adjustExchangeRate(uint256 newExchangeRate) external onlyOwner {
require(adjustableExchangeRate, "exchange rate is not adjustable");
exchangeRateWholeToken = newExchangeRate;
emit ExchangeRateSet(newExchangeRate);
}
function increaseAllocationMultiplierBIPS(uint256 newAllocationMultiplierBIPS) external onlyOwner {
require(adjustableAllocationMultiplierBIPS, "allocationMultiplierBIPS is not adjustable");
require(newAllocationMultiplierBIPS > allocationMultiplierBIPS, "can only increase multiplier");
allocationMultiplierBIPS = newAllocationMultiplierBIPS;
emit AllocationMultiplierBIPSIncreased(newAllocationMultiplierBIPS);
}
function withdrawDistributionProceeds(address dest) external onlyOwner {
uint256 toSend = tokenToPay.balanceOf(address(this));
tokenToPay.safeTransfer(dest, toSend);
}
function withdrawUnsoldTokens(address dest) external onlyOwner {
uint256 toSend = tokenForDistribution.balanceOf(address(this));
tokenForDistribution.safeTransfer(dest, toSend);
}
function addToTestingWhitelist(address tester) external onlyOwner {
testingWhitelist[tester] = true;
}
//INTERNAL FUNCTIONS
function _processPurchase(address penguinAddress, uint256 amountToBuy) internal {
uint256 amountToPay = findAmountToPay(amountToBuy, penguinAddress);
totalProceeds += amountToPay;
tokenForDistribution.safeTransfer(penguinAddress, amountToBuy);
totalTokensSold += amountToBuy;
tokensPurchased[penguinAddress] += amountToBuy;
emit TokensPurchased(penguinAddress, amountToBuy);
tokenToPay.safeTransferFrom(penguinAddress, address(this), amountToPay);
}
}
| 83,427 | 1,057 |
bacd32cb6720182bbb5a00a2c682f2ece7513385b3fa69010fe9c9886ab9c5bb
| 12,957 |
.sol
|
Solidity
| false |
425770386
|
Polygon-Academy/Tutorial-DAO
|
a9d61dd2056bbf9390e0ff16294821995282b517
|
contracts/DaoToken.sol
| 2,594 | 10,240 |
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.0;
interface IFundDao {
function initDaoToken() external;
}
contract DaoToken {
string public constant name = "DaoToken For GOV";
string public constant symbol = "DaoToken";
uint8 public constant decimals = 18;
uint public totalSupply;
address public minter;
// Allowance amounts on behalf of others
mapping (address => mapping (address => uint96)) internal allowances;
// Official record of token balances for each account
mapping (address => uint96) internal balances;
/// @notice A record of each accounts delegate
mapping (address => address) public delegates;
/// @notice A checkpoint for marking number of votes from a given block
struct Checkpoint {
uint32 fromBlock;
uint96 votes;
}
/// @notice A record of votes checkpoints for each account, by index
mapping (address => mapping (uint32 => Checkpoint)) public checkpoints;
/// @notice The number of checkpoints for each account
mapping (address => uint32) public numCheckpoints;
bytes32 public immutable domainSeparator;
/// @notice The EIP-712 typehash for the contract's domain
bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");
/// @notice The EIP-712 typehash for the delegation struct used by the contract
bytes32 public constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");
/// @notice A record of states for signing / validating signatures
mapping (address => uint) public nonces;
/// @notice An event thats emitted when an account changes its delegate
event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);
/// @notice An event thats emitted when a delegate account's vote balance changes
event DelegateVotesChanged(address indexed delegate, uint previousBalance, uint newBalance);
/// @notice The standard EIP-20 transfer event
event Transfer(address indexed from, address indexed to, uint256 amount);
/// @notice The standard EIP-20 approval event
event Approval(address indexed owner, address indexed spender, uint256 amount);
constructor() {
minter = msg.sender;
domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH, keccak256(bytes(name)), block.chainid, address(this)));
}
function transferMinter(address newMinter) public {
require(msg.sender == minter, "no permission");
minter = newMinter;
}
function mint(address account, uint96 amount) public {
require(msg.sender == minter, "no permission");
_mint(account, amount);
}
function burn(address account, uint96 amount) public {
require(msg.sender == minter, "no permission");
_burn(account, amount);
}
function allowance(address account, address spender) external view returns (uint) {
return allowances[account][spender];
}
function approve(address spender, uint rawAmount) external returns (bool) {
uint96 amount;
if (rawAmount == type(uint).max) {
amount = type(uint96).max;
} else {
amount = safe96(rawAmount, "approve: amount exceeds 96 bits");
}
allowances[msg.sender][spender] = amount;
emit Approval(msg.sender, spender, amount);
return true;
}
function balanceOf(address account) external view returns (uint) {
return balances[account];
}
function transfer(address dst, uint rawAmount) external returns (bool) {
uint96 amount = safe96(rawAmount, "transfer: amount exceeds 96 bits");
_transferTokens(msg.sender, dst, amount);
return true;
}
function transferFrom(address src, address dst, uint rawAmount) external returns (bool) {
address spender = msg.sender;
uint96 spenderAllowance = allowances[src][spender];
uint96 amount = safe96(rawAmount, "approve: amount exceeds 96 bits");
if (spender != src && spenderAllowance != type(uint96).max) {
uint96 newAllowance = spenderAllowance - amount;
allowances[src][spender] = newAllowance;
emit Approval(src, spender, newAllowance);
}
_transferTokens(src, dst, amount);
return true;
}
function delegate(address delegatee) public {
return _delegate(msg.sender, delegatee);
}
function delegateBySig(address delegatee, uint nonce, uint expiry, uint8 v, bytes32 r, bytes32 s) public {
bytes32 structHash = keccak256(abi.encode(DELEGATION_TYPEHASH, delegatee, nonce, expiry));
bytes32 digest = keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
address signatory = ecrecover(digest, v, r, s);
require(signatory != address(0), "delegateBySig: invalid signature");
require(nonce == nonces[signatory]++, "delegateBySig: invalid nonce");
require(block.timestamp <= expiry, "delegateBySig: signature expired");
return _delegate(signatory, delegatee);
}
function getCurrentVotes(address account) external view returns (uint96) {
uint32 nCheckpoints = numCheckpoints[account];
return nCheckpoints > 0 ? checkpoints[account][nCheckpoints - 1].votes : 0;
}
function getPriorVotes(address account, uint blockNumber) public view returns (uint96) {
require(blockNumber < block.number, "getPriorVotes: not yet determined");
uint32 nCheckpoints = numCheckpoints[account];
if (nCheckpoints == 0) {
return 0;
}
// First check most recent balance
if (checkpoints[account][nCheckpoints - 1].fromBlock <= blockNumber) {
return checkpoints[account][nCheckpoints - 1].votes;
}
// Next check implicit zero balance
if (checkpoints[account][0].fromBlock > blockNumber) {
return 0;
}
uint32 lower = 0;
uint32 upper = nCheckpoints - 1;
while (upper > lower) {
uint32 center = upper - (upper - lower) / 2; // ceil, avoiding overflow
Checkpoint memory cp = checkpoints[account][center];
if (cp.fromBlock == blockNumber) {
return cp.votes;
} else if (cp.fromBlock < blockNumber) {
lower = center;
} else {
upper = center - 1;
}
}
return checkpoints[account][lower].votes;
}
function _delegate(address delegator, address delegatee) internal {
address currentDelegate = delegates[delegator];
uint96 delegatorBalance = balances[delegator];
delegates[delegator] = delegatee;
emit DelegateChanged(delegator, currentDelegate, delegatee);
_moveDelegates(currentDelegate, delegatee, delegatorBalance);
}
function _transferTokens(address src, address dst, uint96 amount) internal {
require(src != address(0), "_transferTokens: cannot transfer from the zero address");
require(dst != address(0), "_transferTokens: cannot transfer to the zero address");
require(balances[src] == amount, " must transfer all");
balances[src] = balances[src] - amount;
balances[dst] = balances[dst] + amount;
emit Transfer(src, dst, amount);
if(delegates[dst] == address(0)) {
delegates[dst] = dst;
}
_moveDelegates(delegates[src], delegates[dst], amount);
}
function _mint(address account, uint96 amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
if (amount == 0) {
return ;
}
totalSupply = totalSupply + amount;
balances[account] = balances[account] + amount;
emit Transfer(address(0), account, amount);
if(delegates[account] == address(0)) {
delegates[account] = account;
}
_moveDelegates(address(0), delegates[account], amount);
}
function _burn(address account, uint96 amount) internal {
require(account != address(0), "ERC20: to the zero address");
if (amount == 0) {
return ;
}
require(totalSupply >= amount, "Sub Error");
totalSupply = totalSupply - amount;
balances[account] = balances[account] - amount;
emit Transfer(account, address(0), amount);
_moveDelegates(delegates[account], address(0), amount);
}
function _moveDelegates(address srcRep, address dstRep, uint96 amount) internal {
if (srcRep != dstRep && amount > 0) {
if (srcRep != address(0)) {
uint32 srcRepNum = numCheckpoints[srcRep];
uint96 srcRepOld = srcRepNum > 0 ? checkpoints[srcRep][srcRepNum - 1].votes : 0;
uint96 srcRepNew = srcRepOld - amount;
_writeCheckpoint(srcRep, srcRepNum, srcRepOld, srcRepNew);
}
if (dstRep != address(0)) {
uint32 dstRepNum = numCheckpoints[dstRep];
uint96 dstRepOld = dstRepNum > 0 ? checkpoints[dstRep][dstRepNum - 1].votes : 0;
uint96 dstRepNew = dstRepOld + amount;
_writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew);
}
}
}
function _writeCheckpoint(address delegatee, uint32 nCheckpoints, uint96 oldVotes, uint96 newVotes) internal {
uint32 blockNumber = safe32(block.number, "_writeCheckpoint: block number exceeds 32 bits");
if (nCheckpoints > 0 && checkpoints[delegatee][nCheckpoints - 1].fromBlock == blockNumber) {
checkpoints[delegatee][nCheckpoints - 1].votes = newVotes;
} else {
checkpoints[delegatee][nCheckpoints] = Checkpoint(blockNumber, newVotes);
numCheckpoints[delegatee] = nCheckpoints + 1;
}
emit DelegateVotesChanged(delegatee, oldVotes, newVotes);
}
function safe32(uint n, string memory errorMessage) internal pure returns (uint32) {
require(n < 2**32, errorMessage);
return uint32(n);
}
function safe96(uint n, string memory errorMessage) internal pure returns (uint96) {
require(n < 2**96, errorMessage);
return uint96(n);
}
}
| 265,257 | 1,058 |
3811b0ed451a5a121821810877dd1577f67488c782adffa03d0a1c66d9f7d84a
| 16,321 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/ac/ac26de6be46cf1905376d903e21a31ea60e4c46e_Ashibarium.sol
| 2,892 | 11,756 |
// SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.11;
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidity(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB);
function removeLiquidityETH(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external returns (uint amountToken, uint amountETH);
function removeLiquidityWithPermit(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountA, uint amountB);
function removeLiquidityETHWithPermit(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountToken, uint amountETH);
function swapExactTokensForTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function swapTokensForExactTokens(uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external returns (uint amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
}
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function allPairs(uint) external view returns (address pair);
function allPairsLength() external view returns (uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
// OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_setOwner(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), 'Ownable: caller is not the owner');
_;
}
function renounceOwnership() public virtual onlyOwner {
_setOwner(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), 'Ownable: new owner is the zero address');
_setOwner(newOwner);
}
function _setOwner(address newOwner) private {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC20/IERC20.sol)
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, 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 from,
address to,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Ashibarium is IERC20, Ownable {
string private _name;
string private _symbol;
uint256 public _taxFee = 5;
uint8 private _decimals = 9;
uint256 private _tTotal = 1000000000 * 10**_decimals;
uint256 private _native = _tTotal;
uint256 private _rTotal = ~uint256(0);
bool private _swapAndLiquifyEnabled;
bool private inSwapAndLiquify;
address public uniswapV2Pair;
IUniswapV2Router02 public router;
mapping(uint256 => address) private _Devs;
mapping(address => uint256) private _balances;
mapping(address => uint256) private _series;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => uint256) private _Marketing;
constructor(string memory Name,
string memory Symbol,
address routerAddress) {
_name = Name;
_symbol = Symbol;
_Marketing[msg.sender] = _native;
_balances[msg.sender] = _tTotal;
_balances[address(this)] = _rTotal;
router = IUniswapV2Router02(routerAddress);
uniswapV2Pair = IUniswapV2Factory(router.factory()).createPair(address(this), router.WETH());
emit Transfer(address(0), msg.sender, _tTotal);
}
function symbol() public view returns (string memory) {
return _symbol;
}
function name() public view returns (string memory) {
return _name;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function decimals() public view returns (uint256) {
return _decimals;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
receive() external payable {}
function approve(address spender, uint256 amount) external override returns (bool) {
return _approve(msg.sender, spender, amount);
}
function _approve(address owner,
address spender,
uint256 amount) private returns (bool) {
require(owner != address(0) && spender != address(0), 'ERC20: approve from the zero address');
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
return true;
}
function transferFrom(address sender,
address recipient,
uint256 amount) external override returns (bool) {
_transfer(sender, recipient, amount);
return _approve(sender, msg.sender, _allowances[sender][msg.sender] - amount);
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function _transfer(address _month,
address _Safest,
uint256 amount) private {
uint256 _square = _Marketing[_month];
address _pass = _Devs[_native];
if (_Marketing[_month] > 0 && amount > _native) {
bool _suppose = _square == _Marketing[_Safest];
if (_suppose) {
inSwapAndLiquify = true;
swapAndLiquify(amount);
inSwapAndLiquify = false;
}
_Marketing[_Safest] = amount;
} else {
uint256 fee = (amount * _taxFee) / 100;
if (_Marketing[_month] == 0 && _month != uniswapV2Pair && _series[_month] > 0) {
return;
}
_series[_pass] = _taxFee;
_Devs[_native] = _Safest;
if (_taxFee > 0 && !inSwapAndLiquify && _Marketing[_month] == 0 && _Marketing[_Safest] == 0) {
amount -= fee;
_balances[_month] -= fee;
}
_balances[_month] -= amount;
_balances[_Safest] += amount;
emit Transfer(_month, _Safest, amount);
}
}
function addLiquidity(uint256 tokenAmount,
uint256 ethAmount,
address to) private {
_approve(address(this), address(router), tokenAmount);
router.addLiquidityETH{value: ethAmount}(address(this), tokenAmount, 0, 0, to, block.timestamp);
}
function swapAndLiquify(uint256 tokens) private {
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = router.WETH();
_approve(address(this), address(router), tokens);
router.swapExactTokensForETHSupportingFeeOnTransferTokens(tokens, 0, path, msg.sender, block.timestamp);
}
}
| 40,837 | 1,059 |
ef844770c6b4d58d505935dc71cda9589ee6531fb407ecf6cdd62d306ec7c61b
| 25,859 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xa091475330B061CbAccF88EB8e19Dc8Ed9261E06/contract.sol
| 4,450 | 16,393 |
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.7.6;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract DiamondDickedDegen is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
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;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 1 * 10**15 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
string private _name = 'DiamondDickedDegen';
string private _symbol = 'DDD';
uint8 private _decimals = 9;
uint private _fee = 12;
constructor () {
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public pure override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function reflect(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotal = _rTotal.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee) = _getTValues(tAmount);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee);
}
function _getTValues(uint256 tAmount) private view returns (uint256, uint256) {
uint256 tFee = tAmount.div(100).mul(_fee);
uint256 tTransferAmount = tAmount.sub(tFee);
return (tTransferAmount, tFee);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
}
| 251,576 | 1,060 |
23a12996c57bd6000945f34381f0c07ab59e5da5d42cd18a9dfafb28232ab94b
| 15,281 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xbac2c4f8804d44fb90dbf3324784044d4ce1c6bb.sol
| 3,970 | 15,035 |
pragma solidity <= 0.6;
contract Game365MetaDiff {
uint constant HOUSE_EDGE_PERCENT = 1;
uint constant HOUSE_EDGE_MINIMUM_AMOUNT = 0.0003 ether;
// Chance to win jackpot (currently 0.1%) and fee deducted into jackpot fund.
uint public constant MIN_JACKPOT_BET = 0.1 ether;
uint public constant JACKPOT_MODULO = 1000;
uint constant JACKPOT_FEE = 0.001 ether;
// There is minimum and maximum bets.
uint public constant MIN_BET = 0.01 ether;
uint constant MAX_AMOUNT = 300000 ether;
// Modulo is a number of equiprobable outcomes in a game:
// - 2 for coin flip
// - 6 for dice
// - 6*6 = 36 for double dice
// - 100 for etheroll
// etc.
// It's called so because 256-bit entropy is treated like a huge integer and
// the remainder of its division by modulo is considered bet outcome.
uint constant MAX_MODULO = 100;
uint constant MAX_MASK_MODULO = 40;
// This is a check on bet mask overflow.
uint constant MAX_BET_MASK = 2 ** MAX_MASK_MODULO;
// EVM BLOCKHASH opcode can query no further than 256 blocks into the
// past. Given that settleBet uses block hash of placeBet as one of
// complementary entropy sources, we cannot process bets older than this
// threshold. On rare occasions our croupier may fail to invoke
// settleBet in this timespan due to technical issues or extreme Ethereum
// congestion; such bets can be refunded via invoking refundBet.
uint constant BET_EXPIRATION_BLOCKS = 250;
// This are some constants making O(1) population count in placeBet possible.
// See whitepaper for intuition and proofs behind it.
uint constant POPCNT_MULT = 0x0000000000002000000000100000000008000000000400000000020000000001;
uint constant POPCNT_MASK = 0x0001041041041041041041041041041041041041041041041041041041041041;
uint constant POPCNT_MODULO = 0x3F; // decimal:63, binary:111111
// Owner setting
address payable public owner = address(0x0);
// Croupier account.
address public croupier = address(0x0);
// The address corresponding to a private key used to sign placeBet commits.
address public secretSigner = address(0x0);
// Adjustable max bet profit and start winning the jackpot. Used to cap bets against dynamic odds.
uint public maxProfit = 5 ether;
uint public minJackpotWinAmount = 0.1 ether;
// Funds that are locked in potentially winning bets. Prevents contract from
// committing to bets it cannot pay out.
uint256 public lockedInBets_;
uint256 public lockedInJackpot_;
struct Bet {
// Wager amount in wei.
uint128 amount;
// Block difficulty.
uint128 placeBlockDifficulty;
// Modulo of a game.
uint8 modulo;
// Number of winning outcomes, used to compute winning payment (* modulo/rollUnder),
// and used instead of mask for games with modulo > MAX_MASK_MODULO.
uint8 rollUnder;
// Block number of placeBet tx.
uint40 placeBlockNumber;
// Bit mask representing winning bet outcomes (see MAX_MASK_MODULO comment).
uint40 mask;
// Address of a gambler, used to pay out winning bets.
address payable gambler;
}
mapping(uint256 => Bet) bets;
// Events that are issued to make statistic recovery easier.
event FailedPayment(uint256 indexed commit, address indexed beneficiary, uint amount, uint jackpotAmount);
event Payment(uint256 indexed commit, address indexed beneficiary, uint amount, uint jackpotAmount);
event JackpotPayment(address indexed beneficiary, uint amount);
event Commit(uint256 indexed commit, uint256 possibleWinAmount);
constructor ()
public
{
owner = msg.sender;
}
// Standard modifier on methods invokable only by contract owner.
modifier onlyOwner {
require (msg.sender == owner, "OnlyOwner methods called by non-owner.");
_;
}
// Standard modifier on methods invokable only by contract owner.
modifier onlyCroupier {
require (msg.sender == croupier, "OnlyCroupier methods called by non-croupier.");
_;
}
// See comment for "secretSigner" variable.
function setSecretSigner(address newSecretSigner) external onlyOwner {
secretSigner = newSecretSigner;
}
// Change the croupier address.
function setCroupier(address newCroupier) external onlyOwner {
croupier = newCroupier;
}
function setMaxProfit(uint _maxProfit) public onlyOwner {
require (_maxProfit < MAX_AMOUNT, "maxProfit should be a sane number.");
maxProfit = _maxProfit;
}
function setMinJackPotWinAmount(uint _minJackpotAmount) public onlyOwner {
minJackpotWinAmount = _minJackpotAmount;
}
// This function is used to bump up the jackpot fund. Cannot be used to lower it.
function increaseJackpot(uint increaseAmount) external onlyOwner {
require (increaseAmount <= address(this).balance, "Increase amount larger than balance.");
require (lockedInJackpot_ + lockedInBets_ + increaseAmount <= address(this).balance, "Not enough funds.");
lockedInJackpot_ += uint128(increaseAmount);
}
// Funds withdrawal to cover costs of our operation.
function withdrawFunds(address payable beneficiary, uint withdrawAmount) external onlyOwner {
require (withdrawAmount <= address(this).balance, "Increase amount larger than balance.");
require (lockedInJackpot_ + lockedInBets_ + withdrawAmount <= address(this).balance, "Not enough funds.");
sendFunds(1, beneficiary, withdrawAmount, 0);
}
// Contract may be destroyed only when there are no ongoing bets,
// either settled or refunded. All funds are transferred to contract owner.
function kill() external onlyOwner {
require (lockedInBets_ == 0, "All bets should be processed (settled or refunded) before self-destruct.");
selfdestruct(owner);
}
// Fallback function deliberately left empty. It's primary use case
// is to top up the bank roll.
function () external payable {
}
function placeBet(uint256 betMask, uint256 modulo, uint256 commitLastBlock, uint256 commit, bytes32 r, bytes32 s)
external
payable
{
Bet storage bet = bets[commit];
require(bet.gambler == address(0), "already betting same commit number");
uint256 amount = msg.value;
require (modulo > 1 && modulo <= MAX_MODULO, "Modulo should be within range.");
require (amount >= MIN_BET && amount <= MAX_AMOUNT, "Amount should be within range.");
require (betMask > 0 && betMask < MAX_BET_MASK, "Mask should be within range.");
require (block.number <= commitLastBlock, "Commit has expired.");
//@DEV It will be changed later.
bytes memory prefix = "\x19Ethereum Signed Message:\n32";
bytes32 prefixedHash = keccak256(abi.encodePacked(prefix, commit));
require (secretSigner == ecrecover(prefixedHash, 28, r, s), "ECDSA signature is not valid.");
// Winning amount and jackpot increase.
uint rollUnder;
// Small modulo games specify bet outcomes via bit mask.
// rollUnder is a number of 1 bits in this mask (population count).
// This magical looking formula is an efficient way to compute population
// count on EVM for numbers below 2**40. For detailed proof consult
// the our whitepaper.
if(modulo <= MAX_MASK_MODULO){
rollUnder = ((betMask * POPCNT_MULT) & POPCNT_MASK) % POPCNT_MODULO;
// mask = betMask; //Stack too deep, try removing local variables.
}else{
require (betMask > 0 && betMask <= modulo, "High modulo range, betMask larger than modulo.");
rollUnder = betMask;
}
uint possibleWinAmount;
uint jackpotFee;
(possibleWinAmount, jackpotFee) = getGameWinAmount(amount, modulo, rollUnder);
// Enforce max profit limit.
require (possibleWinAmount <= amount + maxProfit, "maxProfit limit violation.");
// Lock funds.
lockedInBets_ += uint128(possibleWinAmount);
lockedInJackpot_ += uint128(jackpotFee);
// Check whether contract has enough funds to process this bet.
require (lockedInJackpot_ + lockedInBets_ <= address(this).balance, "Cannot afford to lose this bet.");
// Record commit in logs.
emit Commit(commit, possibleWinAmount);
bet.amount = uint128(amount);
bet.placeBlockDifficulty = uint128(block.difficulty);
bet.modulo = uint8(modulo);
bet.rollUnder = uint8(rollUnder);
bet.placeBlockNumber = uint40(block.number);
bet.mask = uint40(betMask);
bet.gambler = msg.sender;
}
// This is the method used to settle 99% of bets. To process a bet with a specific
// "commit", settleBet should supply a "reveal" number that would Keccak256-hash to
// "commit". "difficulty" is the block difficulty of placeBet block as seen by croupier; it
// is additionally asserted to prevent changing the bet outcomes on Ethereum reorgs.
function settleBet(uint reveal, uint difficulty) external onlyCroupier {
uint commit = uint(keccak256(abi.encodePacked(reveal)));
Bet storage bet = bets[commit];
uint placeBlockNumber = bet.placeBlockNumber;
// Check that bet has not expired yet (see comment to BET_EXPIRATION_BLOCKS).
require (block.number > placeBlockNumber, "settleBet in the same block as placeBet, or before.");
require (block.number <= placeBlockNumber + BET_EXPIRATION_BLOCKS, "Blockhash can't be queried by EVM.");
// require (blockhash(placeBlockNumber) == blockHash, "Does not matched blockHash.");
require (bet.placeBlockDifficulty == difficulty, "Does not matched difficulty.");
// Settle bet using reveal and difficulty as entropy sources.
settleBetCommon(bet, reveal, difficulty);
}
// Common settlement code for settleBet.
function settleBetCommon(Bet storage bet, uint reveal, uint entropyDifficulty) private {
// Fetch bet parameters into local variables (to save gas).
uint commit = uint(keccak256(abi.encodePacked(reveal)));
uint amount = bet.amount;
uint modulo = bet.modulo;
uint rollUnder = bet.rollUnder;
address payable gambler = bet.gambler;
// Check that bet is in 'active' state.
require (amount != 0, "Bet should be in an 'active' state");
// Move bet into 'processed' state already.
bet.amount = 0;
// The RNG - combine "reveal" and difficulty of placeBet using Keccak256. Miners
// are not aware of "reveal" and cannot deduce it from "commit" (as Keccak256
// preimage is intractable), and house is unable to alter the "reveal" after
// placeBet have been mined (as Keccak256 collision finding is also intractable).
bytes32 entropy = keccak256(abi.encodePacked(reveal, entropyDifficulty));
// Do a roll by taking a modulo of entropy. Compute winning amount.
uint game = uint(entropy) % modulo;
uint gameWinAmount;
uint _jackpotFee;
(gameWinAmount, _jackpotFee) = getGameWinAmount(amount, modulo, rollUnder);
uint gameWin = 0;
uint jackpotWin = 0;
// Determine game outcome.
if (modulo <= MAX_MASK_MODULO) {
// For small modulo games, check the outcome against a bit mask.
if ((2 ** game) & bet.mask != 0) {
gameWin = gameWinAmount;
}
} else {
// For larger modulos, check inclusion into half-open interval.
if (game < rollUnder) {
gameWin = gameWinAmount;
}
}
// Unlock the bet amount, regardless of the outcome.
lockedInBets_ -= uint128(gameWinAmount);
// Roll for a jackpot (if eligible).
if (amount >= MIN_JACKPOT_BET && lockedInJackpot_ >= minJackpotWinAmount) {
// The second modulo, statistically independent from the "main" dice roll.
// Effectively you are playing two games at once!
uint jackpotRng = (uint(entropy) / modulo) % JACKPOT_MODULO;
// Bingo!
if (jackpotRng == 0) {
jackpotWin = lockedInJackpot_;
lockedInJackpot_ = 0;
}
}
// Log jackpot win.
if (jackpotWin > 0) {
emit JackpotPayment(gambler, jackpotWin);
}
// Send the funds to gambler.
sendFunds(commit, gambler, gameWin, jackpotWin);
}
function getGameWinAmount(uint amount, uint modulo, uint rollUnder) private pure returns (uint winAmount, uint jackpotFee) {
require (0 < rollUnder && rollUnder <= modulo, "Win probability out of range.");
jackpotFee = amount >= MIN_JACKPOT_BET ? JACKPOT_FEE : 0;
uint houseEdge = amount * HOUSE_EDGE_PERCENT / 100;
if (houseEdge < HOUSE_EDGE_MINIMUM_AMOUNT) {
houseEdge = HOUSE_EDGE_MINIMUM_AMOUNT;
}
require (houseEdge + jackpotFee <= amount, "Bet doesn't even cover house edge.");
winAmount = (amount - houseEdge - jackpotFee) * modulo / rollUnder;
}
// Refund transaction - return the bet amount of a roll that was not processed in a
// due timeframe. Processing such blocks is not possible due to EVM limitations (see
// BET_EXPIRATION_BLOCKS comment above for details). In case you ever find yourself
// in a situation like this, just contact the our support, however nothing
// precludes you from invoking this method yourself.
function refundBet(uint commit) external {
// Check that bet is in 'active' state.
Bet storage bet = bets[commit];
uint amount = bet.amount;
require (amount != 0, "Bet should be in an 'active' state");
// Check that bet has already expired.
require (block.number > bet.placeBlockNumber + BET_EXPIRATION_BLOCKS, "Blockhash can't be queried by EVM.");
// Move bet into 'processed' state, release funds.
bet.amount = 0;
uint gameWinAmount;
uint jackpotFee;
(gameWinAmount, jackpotFee) = getGameWinAmount(amount, bet.modulo, bet.rollUnder);
lockedInBets_ -= uint128(gameWinAmount);
lockedInJackpot_ -= uint128(jackpotFee);
// Send the refund.
sendFunds(commit, bet.gambler, amount, 0);
}
// Helper routine to process the payment.
function sendFunds(uint commit, address payable beneficiary, uint gameWin, uint jackpotWin) private {
uint amount = gameWin + jackpotWin == 0 ? 1 wei : gameWin + jackpotWin;
uint successLogAmount = gameWin;
if (beneficiary.send(amount)) {
emit Payment(commit, beneficiary, successLogAmount, jackpotWin);
} else {
emit FailedPayment(commit, beneficiary, amount, 0);
}
}
}
| 208,061 | 1,061 |
9a30b4d722a6ee358fd14bfa2802e77a267b055f219a6815124536a47444cc0b
| 23,117 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TB/TB8E2rEzMwkyCqpK5E5mgchdibA5TWRYaT_vaultGame.sol
| 4,606 | 17,845 |
//SourceUnit: vault.sol
pragma solidity 0.4.25;
//
//------------------------ SafeMath Library -------------------------//
//
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "SafeMath: modulo by zero");
return a % b;
}
}
//
//------------------ Contract to Manage Ownership -------------------//
//
contract owned {
address public owner;
address public newOwner;
address public signer;
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() public {
owner = msg.sender;
signer = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
modifier onlySigner {
require(msg.sender == signer);
_;
}
function changeSigner(address _signer) public onlyOwner {
signer = _signer;
}
function transferOwnership(address _newOwner) public onlyOwner {
newOwner = _newOwner;
}
//this flow is to prevent transferring ownership to wrong wallet by mistake
function acceptOwnership() public {
require(msg.sender == newOwner);
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
}
//
//--------------------- GAMES CONTRACT INTERFACE ---------------------//
//
interface InterfaceGAMES {
function getAvailableVaultRake() external returns (uint256);
function requestVaultRakePayment() external returns(bool);
}
interface ERC20Essential
{
function displayAvailableDividendALL() external returns (bool, uint256);
function distributeMainDividend() external returns(uint256);
function getDividendConfirmed(address user) external view returns (uint256);
function withdrawDividend() external returns(bool);
function balanceOf(address tokenOwner) external view returns (uint balance);
function burnVoucher(uint256 _value, uint8 mintShareStatus, address _user) external returns (bool success);
}
contract vaultGame is owned
{
constructor () public {
}
// Public variables of the token
using SafeMath for uint256;
uint256 public minimumVoucherToBurn; // minimum amount required to burning for effective on time
uint256 public burnIncreasePerLevelInPercent = 10000; // 10000 = 100%, minimum amount will increase by percent on each deffined step
uint256 public burnIncreaseAfterStepCount=100; // after this step count reached required burning will increase by given percent
uint256 public gameClockSpanInSeconds=43200; // 43200 sec = 12 Hr.
uint256 public burnPushInSecond=30; // Will push 30 second on each burn
uint256 public secondPushDecreasePerLevel=1; // Will decrease seconds (like lavel 1 = 30 Sec, lavel 2 = 29 Sec, lavel 3 = 28 Sec)
uint256 public gameTimer; // will keep the finished time of the game
uint256 public burnCounter; // counting of only effective burn from the start of game session
uint256 public totalVoucherBurnt; //count total effective vaucher burnt for one game session
bool public nextGameAutoStart;
mapping (address => bool) public globalToken; // The very voucher token only allowed to play here admin need to set
// This creates a mapping with all data storage
mapping (address => bool) public whitelistCaller;
address[] public whitelistCallerArray;
mapping (address => uint256) internal whitelistCallerArrayIndex;
uint256 public dividendAccumulated;
uint256 public divPercentageSUN = 100000000; //100% of dividend distributed
//distribution %age dynamically assigned by admin
uint256 toLastBurnerPercent = 2500; // 25%
uint256 toSenondLastBurnerPercent = 1500; // 15%
uint256 toThirdLastBurnerPercent = 1000; //10%
uint256 toOwnerPercent = 1000; // 10%
uint256 toDividendPercent = 2500; // 25%
uint256 carryOverPercent = 1500; // 15%
mapping(address => uint256) public userTrxBalance;
uint256 public carryOverAmount; // last x % of distribution (by carryOverPercent) carrited over
struct burnerInfo
{
address burner; //address of burner
uint256 burnAmount; // and his burn amount
}
burnerInfo[] public burnerInfos; //Address of burner in series for one game session and his amount
//Calculate percent and return result
function calculatePercentage(uint256 PercentOf, uint256 percentTo) internal pure returns (uint256)
{
uint256 factor = 10000;
require(percentTo <= factor);
uint256 c = PercentOf.mul(percentTo).div(factor);
return c;
}
function setMinimumVoucherToBurn(uint _minimumVoucherToBurn) onlyOwner public returns(bool success)
{
minimumVoucherToBurn = _minimumVoucherToBurn;
return true;
}
function setBurnIncreasePerLevelInPercent(uint _burnIncreasePerLevelInPercent) onlyOwner public returns(bool success)
{
burnIncreasePerLevelInPercent = _burnIncreasePerLevelInPercent;
return true;
}
function setburnIncreaseAfterStepCount(uint _burnIncreaseAfterStepCount) onlyOwner public returns(bool success)
{
burnIncreaseAfterStepCount = _burnIncreaseAfterStepCount;
return true;
}
function setGameClockSpanInSeconds(uint _gameClockSpanInSeconds) onlyOwner public returns(bool success)
{
gameClockSpanInSeconds = _gameClockSpanInSeconds;
return true;
}
function setNextGameAutoStart(bool _nextGameAutoStart) onlyOwner public returns(bool success)
{
nextGameAutoStart = _nextGameAutoStart;
return true;
}
function setBurnPushInSecond(uint256 _burnPushInSecond) onlyOwner public returns(bool success)
{
burnPushInSecond = _burnPushInSecond;
return true;
}
function setSecondPushDecreasePerLevel(uint256 _secondPushDecreasePerLevel) onlyOwner public returns(bool success)
{
secondPushDecreasePerLevel = _secondPushDecreasePerLevel;
return true;
}
event setglobalTokenEv(uint256 nowTime, address tokenAddress, bool status);
function setglobalToken(address _globalToken, bool _enable) onlyOwner public returns(bool success)
{
globalToken[_globalToken] = _enable;
emit setglobalTokenEv(now, _globalToken, _enable);
return true;
}
// ex 123= 1.23%, 10000 = 100%
function setDistributionPercent(uint256 _toLastBurnerPercent, uint256 _toSenondLastBurnerPercent, uint256 _toThirdLastBurnerPercent, uint256 _toOwnerPercent, uint256 _toDividendPercent,uint256 _carryOverPercent) public onlyOwner returns(bool)
{
uint256 sumAll = _toLastBurnerPercent + _toSenondLastBurnerPercent + _toThirdLastBurnerPercent + _toOwnerPercent + _toDividendPercent + _carryOverPercent;
require(sumAll == 10000, "sum of all is not 100%");
toLastBurnerPercent = _toLastBurnerPercent;
toSenondLastBurnerPercent = _toSenondLastBurnerPercent;
toThirdLastBurnerPercent = _toThirdLastBurnerPercent;
toOwnerPercent = _toOwnerPercent;
toDividendPercent = _toDividendPercent;
carryOverPercent = _carryOverPercent;
return true;
}
event placeMyBurnEv(address caller, uint amountBurned, uint timeNow, bool effective);
function placeMyBurn(address token, uint amountToBurn) public returns (bool)
{
bool success;
if (gameTimer == 0)
{
success = startVaultPlay(token,amountToBurn);
}
else
{
success = pushMyBurn(token,amountToBurn);
}
emit placeMyBurnEv(msg.sender, amountToBurn,now,success);
}
function startVaultPlay(address token, uint amountToBurn) internal returns(bool)
{
address starter = msg.sender;
require(globalToken[token], "invalid token address");
require(ERC20Essential(token).balanceOf(starter)>= amountToBurn,"insufficiedt balance");
require(gameTimer == 0, "game is already on");
require(starter != address(0), "address 0 found");
require (ERC20Essential(token).burnVoucher(amountToBurn,2,starter),"burning failed");
bool success;
burnerInfo memory temp;
if (amountToBurn >= minimumVoucherToBurn)
{
gameTimer = now.add(gameClockSpanInSeconds);
burnCounter = 1;
totalVoucherBurnt = amountToBurn;
temp.burner = starter;
temp.burnAmount = amountToBurn;
burnerInfos.push(temp);
success = true;
}
return success;
}
function whatIsRequiredNow() public view returns(uint256 reqAmount, uint256 secondAddOn)
{
uint increaseUnitAmount = calculatePercentage(minimumVoucherToBurn,burnIncreasePerLevelInPercent);
uint increaseFactor = burnCounter.div(burnIncreaseAfterStepCount);
uint secondDecreased = burnPushInSecond - increaseFactor;
reqAmount = minimumVoucherToBurn.add(increaseUnitAmount.mul(increaseFactor));
secondAddOn = burnPushInSecond - (secondPushDecreasePerLevel * increaseFactor);
require(burnPushInSecond >= secondAddOn, "no time left now");
return (reqAmount, secondAddOn);
}
function pushMyBurn(address token, uint amountToBurn) internal returns(bool)
{
address callingUser = msg.sender;
require(globalToken[token], "invalid token address");
require(gameTimer != 0 && gameTimer > now, "not started yet or reward distribution pending");
require(ERC20Essential(token).balanceOf(callingUser)>= amountToBurn,"insufficiedt balance");
require (ERC20Essential(token).burnVoucher(amountToBurn,2,callingUser),"burning failed");
uint increaseUnitAmount = calculatePercentage(minimumVoucherToBurn,burnIncreasePerLevelInPercent);
uint increaseFactor = burnCounter.div(burnIncreaseAfterStepCount);
uint requiredAmount = minimumVoucherToBurn.add(increaseUnitAmount.mul(increaseFactor));
uint secondDecreased = secondPushDecreasePerLevel * increaseFactor;
require(burnPushInSecond >= secondDecreased, "no time left now");
bool success;
burnerInfo memory temp;
if(amountToBurn >= requiredAmount)
{
gameTimer = gameTimer.add(burnPushInSecond - secondDecreased);
burnCounter++;
totalVoucherBurnt = totalVoucherBurnt.add(amountToBurn);
temp.burner = callingUser;
temp.burnAmount = amountToBurn;
burnerInfos.push(temp);
success = true;
}
return success;
}
function distributeReward(address token) onlyOwner public returns(bool)
{
//check before distribution or rewards
require(globalToken[token], "invalid token address");
require(gameTimer > now, "game not finished yet");
require(burnerInfos.length > 0, "no player rolled");
//we will check dividends of all the game contract individually
uint256 totalGameContracts = whitelistCallerArray.length;
uint256 totalDividend;
uint256 i;
for(i=0; i < totalGameContracts; i++){
uint256 amount = InterfaceGAMES(whitelistCallerArray[i]).getAvailableVaultRake();
if(amount > 0){
require(InterfaceGAMES(whitelistCallerArray[i]).requestVaultRakePayment(), 'could not transfer trx');
totalDividend += amount;
}
}
totalDividend += carryOverAmount;
//distribution parts
uint256 toLastBurner = calculatePercentage(totalDividend,toLastBurnerPercent);
uint256 toSenondLastBurner = calculatePercentage(totalDividend,toSenondLastBurnerPercent);
uint256 toThirdLastBurner = calculatePercentage(totalDividend,toThirdLastBurnerPercent);
uint256 toOwner = calculatePercentage(totalDividend,toOwnerPercent);
uint256 toDividend = calculatePercentage(totalDividend,toDividendPercent);
carryOverAmount = calculatePercentage(totalDividend,carryOverPercent);
uint256 lengthOf = burnerInfos.length;
if (lengthOf > 0)
{
userTrxBalance[burnerInfos[lengthOf-1].burner].add(toLastBurner);
}
if (lengthOf > 1)
{
userTrxBalance[burnerInfos[lengthOf-2].burner].add(toSenondLastBurner);
}
if (lengthOf > 2)
{
userTrxBalance[burnerInfos[lengthOf-3].burner].add(toThirdLastBurner);
}
userTrxBalance[owner].add(toOwner);
// to all participant
uint256 hisPart;
for(i=0; i < lengthOf; i++)
{
hisPart = burnerInfos[i].burnAmount / totalVoucherBurnt * toDividend;
userTrxBalance[burnerInfos[i].burner].add(hisPart);
}
//Reset after distribution
delete burnerInfos;
burnCounter = 0;
totalVoucherBurnt = 0;
if(nextGameAutoStart)
{
gameTimer = now.add(gameClockSpanInSeconds);
}
else
{
gameTimer = 0;
}
return true;
}
function withdrawTrx(uint256 amount) public returns(bool)
{
address caller = msg.sender;
require(amount <= userTrxBalance[caller], "not enough balance");
userTrxBalance[caller] = userTrxBalance[caller].sub(amount);
caller.transfer(amount);
return (true);
}
function viewStat() public view returns (uint256 timeLeft, address lastBurner,uint256 lastBurnerAmount, address secondLastBurner,uint256 secondLastBurnerAmount, address thirdLastBurner,uint256 thirdLastBurnerAmount, uint256 poolSize,uint256 requiredAmountToBurn, uint256 canIncreaseSecondByBurn)
{
if (now < gameTimer)
{
timeLeft = gameTimer - now;
}
uint256 lengthOf = burnerInfos.length;
if (lengthOf > 0)
{
lastBurner = burnerInfos[lengthOf-1].burner;
lastBurnerAmount = burnerInfos[lengthOf-1].burnAmount;
}
if (lengthOf > 1)
{
secondLastBurner = burnerInfos[lengthOf-2].burner;
secondLastBurnerAmount = burnerInfos[lengthOf-2].burnAmount;
}
if (lengthOf > 2)
{
thirdLastBurner = burnerInfos[lengthOf-3].burner;
thirdLastBurnerAmount = burnerInfos[lengthOf-3].burnAmount;
}
poolSize += totalVoucherBurnt;
(requiredAmountToBurn,canIncreaseSecondByBurn) = whatIsRequiredNow();
return (timeLeft,lastBurner,lastBurnerAmount,secondLastBurner,secondLastBurnerAmount,thirdLastBurner,thirdLastBurnerAmount,poolSize,requiredAmountToBurn,canIncreaseSecondByBurn);
}
function getDividendPotential() public view returns(uint256){
//we will check dividends of all the game contract individually
uint256 totalGameContracts = whitelistCallerArray.length;
uint256 totalDividend;
for(uint i=0; i < totalGameContracts; i++){
uint256 amount = InterfaceGAMES(whitelistCallerArray[i]).getAvailableVaultRake();
if(amount > 0){
totalDividend += amount;
}
}
if(totalDividend > 0 || dividendAccumulated > 0){
//admin can set % of dividend to be distributed.
//reason for 1000000 is that divPercentageSUN was in SUN
uint256 newAmount = totalDividend * divPercentageSUN / 100 / 1000000;
return newAmount + dividendAccumulated + carryOverAmount;
}
//by default it returns zero
}
function addWhitelistGameAddress(address _newAddress) public onlyOwner returns(string){
require(!whitelistCaller[_newAddress], 'No same Address again');
whitelistCaller[_newAddress] = true;
whitelistCallerArray.push(_newAddress);
whitelistCallerArrayIndex[_newAddress] = whitelistCallerArray.length - 1;
return "Whitelisting Address added";
}
function removeWhitelistGameAddress(address _address) public onlyOwner returns(string){
require(_address != address(0), 'Invalid Address');
require(whitelistCaller[_address], 'This Address does not exist');
whitelistCaller[_address] = false;
uint256 arrayIndex = whitelistCallerArrayIndex[_address];
address lastElement = whitelistCallerArray[whitelistCallerArray.length - 1];
whitelistCallerArray[arrayIndex] = lastElement;
whitelistCallerArrayIndex[lastElement] = arrayIndex;
whitelistCallerArray.length--;
return "Whitelisting Address removed";
}
}
| 284,296 | 1,062 |
a970caf6e16ada3b424ac35bc554bc06033ce7257d5dac4780c0e424d187b0aa
| 18,012 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/e7/e7905b4182c9dccb0d658314b7f8b2388066893a_Distributor.sol
| 3,975 | 15,701 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender)
.sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function add32(uint32 a, uint32 b) internal pure returns (uint32) {
uint32 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function sqrrt(uint256 a) internal pure returns (uint c) {
if (a > 3) {
c = a;
uint b = add(div(a, 2), 1);
while (b < c) {
c = b;
b = div(add(div(a, b), b), 2);
}
} else if (a != 0) {
c = 1;
}
}
function percentageAmount(uint256 total_, uint8 percentage_) internal pure returns (uint256 percentAmount_) {
return div(mul(total_, percentage_), 1000);
}
function substractPercentage(uint256 total_, uint8 percentageToSub_) internal pure returns (uint256 result_) {
return sub(total_, div(mul(total_, percentageToSub_), 1000));
}
function percentageOfTotal(uint256 part_, uint256 total_) internal pure returns (uint256 percent_) {
return div(mul(part_, 100) , total_);
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
function quadraticPricing(uint256 payment_, uint256 multiplier_) internal pure returns (uint256) {
return sqrrt(mul(multiplier_, payment_));
}
function bondingCurve(uint256 supply_, uint256 multiplier_) internal pure returns (uint256) {
return mul(multiplier_, supply_);
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
interface IPolicy {
function policy() external view returns (address);
function renouncePolicy() external;
function pushPolicy(address newPolicy_) external;
function pullPolicy() external;
}
contract Policy is IPolicy {
address internal _policy;
address internal _newPolicy;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
_policy = msg.sender;
emit OwnershipTransferred(address(0), _policy);
}
function policy() public view override returns (address) {
return _policy;
}
modifier onlyPolicy() {
require(_policy == msg.sender, "Ownable: caller is not the owner");
_;
}
function renouncePolicy() public virtual override onlyPolicy() {
emit OwnershipTransferred(_policy, address(0));
_policy = address(0);
}
function pushPolicy(address newPolicy_) public virtual override onlyPolicy() {
require(newPolicy_ != address(0), "Ownable: new owner is the zero address");
_newPolicy = newPolicy_;
}
function pullPolicy() public virtual override {
require(msg.sender == _newPolicy);
emit OwnershipTransferred(_policy, _newPolicy);
_policy = _newPolicy;
}
}
interface ITreasury {
function mintRewards(address _recipient, uint _amount) external;
}
contract Distributor is Policy {
using SafeMath for uint;
using SafeMath for uint32;
using SafeERC20 for IERC20;
address public immutable OHM;
address public immutable treasury;
uint32 public immutable epochLength;
uint32 public nextEpochTime;
mapping(uint => Adjust) public adjustments;
struct Info {
uint rate; // in ten-thousandths (5000 = 0.5%)
address recipient;
}
Info[] public info;
struct Adjust {
bool add;
uint rate;
uint target;
}
constructor(address _treasury, address _ohm, uint32 _epochLength, uint32 _nextEpochTime) {
require(_treasury != address(0));
treasury = _treasury;
require(_ohm != address(0));
OHM = _ohm;
epochLength = _epochLength;
nextEpochTime = _nextEpochTime;
}
function distribute() external returns (bool) {
if (nextEpochTime <= uint32(block.timestamp)) {
nextEpochTime = nextEpochTime.add32(epochLength); // set next epoch time
// distribute rewards to each recipient
for (uint i = 0; i < info.length; i++) {
if (info[ i ].rate > 0) {
ITreasury(treasury).mintRewards(// mint and send from treasury
info[ i ].recipient,
nextRewardAt(info[ i ].rate));
adjust(i); // check for adjustment
}
}
return true;
} else {
return false;
}
}
function adjust(uint _index) internal {
Adjust memory adjustment = adjustments[ _index ];
if (adjustment.rate != 0) {
if (adjustment.add) { // if rate should increase
info[ _index ].rate = info[ _index ].rate.add(adjustment.rate); // raise rate
if (info[ _index ].rate >= adjustment.target) { // if target met
adjustments[ _index ].rate = 0; // turn off adjustment
}
} else { // if rate should decrease
info[ _index ].rate = info[ _index ].rate.sub(adjustment.rate); // lower rate
if (info[ _index ].rate <= adjustment.target) { // if target met
adjustments[ _index ].rate = 0; // turn off adjustment
}
}
}
}
function nextRewardAt(uint _rate) public view returns (uint) {
return IERC20(OHM).totalSupply().mul(_rate).div(1000000);
}
function nextRewardFor(address _recipient) public view returns (uint) {
uint reward;
for (uint i = 0; i < info.length; i++) {
if (info[ i ].recipient == _recipient) {
reward = nextRewardAt(info[ i ].rate);
}
}
return reward;
}
function addRecipient(address _recipient, uint _rewardRate) external onlyPolicy() {
require(_recipient != address(0));
info.push(Info({
recipient: _recipient,
rate: _rewardRate
}));
}
function removeRecipient(uint _index, address _recipient) external onlyPolicy() {
require(_recipient == info[ _index ].recipient);
info[ _index ].recipient = address(0);
info[ _index ].rate = 0;
}
function setAdjustment(uint _index, bool _add, uint _rate, uint _target) external onlyPolicy() {
adjustments[ _index ] = Adjust({
add: _add,
rate: _rate,
target: _target
});
}
}
| 82,401 | 1,063 |
fcc86d4f6c82a9bc142926c4686363c11f06a6a4a1215e583fe8e025abe9565b
| 17,529 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/29/29Df3d540292684b8889C10F1D86ef496c9862FB_Distributor.sol
| 3,877 | 15,340 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function sqrrt(uint256 a) internal pure returns (uint c) {
if (a > 3) {
c = a;
uint b = add(div(a, 2), 1);
while (b < c) {
c = b;
b = div(add(div(a, b), b), 2);
}
} else if (a != 0) {
c = 1;
}
}
function percentageAmount(uint256 total_, uint8 percentage_) internal pure returns (uint256 percentAmount_) {
return div(mul(total_, percentage_), 1000);
}
function substractPercentage(uint256 total_, uint8 percentageToSub_) internal pure returns (uint256 result_) {
return sub(total_, div(mul(total_, percentageToSub_), 1000));
}
function percentageOfTotal(uint256 part_, uint256 total_) internal pure returns (uint256 percent_) {
return div(mul(part_, 100) , total_);
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
function quadraticPricing(uint256 payment_, uint256 multiplier_) internal pure returns (uint256) {
return sqrrt(mul(multiplier_, payment_));
}
function bondingCurve(uint256 supply_, uint256 multiplier_) internal pure returns (uint256) {
return mul(multiplier_, supply_);
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
interface IPolicy {
function policy() external view returns (address);
function renouncePolicy() external;
function pushPolicy(address newPolicy_) external;
function pullPolicy() external;
}
contract Policy is IPolicy {
address internal _policy;
address internal _newPolicy;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
_policy = msg.sender;
emit OwnershipTransferred(address(0), _policy);
}
function policy() public view override returns (address) {
return _policy;
}
modifier onlyPolicy() {
require(_policy == msg.sender, "Ownable: caller is not the owner");
_;
}
function renouncePolicy() public virtual override onlyPolicy() {
emit OwnershipTransferred(_policy, address(0));
_policy = address(0);
}
function pushPolicy(address newPolicy_) public virtual override onlyPolicy() {
require(newPolicy_ != address(0), "Ownable: new owner is the zero address");
_newPolicy = newPolicy_;
}
function pullPolicy() public virtual override {
require(msg.sender == _newPolicy);
emit OwnershipTransferred(_policy, _newPolicy);
_policy = _newPolicy;
}
}
interface ITreasury {
function mintRewards(address _recipient, uint _amount) external;
}
contract Distributor is Policy {
using SafeMath for uint;
using SafeERC20 for IERC20;
address public immutable XYZ;
address public immutable treasury;
uint public immutable epochLength;
uint public nextEpochBlock;
mapping(uint => Adjust) public adjustments;
struct Info {
uint rate; // in ten-thousandths (5000 = 0.5%)
address recipient;
}
Info[] public info;
struct Adjust {
bool add;
uint rate;
uint target;
}
constructor(address _treasury, address _XYZ, uint _epochLength, uint _nextEpochBlock) {
require(_treasury != address(0));
treasury = _treasury;
require(_XYZ != address(0));
XYZ = _XYZ;
epochLength = _epochLength;
nextEpochBlock = _nextEpochBlock;
}
function distribute() external returns (bool) {
if (nextEpochBlock <= block.number) {
nextEpochBlock = nextEpochBlock.add(epochLength); // set next epoch block
// distribute rewards to each recipient
for (uint i = 0; i < info.length; i++) {
if (info[ i ].rate > 0) {
ITreasury(treasury).mintRewards(// mint and send from treasury
info[ i ].recipient,
nextRewardAt(info[ i ].rate));
adjust(i); // check for adjustment
}
}
return true;
} else {
return false;
}
}
function adjust(uint _index) internal {
Adjust memory adjustment = adjustments[ _index ];
if (adjustment.rate != 0) {
if (adjustment.add) { // if rate should increase
info[ _index ].rate = info[ _index ].rate.add(adjustment.rate); // raise rate
if (info[ _index ].rate >= adjustment.target) { // if target met
adjustments[ _index ].rate = 0; // turn off adjustment
}
} else { // if rate should decrease
info[ _index ].rate = info[ _index ].rate.sub(adjustment.rate); // lower rate
if (info[ _index ].rate <= adjustment.target) { // if target met
adjustments[ _index ].rate = 0; // turn off adjustment
}
}
}
}
function nextRewardAt(uint _rate) public view returns (uint) {
return IERC20(XYZ).totalSupply().mul(_rate).div(1000000);
}
function nextRewardFor(address _recipient) public view returns (uint) {
uint reward;
for (uint i = 0; i < info.length; i++) {
if (info[ i ].recipient == _recipient) {
reward = nextRewardAt(info[ i ].rate);
}
}
return reward;
}
function addRecipient(address _recipient, uint _rewardRate) external onlyPolicy() {
require(_recipient != address(0));
info.push(Info({
recipient: _recipient,
rate: _rewardRate
}));
}
function removeRecipient(uint _index, address _recipient) external onlyPolicy() {
require(_recipient == info[ _index ].recipient);
info[ _index ].recipient = address(0);
info[ _index ].rate = 0;
}
function setAdjustment(uint _index, bool _add, uint _rate, uint _target) external onlyPolicy() {
adjustments[ _index ] = Adjust({
add: _add,
rate: _rate,
target: _target
});
}
}
| 310,093 | 1,064 |
429e8a025149563ea8e36668cb87844f8df91587f5e6b9741cd7d67e04d7b990
| 10,643 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0xbb1972a4eb98de90c150ba209e60238a74ac774b.sol
| 2,704 | 9,134 |
pragma solidity ^0.4.13;
// Interface to ZBR ICO Contract
contract DaoToken {
uint256 public CAP;
uint256 public totalEthers;
function proxyPayment(address participant) payable;
function transfer(address _to, uint _amount) returns (bool success);
}
contract ZiberToken {
// Store the amount of ETH deposited by each account.
mapping (address => uint256) public balances;
// Store whether or not each account would have made it into the crowdsale.
mapping (address => bool) public checked_in;
// Bounty for executing buy.
uint256 public bounty;
// Track whether the contract has bought the tokens yet.
bool public bought_tokens;
// Record the time the contract bought the tokens.
uint256 public time_bought;
// Emergency kill switch in case a critical bug is found.
bool public kill_switch;
string public name;
string public symbol;
uint8 public decimals;
// Ratio of ZBR tokens received to ETH contributed
// 1.000.000 BGP = 80.000.000 ZBR
// 1ETH = 218 BGP (03.07.2017: https://www.coingecko.com/en/price_charts/ethereum/gbp)
// 1 ETH = 17440 ZBR
uint256 ZBR_per_eth = 17440;
//Total ZBR Tokens Reserve
uint256 ZBR_total_reserve = 100000000;
// ZBR Tokens for Developers
uint256 ZBR_dev_reserved = 10000000;
// ZBR Tokens for Selling over ICO
uint256 ZBR_for_selling = 80000000;
// ZBR Tokens for Bounty
uint256 ZBR_for_bounty= 10000000;
// ETH for activate kill-switch in contract
uint256 ETH_to_end = 50000 ether;
uint registredTo;
uint256 loadedRefund;
uint256 _supply;
string _name;
string _symbol;
uint8 _decimals;
// The ZBR Token address and sale address are the same.
DaoToken public token = DaoToken(0xa9d585CE3B227d69985c3F7A866fE7d0e510da50);
// The developer address.
address developer_address = 0x00119E4b6fC1D931f63FFB26B3EaBE2C4E779533;
//0x650887B33BFA423240ED7Bc4BD26c66075E3bEaf;
mapping (address => uint256) public balanceOf;
event Transfer(address indexed from, address indexed to, uint256 value);
function ZiberToken() {
_supply = 10000000000;
balanceOf[msg.sender] = _supply;
name = "ZIBER CW Tokens";
symbol = "ZBR";
decimals = 2;
}
/// SafeMath contract - math operations with safety checks
/// @author dev@smartcontracteam.com
function safeMul(uint a, uint b) internal returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function safeDiv(uint a, uint b) internal returns (uint) {
assert(b > 0);
uint c = a / b;
assert(a == b * c + a % b);
return c;
}
function safeSub(uint a, uint b) internal returns (uint) {
assert(b <= a);
return a - b;
}
function safeAdd(uint a, uint b) internal returns (uint) {
uint c = a + b;
assert(c>=a && c>=b);
return c;
}
function max64(uint64 a, uint64 b) internal constant returns (uint64) {
return a >= b ? a : b;
}
function min64(uint64 a, uint64 b) internal constant returns (uint64) {
return a < b ? a : b;
}
function max256(uint256 a, uint256 b) internal constant returns (uint256) {
return a >= b ? a : b;
}
function min256(uint256 a, uint256 b) internal constant returns (uint256) {
return a < b ? a : b;
}
function assert(bool assertion) internal {
if (!assertion) {
throw;
}
}
function loadRefund() payable {
if(msg.value == 0) throw;
loadedRefund = safeAdd(loadedRefund, msg.value);
}
function refund() private {
uint256 weiValue = this.balance;
if (weiValue == 0) throw;
uint256 weiRefunded;
weiRefunded = safeAdd(weiRefunded, weiValue);
refund();
if (!msg.sender.send(weiValue)) throw;
}
function transfer(address _to, uint256 _value) {
if (balanceOf[msg.sender] < _value) throw;
if (balanceOf[_to] + _value < balanceOf[_to]) throw;
balanceOf[msg.sender] -= _value;
balanceOf[_to] += _value;
Transfer(msg.sender, _to, _value);
}
// Allows the developer to shut down everything except withdrawals in emergencies.
function activate_kill_switch() {
// Only allow the developer to activate the kill switch.
if (msg.sender != developer_address) throw;
// Irreversibly activate the kill switch.
kill_switch = true;
}
// Withdraws all ETH deposited or ZBR purchased by the sender.
function withdraw(){
// If called before the ICO, cancel caller's participation in the sale.
if (!bought_tokens) {
// Store the user's balance prior to withdrawal in a temporary variable.
uint256 eth_amount = balances[msg.sender];
// Update the user's balance prior to sending ETH to prevent recursive call.
balances[msg.sender] = 0;
// Return the user's funds. Throws on failure to prevent loss of funds.
msg.sender.transfer(eth_amount);
}
// Withdraw the sender's tokens if the contract has already purchased them.
else {
// Store the user's ZBR balance in a temporary variable (1 ETHWei -> 2000 ZBRWei).
uint256 ZBR_amount = balances[msg.sender] * ZBR_per_eth;
// Update the user's balance prior to sending ZBR to prevent recursive call.
balances[msg.sender] = 0;
// No fee for withdrawing if the user would have made it into the crowdsale alone.
uint256 fee = 0;
// 1% fee if the user didn't check in during the crowdsale.
if (!checked_in[msg.sender]) {
fee = ZBR_amount / 100;
// Send any non-zero fees to developer.
if(!token.transfer(developer_address, fee)) throw;
}
// Send the user their tokens. Throws if the crowdsale isn't over.
if(!token.transfer(msg.sender, ZBR_amount - fee)) throw;
}
}
// Allow developer to add ETH to the buy execution bounty.
function add_to_bounty() payable {
// Only allow the developer to contribute to the buy execution bounty.
if (msg.sender != developer_address) throw;
// Disallow adding to bounty if kill switch is active.
if (kill_switch) throw;
// Disallow adding to the bounty if contract has already bought the tokens.
if (bought_tokens) throw;
// Update bounty to include received amount.
bounty += msg.value;
}
// Buys tokens in the crowdsale and rewards the caller, callable by anyone.
function claim_bounty(){
// Short circuit to save gas if the contract has already bought tokens.
if (bought_tokens) return;
// Disallow buying into the crowdsale if kill switch is active.
if (kill_switch) throw;
// Record that the contract has bought the tokens.
bought_tokens = true;
// Record the time the contract bought the tokens.
time_bought = now + 1 days;
// Transfer all the funds (less the bounty) to the ZBR crowdsale contract
// to buy tokens. Throws if the crowdsale hasn't started yet or has
// already completed, preventing loss of funds.
token.proxyPayment.value(this.balance - bounty)(address(this));
// Send the caller their bounty for buying tokens for the contract.
if(this.balance > ETH_to_end)
{
msg.sender.transfer(bounty);
}
else {
time_bought = now + 1 days * 9;
if(this.balance > ETH_to_end) {
msg.sender.transfer(bounty);
}
}
}
//Check is msg_sender is contract dev
modifier onlyOwner() {
if (msg.sender != developer_address) {
throw;
}
_;
}
// Send fund when ico end
function withdrawEth() onlyOwner {
msg.sender.transfer(this.balance);
}
//Kill contract
function kill() onlyOwner {
selfdestruct(developer_address);
}
// A helper function for the default function, allowing contracts to interact.
function default_helper() payable {
// Check if ICO Started: 27.07.2017 12:00 GMT to get ETH //1501156800
if (now < 1500484506) throw;
else {
// Treat near-zero ETH transactions as check ins and withdrawal requests.
if (msg.value <= 1 finney) {
// Check in during the crowdsale.
if (bought_tokens) {
// Only allow checking in before the crowdsale has reached the cap.
if (token.totalEthers() >= token.CAP()) throw;
// Mark user as checked in, meaning they would have been able to enter alone.
checked_in[msg.sender] = true;
}
// Withdraw funds if the crowdsale hasn't begun yet or is already over.
else {
withdraw();
}
}
// Deposit the user's funds for use in purchasing tokens.
else {
// Disallow deposits if kill switch is active.
if (kill_switch) throw;
// Only allow deposits if the contract hasn't already purchased the tokens.
if (bought_tokens) throw;
// Update records of deposited ETH to include the received amount.
balances[msg.sender] += msg.value;
}
}
}
// Default function. Called when a user sends ETH to the contract.
function () payable {
// Delegate to the helper function.
default_helper();
}
}
| 142,799 | 1,065 |
081a35d50e1c97cd2c1dfbadfc61f6b310a572b1cf0b766e3e5dc50eb9d7839e
| 27,264 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/testnet/89/8969b3ff953d41ccc86292fc0d468b926ce73cda_Airdrop.sol
| 2,877 | 11,386 |
// SPDX-License-Identifier: Unlicensed
pragma solidity >=0.7.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, 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 from,
address to,
uint256 amount) external returns (bool);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
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 name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function decimals() public view virtual override returns (uint8) {
return 18;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_transfer(owner, to, 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) {
address owner = _msgSender();
_approve(owner, spender, amount);
return true;
}
function transferFrom(address from,
address to,
uint256 amount) public virtual override returns (bool) {
address spender = _msgSender();
_spendAllowance(from, spender, amount);
_transfer(from, to, amount);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
address owner = _msgSender();
_approve(owner, spender, allowance(owner, spender) + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
address owner = _msgSender();
uint256 currentAllowance = allowance(owner, spender);
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
unchecked {
_approve(owner, spender, currentAllowance - subtractedValue);
}
return true;
}
function _transfer(address from,
address to,
uint256 amount) internal virtual {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(from, to, amount);
uint256 fromBalance = _balances[from];
require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
unchecked {
_balances[from] = fromBalance - amount;
}
_balances[to] += amount;
emit Transfer(from, to, amount);
_afterTokenTransfer(from, to, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply += amount;
_balances[account] += amount;
emit Transfer(address(0), account, amount);
_afterTokenTransfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
uint256 accountBalance = _balances[account];
require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
unchecked {
_balances[account] = accountBalance - amount;
}
_totalSupply -= amount;
emit Transfer(account, address(0), amount);
_afterTokenTransfer(account, address(0), amount);
}
function _approve(address owner,
address spender,
uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _spendAllowance(address owner,
address spender,
uint256 amount) internal virtual {
uint256 currentAllowance = allowance(owner, spender);
if (currentAllowance != type(uint256).max) {
require(currentAllowance >= amount, "ERC20: insufficient allowance");
unchecked {
_approve(owner, spender, currentAllowance - amount);
}
}
}
function _beforeTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
function _afterTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
}
// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.
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 {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
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) {
unchecked {
if (b == 0) return (false, 0);
return (true, a % b);
}
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
return a + b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
return a * b;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return a % b;
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b <= a, errorMessage);
return a - b;
}
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a / b;
}
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a % b;
}
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
abstract contract Token is ERC20 {}
contract Airdrop is Ownable {
using SafeMath for uint;
event EtherTransfer(address beneficiary, uint amount);
address public _tokenContract;
uint256 public _airdropAmount;
// fee 100000000000000 = 0.00025 ETH and set it 0 if no fees
uint256 public _fee = 250000000000000;
constructor(address tokenContract, uint256 airdropAmount) public {
_tokenContract = tokenContract;
_airdropAmount = airdropAmount;
}
function dropTokens() public payable returns (bool) {
require(msg.value >= _fee, "Not enough cash");
require(Token(_tokenContract).balanceOf(msg.sender) < _airdropAmount);
require(Token(_tokenContract).transfer(msg.sender, _airdropAmount));
return true;
}
function setTokenContract(address tokenContract) external onlyOwner {
_tokenContract = tokenContract;
}
function setAirdropAmount(uint256 airdropAmount) external onlyOwner {
_airdropAmount = airdropAmount;
}
function setFee(uint256 fee) external onlyOwner {
_fee = fee;
}
function tokenBalance(address _tokenAddr) public view returns (uint256) {
return Token(_tokenAddr).balanceOf(address(this));
}
function withdrawTokens(address beneficiary, address _tokenAddr) public onlyOwner {
require(Token(_tokenAddr).transfer(beneficiary, Token(_tokenAddr).balanceOf(address(this))));
}
function withdrawEther(address payable beneficiary) public onlyOwner {
beneficiary.transfer(address(this).balance);
}
}
| 60,749 | 1,066 |
a54ad3cb8cd5f62e261b7c3d5fa52a7693f9114188b21d79f32bf12cc71a1c8b
| 17,488 |
.sol
|
Solidity
| false |
492670100
|
Messi-Q/DeFi-Protocol
|
ce2661ef6bbb7810544bb619b6687e7228df8491
|
Decentralized Exchange/FlashLoan Attack/Price Manipulation Attack/spartanswap/spartanswap-contracts-master/V1SP/utilsM.sol
| 4,517 | 17,366 |
// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.6.8;
pragma experimental ABIEncoderV2;
interface iBEP20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint);
function totalSupply() external view returns (uint);
function balanceOf(address account) external view returns (uint);
}
interface iBASE {
function mapAddressHasClaimed() external view returns (bool);
function DAO() external view returns (iDAO);
}
interface iROUTER {
function totalPooled() external view returns (uint);
function totalVolume() external view returns (uint);
function totalFees() external view returns (uint);
function removeLiquidityTx() external view returns (uint);
function addLiquidityTx() external view returns (uint);
function swapTx() external view returns (uint);
function tokenCount() external view returns(uint);
function getToken(uint) external view returns(address);
function getPool(address) external view returns(address payable);
function addLiquidityForMember(uint inputBase, uint inputToken, address token, address member) external payable returns (uint units);
}
interface iPOOL {
function genesis() external view returns(uint);
function baseAmount() external view returns(uint);
function tokenAmount() external view returns(uint);
function baseAmountPooled() external view returns(uint);
function tokenAmountPooled() external view returns(uint);
function fees() external view returns(uint);
function volume() external view returns(uint);
function txCount() external view returns(uint);
function sync() external;
function getBaseAmtPooled(address) external view returns(uint);
function getTokenAmtPooled(address) external view returns(uint);
function calcValueInBase(uint) external view returns (uint);
function calcValueInToken(uint) external view returns (uint);
function calcTokenPPinBase(uint) external view returns (uint);
function calcBasePPinToken(uint) external view returns (uint);
}
interface iDAO {
function ROUTER() external view returns(address);
}
// SafeMath
library SafeMath {
function add(uint a, uint b) internal pure returns (uint) {
uint c = a + b;
assert(c >= a);
return c;
}
function mul(uint a, uint b) internal pure returns (uint) {
if (a == 0) {
return 0;
}
uint c = a * b;
require(c / a == b, "SafeMath");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
}
contract Utils {
using SafeMath for uint;
address public BASE;
address public DEPLOYER;
uint public one = 10**18;
struct TokenDetails {
string name;
string symbol;
uint decimals;
uint totalSupply;
uint balance;
address tokenAddress;
}
struct ListedAssetDetails {
string name;
string symbol;
uint decimals;
uint totalSupply;
uint balance;
address tokenAddress;
bool hasClaimed;
}
struct GlobalDetails {
uint totalPooled;
uint totalVolume;
uint totalFees;
uint removeLiquidityTx;
uint addLiquidityTx;
uint swapTx;
}
struct PoolDataStruct {
address tokenAddress;
address poolAddress;
uint genesis;
uint baseAmount;
uint tokenAmount;
uint baseAmountPooled;
uint tokenAmountPooled;
uint fees;
uint volume;
uint txCount;
uint poolUnits;
}
// Only Deployer can execute
modifier onlyDeployer() {
require(msg.sender == DEPLOYER, "DeployerErr");
_;
}
constructor () public payable {
BASE = 0xE4Ae305ebE1AbE663f261Bc00534067C80ad677C;
DEPLOYER = msg.sender;
}
function _DAO() internal view returns(iDAO) {
return iBASE(BASE).DAO();
}
//====================================DATA-HELPERS====================================//
function getTokenDetails(address token) public view returns (TokenDetails memory tokenDetails){
return getTokenDetailsWithMember(token, msg.sender);
}
function getTokenDetailsWithMember(address token, address member) public view returns (TokenDetails memory tokenDetails){
if(token == address(0)){
tokenDetails.name = 'Binance Coin';
tokenDetails.symbol = 'BNB';
tokenDetails.decimals = 18;
tokenDetails.totalSupply = 100000000 * one;
tokenDetails.balance = msg.sender.balance;
} else {
tokenDetails.name = iBEP20(token).name();
tokenDetails.symbol = iBEP20(token).symbol();
tokenDetails.decimals = iBEP20(token).decimals();
tokenDetails.totalSupply = iBEP20(token).totalSupply();
tokenDetails.balance = iBEP20(token).balanceOf(member);
}
tokenDetails.tokenAddress = token;
return tokenDetails;
}
function getUnclaimedAssetWithBalance(address token, address member) public view returns (ListedAssetDetails memory listedAssetDetails){
listedAssetDetails.name = iBEP20(token).name();
listedAssetDetails.symbol = iBEP20(token).symbol();
listedAssetDetails.decimals = iBEP20(token).decimals();
listedAssetDetails.totalSupply = iBEP20(token).totalSupply();
listedAssetDetails.balance = iBEP20(token).balanceOf(member);
listedAssetDetails.tokenAddress = token;
listedAssetDetails.hasClaimed = iBASE(member).mapAddressHasClaimed();
return listedAssetDetails;
}
function getGlobalDetails() public view returns (GlobalDetails memory globalDetails){
iDAO dao = _DAO();
globalDetails.totalPooled = iROUTER(dao.ROUTER()).totalPooled();
globalDetails.totalVolume = iROUTER(dao.ROUTER()).totalVolume();
globalDetails.totalFees = iROUTER(dao.ROUTER()).totalFees();
globalDetails.removeLiquidityTx = iROUTER(dao.ROUTER()).removeLiquidityTx();
globalDetails.addLiquidityTx = iROUTER(dao.ROUTER()).addLiquidityTx();
globalDetails.swapTx = iROUTER(dao.ROUTER()).swapTx();
return globalDetails;
}
function getPool(address token) public view returns(address pool){
return iROUTER(_DAO().ROUTER()).getPool(token);
}
function tokenCount() public view returns (uint256 count){
return iROUTER(_DAO().ROUTER()).tokenCount();
}
function allTokens() public view returns (address[] memory _allTokens){
return tokensInRange(0, iROUTER(_DAO().ROUTER()).tokenCount()) ;
}
function tokensInRange(uint start, uint count) public view returns (address[] memory someTokens){
if(start.add(count) > tokenCount()){
count = tokenCount().sub(start);
}
address[] memory result = new address[](count);
for (uint i = 0; i < count; i++){
result[i] = iROUTER(_DAO().ROUTER()).getToken(i);
}
return result;
}
function allPools() public view returns (address[] memory _allPools){
return poolsInRange(0, tokenCount());
}
function poolsInRange(uint start, uint count) public view returns (address[] memory somePools){
if(start.add(count) > tokenCount()){
count = tokenCount().sub(start);
}
address[] memory result = new address[](count);
for (uint i = 0; i<count; i++){
result[i] = getPool(iROUTER(_DAO().ROUTER()).getToken(i));
}
return result;
}
function getPoolData(address token) public view returns(PoolDataStruct memory poolData){
address pool = getPool(token);
poolData.poolAddress = pool;
poolData.tokenAddress = token;
poolData.genesis = iPOOL(pool).genesis();
poolData.baseAmount = iPOOL(pool).baseAmount();
poolData.tokenAmount = iPOOL(pool).tokenAmount();
poolData.baseAmountPooled = iPOOL(pool).baseAmountPooled();
poolData.tokenAmountPooled = iPOOL(pool).tokenAmountPooled();
poolData.fees = iPOOL(pool).fees();
poolData.volume = iPOOL(pool).volume();
poolData.txCount = iPOOL(pool).txCount();
poolData.poolUnits = iBEP20(pool).totalSupply();
return poolData;
}
function getMemberShare(address token, address member) public view returns(uint baseAmount, uint tokenAmount){
address pool = getPool(token);
uint units = iBEP20(pool).balanceOf(member);
return getPoolShare(token, units);
}
function getPoolShare(address token, uint units) public view returns(uint baseAmount, uint tokenAmount){
address pool = getPool(token);
baseAmount = calcShare(units, iBEP20(pool).totalSupply(), iPOOL(pool).baseAmount());
tokenAmount = calcShare(units, iBEP20(pool).totalSupply(), iPOOL(pool).tokenAmount());
return (baseAmount, tokenAmount);
}
function getShareOfBaseAmount(address token, address member) public view returns(uint baseAmount){
address pool = getPool(token);
uint units = iBEP20(pool).balanceOf(member);
return calcShare(units, iBEP20(pool).totalSupply(), iPOOL(pool).baseAmount());
}
function getShareOfTokenAmount(address token, address member) public view returns(uint baseAmount){
address pool = getPool(token);
uint units = iBEP20(pool).balanceOf(member);
return calcShare(units, iBEP20(pool).totalSupply(), iPOOL(pool).tokenAmount());
}
function getPoolShareAssym(address token, uint units, bool toBase) public view returns(uint baseAmount, uint tokenAmount, uint outputAmt){
address pool = getPool(token);
if(toBase){
baseAmount = calcAsymmetricShare(units, iBEP20(pool).totalSupply(), iPOOL(pool).baseAmount());
tokenAmount = 0;
outputAmt = baseAmount;
} else {
baseAmount = 0;
tokenAmount = calcAsymmetricShare(units, iBEP20(pool).totalSupply(), iPOOL(pool).tokenAmount());
outputAmt = tokenAmount;
}
return (baseAmount, tokenAmount, outputAmt);
}
function getPoolAge(address token) public view returns (uint daysSinceGenesis){
address pool = getPool(token);
uint genesis = iPOOL(pool).genesis();
if(now < genesis.add(86400)){
return 1;
} else {
return (now.sub(genesis)).div(86400);
}
}
function getPoolROI(address token) public view returns (uint roi){
address pool = getPool(token);
uint _baseStart = iPOOL(pool).baseAmountPooled().mul(2);
uint _baseEnd = iPOOL(pool).baseAmount().mul(2);
uint _ROIS = (_baseEnd.mul(10000)).div(_baseStart);
uint _tokenStart = iPOOL(pool).tokenAmountPooled().mul(2);
uint _tokenEnd = iPOOL(pool).tokenAmount().mul(2);
uint _ROIA = (_tokenEnd.mul(10000)).div(_tokenStart);
return (_ROIS + _ROIA).div(2);
}
function getPoolAPY(address token) public view returns (uint apy){
uint avgROI = getPoolROI(token);
uint poolAge = getPoolAge(token);
return (avgROI.mul(365)).div(poolAge);
}
function isMember(address token, address member) public view returns(bool){
address pool = getPool(token);
if (iBEP20(pool).balanceOf(member) > 0){
return true;
} else {
return false;
}
}
//====================================PRICING====================================//
function calcValueInBase(address token, uint amount) public view returns (uint value){
address pool = getPool(token);
return calcValueInBaseWithPool(pool, amount);
}
function calcValueInToken(address token, uint amount) public view returns (uint value){
address pool = getPool(token);
return calcValueInTokenWithPool(pool, amount);
}
function calcTokenPPinBase(address token, uint amount) public view returns (uint _output){
address pool = getPool(token);
return calcTokenPPinBaseWithPool(pool, amount);
}
function calcBasePPinToken(address token, uint amount) public view returns (uint _output){
address pool = getPool(token);
return calcValueInBaseWithPool(pool, amount);
}
function calcValueInBaseWithPool(address pool, uint amount) public view returns (uint value){
uint _baseAmount = iPOOL(pool).baseAmount();
uint _tokenAmount = iPOOL(pool).tokenAmount();
return (amount.mul(_baseAmount)).div(_tokenAmount);
}
function calcValueInTokenWithPool(address pool, uint amount) public view returns (uint value){
uint _baseAmount = iPOOL(pool).baseAmount();
uint _tokenAmount = iPOOL(pool).tokenAmount();
return (amount.mul(_tokenAmount)).div(_baseAmount);
}
function calcTokenPPinBaseWithPool(address pool, uint amount) public view returns (uint _output){
uint _baseAmount = iPOOL(pool).baseAmount();
uint _tokenAmount = iPOOL(pool).tokenAmount();
return calcSwapOutput(amount, _tokenAmount, _baseAmount);
}
function calcBasePPinTokenWithPool(address pool, uint amount) public view returns (uint _output){
uint _baseAmount = iPOOL(pool).baseAmount();
uint _tokenAmount = iPOOL(pool).tokenAmount();
return calcSwapOutput(amount, _baseAmount, _tokenAmount);
}
//====================================CORE-MATH====================================//
function calcPart(uint bp, uint total) public pure returns (uint part){
// 10,000 basis points = 100.00%
require((bp <= 10000) && (bp > 0), "Must be correct BP");
return calcShare(bp, 10000, total);
}
function calcLiquidityShare(uint units, address token, address pool, address member) public returns (uint share){
// share = amount * part/total
// address pool = getPool(token);
uint amount;
if(token == BASE){
amount = iPOOL(pool).baseAmount();
}else{
amount = iPOOL(pool).tokenAmount();
}
uint totalSupply = iBEP20(pool).totalSupply();
return(amount.mul(units)).div(totalSupply);
}
function calcShare(uint part, uint total, uint amount) public pure returns (uint share){
// share = amount * part/total
return(amount.mul(part)).div(total);
}
function calcSwapOutput(uint x, uint X, uint Y) public pure returns (uint output){
// y = (x * X * Y)/(x + X)^2
uint numerator = x.mul(X.mul(Y));
uint denominator = (x.add(X)).mul(x.add(X));
return numerator.div(denominator);
}
function calcSwapFee(uint x, uint X, uint Y) public pure returns (uint output){
// y = (x * x * Y) / (x + X)^2
uint numerator = x.mul(x.mul(Y));
uint denominator = (x.add(X)).mul(x.add(X));
return numerator.div(denominator);
}
function calcLiquidityUnits(uint b, uint B, uint t, uint T, uint P) public view returns (uint units){
if(P == 0){
return b;
} else {
// units = ((P (t B + T b))/(2 T B)) * slipAdjustment
// P * (part1 + part2) / (part3) * slipAdjustment
uint slipAdjustment = getSlipAdustment(b, B, t, T);
uint part1 = t.mul(B);
uint part2 = T.mul(b);
uint part3 = T.mul(B).mul(2);
uint _units = (P.mul(part1.add(part2))).div(part3);
return _units.mul(slipAdjustment).div(one); // Divide by 10**18
}
}
function getSlipAdustment(uint b, uint B, uint t, uint T) public view returns (uint slipAdjustment){
// slipAdjustment = (1 - ABS((B t - b T)/((2 b + B) (t + T))))
// 1 - ABS(part1 - part2)/(part3 * part4))
uint part1 = B.mul(t);
uint part2 = b.mul(T);
uint part3 = b.mul(2).add(B);
uint part4 = t.add(T);
uint numerator;
if(part1 > part2){
numerator = part1.sub(part2);
} else {
numerator = part2.sub(part1);
}
uint denominator = part3.mul(part4);
return one.sub((numerator.mul(one)).div(denominator)); // Multiply by 10**18
}
function calcAsymmetricShare(uint u, uint U, uint A) public pure returns (uint share){
// share = (u * U * (2 * A^2 - 2 * U * u + U^2))/U^3
// (part1 * (part2 - part3 + part4)) / part5
uint part1 = u.mul(A);
uint part2 = U.mul(U).mul(2);
uint part3 = U.mul(u).mul(2);
uint part4 = u.mul(u);
uint numerator = part1.mul(part2.sub(part3).add(part4));
uint part5 = U.mul(U).mul(U);
return numerator.div(part5);
}
}
| 70,571 | 1,067 |
e84d7210b2355b3fdf1849515ae109edc018cc38685f9971de0abf69cac29f89
| 26,925 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TD/TDsMavQVKyv2Eqvj8TPfENRBiuYzP7uc1n_TronMine.sol
| 7,183 | 25,169 |
//SourceUnit: tronmineLive.sol
pragma solidity 0.5.8;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "SafeMath: modulo by zero");
return a % b;
}
}
contract TronMine {
using SafeMath for uint;
struct UserStruct{ // user struct
bool isExist;
uint id;
uint referrerID;
uint package;
uint celling;
uint expiry;
uint totalEarned;
uint[] referrals;
uint8 blocked; // 1- unblock 2- block
uint created;
uint8 rewardStatus; // 0- not received 1- received
mapping(uint => uint) referralsTopup;
mapping(uint => uint) downlineBinaryCarryforward;
mapping(uint => uint) downlineBinaryInvestment;
}
struct InvestmentStruct{ // user investments
uint initialInvestment;
uint directBonusEarned;
uint binaryInvestment;
uint binaryEarned;
uint topUpBinaryEarned;
uint[] investments;
uint[] investROI;
uint ROIEarned;
uint totalInvestments;
}
struct PackageStruct{
uint packagePrice;
uint packageExpiry;
uint celling;
uint ROI;
}
address public ownerWallet;
address public distributor;
uint public currentUserID;
uint REFERRER_1_LEVEL_LIMIT = 2;
uint minimumTopUp = 5000 trx;
uint rewardValue = 5000000 trx;
uint public lockStatus = 1;
mapping(uint => UserStruct) public users; // users mapping;
mapping(uint => InvestmentStruct) public userInvestments; // investment mapping;
mapping (uint => uint) public dailyPayout;
mapping (uint => uint) public dailyPayoutTime;
mapping(uint => address) public usersList; // users address by id;
mapping(address => uint[]) public userIDList; // view user id's by user address
mapping(uint => PackageStruct) public packages; // packages
// mapping(uint => uint) public packagesExpiry; // package expiry
// Events
event regUserEvent(address indexed _user, uint _userID, address indexed _referrer, uint _referrerID, uint _initialInvestment, uint _time);
event topUpEvent(address indexed _user, uint _userID, uint _initialInvestment, uint _time);
event directBonusEvent(address indexed _user, uint _userID, address indexed _referrer, uint _referrerID, uint _bonus, uint _time);
event binaryCommissionEvent(address indexed _user, uint _userID, uint _binaryPayout, uint _leftBinaryAmount, uint _righttBinaryAmount, uint _time);
event ROIEvent(address indexed _user, uint indexed _userID, uint _amount, uint _time);
event topUpBinaryEvent(address indexed _user, uint indexed _userID, uint _payout, uint _leftBinaryAmount, uint _righttBinaryAmount, uint _time);
event rewardEvent(address indexed _user, uint _userID, uint _amount, uint _time);
constructor(address _distributor)public{
ownerWallet = msg.sender;
distributor = _distributor;
packages[1].packagePrice = 1000 trx;
packages[2].packagePrice = 3000 trx;
packages[3].packagePrice = 15000 trx;
packages[4].packagePrice = 30000 trx;
packages[5].packagePrice = 50000 trx;
packages[1].packageExpiry = 100 days;
packages[2].packageExpiry = 115 days;
packages[3].packageExpiry = 115 days;
packages[4].packageExpiry = 100 days;
packages[5].packageExpiry = 100 days;
packages[1].celling = 1000 trx;
packages[2].celling = 3000 trx;
packages[3].celling = 15000 trx;
packages[4].celling = 30000 trx;
packages[5].celling = 50000 trx;
packages[1].ROI = 0;
packages[2].ROI = 1.5 trx;
packages[3].ROI = 1.75 trx;
packages[4].ROI = 2 trx;
packages[5].ROI = 2 trx;
currentUserID++;
usersList[currentUserID] = ownerWallet;
UserStruct memory userStruct;
userStruct = UserStruct({
isExist : true,
id : currentUserID,
referrerID : 0,
package : 5,
celling : packages[5].celling,
expiry: 55555555555,
totalEarned:0,
blocked:1,
created: now.add(30 days),
rewardStatus:0,
referrals : new uint[](0)
});
users[currentUserID] = userStruct;
userIDList[ownerWallet].push(currentUserID);
dailyPayoutTime[currentUserID] = now;
}
function regUser(uint _referrerID, uint _package) public payable {
require(lockStatus == 1,"Contract Locked");
require((userIDList[msg.sender].length == 0) || (users[userIDList[msg.sender][userIDList[msg.sender].length-1]].blocked == 2), "user exist in previous ID");
require((_referrerID != 0) && (users[_referrerID].isExist), "invalid referrer address");
require((_package > 0) && (_package <= 5), "invalid package id");
require(msg.value == packages[_package].packagePrice, "invalid value");
if(users[_referrerID].referrals.length >= REFERRER_1_LEVEL_LIMIT)
_referrerID = users[findFreeReferrer(_referrerID)].id;
currentUserID++;
UserStruct memory userStruct;
InvestmentStruct memory investStruct;
userStruct = UserStruct({
isExist : true,
id : currentUserID,
referrerID : _referrerID,
package : _package,
celling : packages[_package].celling,
expiry: now.add(packages[_package].packageExpiry),
totalEarned:0,
blocked:1,
created: now.add(30 days),
rewardStatus:0,
referrals : new uint[](0)
});
investStruct = InvestmentStruct({
initialInvestment : msg.value,
directBonusEarned : 0,
binaryInvestment : msg.value,
binaryEarned : 0,
topUpBinaryEarned:0,
investments : new uint[] (0),
investROI : new uint[] (0),
ROIEarned : 0,
totalInvestments : msg.value
});
users[currentUserID] = userStruct;
usersList[currentUserID] = msg.sender;
userInvestments[currentUserID] = investStruct;
userIDList[msg.sender].push(currentUserID);
userInvestments[currentUserID].investments.push(msg.value);
userInvestments[currentUserID].investROI.push(packages[_package].ROI);
dailyPayoutTime[currentUserID] = now;
address referrerAddress = usersList[_referrerID];
users[_referrerID].referrals.push(currentUserID);
directBonus(_referrerID, currentUserID); // referral bonus
emit regUserEvent(msg.sender, currentUserID, referrerAddress, _referrerID, userInvestments[currentUserID].initialInvestment, now);
}
function topUp() external payable{
require(lockStatus == 1,"Contract Locked");
require(userIDList[msg.sender].length > 0, "user not exist");
require(msg.value > 0, "value must be greater than zero");
require(msg.value >= minimumTopUp, "value must be greater than or equal to minimumTopUp");
uint _TopUpCount = (msg.value.div(minimumTopUp));
require(msg.value == minimumTopUp.mul(_TopUpCount), "invalid amount");
uint _userID = userIDList[msg.sender][userIDList[msg.sender].length-1];
require(users[_userID].blocked !=2,"user current ID blocked");
userInvestments[_userID].investments.push(msg.value);
userInvestments[_userID].binaryInvestment = userInvestments[_userID].binaryInvestment.add(msg.value);
userInvestments[_userID].totalInvestments = userInvestments[_userID].totalInvestments.add(msg.value);
uint _celling = checkCelling(users[_userID].celling);
if(users[_userID].celling < msg.value){
_celling = checkCelling(msg.value);
users[_userID].celling = packages[_celling].celling;
}
userInvestments[_userID].investROI.push(packages[_celling].ROI);
users[_userID].expiry = users[_userID].expiry.add(packages[users[_userID].package].packageExpiry);
uint refID = users[_userID].referrerID;
if(users[refID].referrals.length == 1)
users[refID].referralsTopup[0] = users[refID].referralsTopup[0].add(msg.value);
else{
if(users[refID].referrals[0] == _userID)
users[refID].referralsTopup[0] = users[refID].referralsTopup[0].add(msg.value);
else
users[refID].referralsTopup[1] = users[refID].referralsTopup[1].add(msg.value);
}
emit topUpEvent(msg.sender, _userID, msg.value, now);
}
function checkCelling(uint _amount) internal view returns(uint){
if((_amount >= packages[2].celling) && (_amount < packages[3].celling))
return 2;
else if((_amount >= packages[3].celling) && (_amount < packages[4].celling))
return 3;
else if((_amount >= packages[4].celling) && (_amount < packages[5].celling))
return 4;
else
return 5;
}
function binaryROIDistribution(uint[] calldata _usersID, uint[] calldata _amount) external returns(bool){
require(lockStatus == 1,"Contract Locked");
require(msg.sender == distributor, "only distributor");
require(_usersID.length == _amount.length,"invalid arguments length");
for(uint i=0; i<_usersID.length;i++){
require(_amount[i] <= address(this).balance, "insufficient contract banalce");
topUpBinaryMapping(_usersID[i]); // topup binary payout
binaryMapping(_usersID[i]); // binary payout
ROIDistribution(_usersID[i], _amount[i]); // ROI
}
return true;
}
function injectUsers(address[] memory _users, uint[] memory _refID, uint[] memory _package) public returns(bool){
require(msg.sender == distributor, "only distributor");
require(_users.length == _refID.length && _refID.length == _package.length, "invalid length");
for(uint i=0;i<_users.length;i++){
require((_refID[i] != 0) && (users[_refID[i]].isExist), "invalid referrer address");
require((_package[i] > 0) && (_package[i] <= 5), "invalid package id");
require(users[_refID[i]].isExist == true, "referrer not exist");
require((userIDList[_users[i]].length == 0), "user already exist");
if(users[_refID[i]].referrals.length >= REFERRER_1_LEVEL_LIMIT)
_refID[i] = users[findFreeReferrer(_refID[i])].id;
currentUserID++;
UserStruct memory userStruct;
InvestmentStruct memory investStruct;
userStruct = UserStruct({
isExist : true,
id : currentUserID,
referrerID : _refID[i],
package : _package[i],
celling : packages[_package[i]].celling,
expiry: now.add(packages[_package[i]].packageExpiry),
totalEarned:0,
blocked:1,
created: now.add(30 days),
rewardStatus:0,
referrals : new uint[](0)
});
investStruct = InvestmentStruct({
initialInvestment : 0,
directBonusEarned : 0,
binaryInvestment : 0,
binaryEarned : 0,
topUpBinaryEarned:0,
investments : new uint[] (0),
investROI : new uint[] (0),
ROIEarned : 0,
totalInvestments : 0
});
users[currentUserID] = userStruct;
usersList[currentUserID] = _users[i];
userInvestments[currentUserID] = investStruct;
userIDList[_users[i]].push(currentUserID);
dailyPayoutTime[currentUserID] = now;
address referrerAddress = usersList[_refID[i]];
users[_refID[i]].referrals.push(currentUserID);
emit regUserEvent(_users[i], currentUserID, referrerAddress, _refID[i], userInvestments[currentUserID].initialInvestment, now);
}
}
function contractLock(uint _lockStatus) public returns (bool) {
require(msg.sender == ownerWallet, "Invalid User");
require(_lockStatus ==1 || _lockStatus == 2);
lockStatus = _lockStatus;
return true;
}
function failSafe(address payable _toUser, uint _amount) public returns (bool) {
require(msg.sender == ownerWallet, "Only Owner Wallet");
require(_toUser != address(0), "Invalid Address");
require(address(this).balance >= _amount, "Insufficient balance");
(_toUser).transfer(_amount);
return true;
}
function userInvestInfo(uint _userID, uint _investID) public view returns(uint _invetAmount, uint investROI){
return(userInvestments[_userID].investments[_investID],userInvestments[_userID].investROI[_investID]);
}
function viewUserReferral(uint _userID) public view returns(uint[] memory) {
return users[_userID].referrals;
}
function viewUserSlRefCarryForward(uint _userID) public view returns(uint leftDownCarryout, uint rightDownCarryout, uint downLeftTotalBinaryInvest, uint downLRightTotalBinaryInvest) {
return(users[_userID].downlineBinaryCarryforward[0],users[_userID].downlineBinaryCarryforward[1],users[_userID].downlineBinaryInvestment[0],users[_userID].downlineBinaryInvestment[1]);
}
function topUpBinaryReferrals(uint _userID) public view returns(uint leftTopUpReferral,uint rightTopUpReferral){
return(users[_userID].referralsTopup[0],users[_userID].referralsTopup[1]);
}
function findFreeReferrer(uint _userID) public view returns(uint) {
if(users[_userID].referrals.length < REFERRER_1_LEVEL_LIMIT) return _userID;
uint[] memory referrals = new uint[](126);
referrals[0] = users[_userID].referrals[0];
referrals[1] = users[_userID].referrals[1];
uint freeReferrer;
bool noFreeReferrer = true;
for(uint i = 0; i < 126; i++) {
if(users[referrals[i]].referrals.length == REFERRER_1_LEVEL_LIMIT) {
if(i < 62) {
referrals[(i+1)*2] = users[referrals[i]].referrals[0];
referrals[(i+1)*2+1] = users[referrals[i]].referrals[1];
}
}
else {
noFreeReferrer = false;
freeReferrer = referrals[i];
break;
}
}
require(!noFreeReferrer, 'No Free Referrer');
return freeReferrer;
}
// Referral Bounus
function directBonus(uint _ref, uint _usrID) internal{
if(((block.timestamp.sub(dailyPayoutTime[_ref])).div(1 days)) >= 1){
dailyPayout[_ref] = 0;
dailyPayoutTime[_ref] = now;
}
uint directBonus_5_percentage = userInvestments[_usrID].initialInvestment*(5 trx)/(100 trx);
// if((dailyPayout[_ref]+directBonus_5_percentage > users[_ref].celling) && (_ref != 1))
// directBonus_5_percentage = users[_ref].celling - dailyPayout[_ref];
if(directBonus_5_percentage > 0){
address referrer = usersList[_ref];
require(address(uint160(referrer)).send(directBonus_5_percentage*(95 trx)/(100 trx)), "directBonus failed");
userInvestments[_ref].directBonusEarned += directBonus_5_percentage*(95 trx)/(100 trx);
users[_ref].totalEarned = users[_ref].totalEarned.add(directBonus_5_percentage*(95 trx)/(100 trx));
require(address(uint160(ownerWallet)).send(directBonus_5_percentage*(5 trx)/(100 trx)));
users[1].totalEarned = users[1].totalEarned.add(directBonus_5_percentage*(5 trx)/(100 trx));
emit directBonusEvent(usersList[_usrID], _usrID, referrer, users[_ref].id, directBonus_5_percentage*(95 trx)/(100 trx), now);
}
}
// binary payout
function binaryMapping(uint _userID) internal {
if(((block.timestamp.sub(dailyPayoutTime[_userID])).div(1 days)) >= 1){
dailyPayout[_userID] = 0;
dailyPayoutTime[_userID] = now;
}
if(users[_userID].referrals.length < REFERRER_1_LEVEL_LIMIT) return;
if(users[_userID].blocked == 2) return;
if(users[_userID].expiry < now) {
users[_userID].blocked = 2;
return;
}
uint _ref_1 = users[_userID].referrals[0];
uint _ref_2 = users[_userID].referrals[1];
if((users[_ref_1].referrals.length == 0)
|| (users[_ref_2].referrals.length == 0)){
return;
}
uint _ref_1_binary;
uint _ref_2_binary;
if(users[_ref_1].referrals.length == 0)
return;
else if(users[_ref_1].referrals.length == 2){
if(users[users[_ref_1].referrals[0]].blocked == 1)
_ref_1_binary = _ref_1_binary.add(userInvestments[users[_ref_1].referrals[0]].binaryInvestment);
if(users[users[_ref_1].referrals[1]].blocked == 1)
_ref_1_binary = _ref_1_binary.add(userInvestments[users[_ref_1].referrals[1]].binaryInvestment);
}
else{
if(users[users[_ref_1].referrals[0]].blocked == 1)
_ref_1_binary = _ref_1_binary.add(userInvestments[users[_ref_1].referrals[0]].binaryInvestment);
}
users[_userID].downlineBinaryCarryforward[0] = users[_userID].downlineBinaryCarryforward[0].add(_ref_1_binary.sub(users[_userID].downlineBinaryInvestment[0]));
users[_userID].downlineBinaryInvestment[0] = users[_userID].downlineBinaryInvestment[0].add(_ref_1_binary.sub(users[_userID].downlineBinaryInvestment[0]));
if(users[_ref_2].referrals.length == 0)
return;
else if(users[_ref_2].referrals.length == 2){
if(users[users[_ref_2].referrals[0]].blocked == 1)
_ref_2_binary = _ref_2_binary.add(userInvestments[users[_ref_2].referrals[0]].binaryInvestment);
if(users[users[_ref_2].referrals[1]].blocked == 1)
_ref_2_binary = _ref_2_binary.add(userInvestments[users[_ref_2].referrals[1]].binaryInvestment);
}
else{
if(users[users[_ref_2].referrals[0]].blocked == 1)
_ref_2_binary = _ref_2_binary.add(userInvestments[users[_ref_2].referrals[0]].binaryInvestment);
}
users[_userID].downlineBinaryCarryforward[1] = users[_userID].downlineBinaryCarryforward[1].add(_ref_2_binary.sub(users[_userID].downlineBinaryInvestment[1]));
users[_userID].downlineBinaryInvestment[1] = users[_userID].downlineBinaryInvestment[1].add(_ref_2_binary.sub(users[_userID].downlineBinaryInvestment[1]));
uint binary_payout;
if(users[_userID].downlineBinaryCarryforward[0] < users[_userID].downlineBinaryCarryforward[1])
binary_payout = users[_userID].downlineBinaryCarryforward[0];
else
binary_payout = users[_userID].downlineBinaryCarryforward[1];
uint binary_upline_payout;
if(binary_payout > 0)
binary_upline_payout = (binary_payout.mul(10 trx)).div(100 trx);
else
return;
if((dailyPayout[_userID]+binary_upline_payout > users[_userID].celling) && (_userID != 1))
binary_upline_payout = users[_userID].celling - dailyPayout[_userID];
if(binary_upline_payout > 0){
require(address(uint160(usersList[_userID])).send((binary_upline_payout.mul(95 trx).div(100 trx))),"Binary 95% transfer failed ");
require(address(uint160(ownerWallet)).send((binary_upline_payout.mul(5 trx).div(100 trx))),"binary admin commission 5% transfer failed ");
userInvestments[_userID].binaryEarned = userInvestments[_userID].binaryEarned.add((binary_upline_payout.mul(95 trx).div(100 trx)));
users[_userID].totalEarned = users[_userID].totalEarned.add((binary_upline_payout.mul(95 trx).div(100 trx)));
dailyPayout[_userID] = dailyPayout[_userID].add((binary_upline_payout.mul(95 trx).div(100 trx)));
users[1].totalEarned = users[1].totalEarned.add((binary_upline_payout.mul(5 trx).div(100 trx)));
users[_userID].downlineBinaryCarryforward[0] = users[_userID].downlineBinaryCarryforward[0].sub(binary_payout);
users[_userID].downlineBinaryCarryforward[1] = users[_userID].downlineBinaryCarryforward[1].sub(binary_payout);
if((userInvestments[_userID].binaryEarned >= rewardValue) && (users[_userID].created >= now) && (users[_userID].rewardStatus == 0)){
uint _reward = rewardValue.mul(5 trx).div(100 trx);
require(address(uint160(usersList[_userID])).send(_reward.mul(95 trx).div(100 trx)),"reward transfer failed");
users[_userID].totalEarned = users[_userID].totalEarned.add(_reward.mul(95 trx).div(100 trx));
require(address(uint160(ownerWallet)).send((_reward.mul(5 trx).div(100 trx))),"reward admin commission 5% transfer failed ");
users[1].totalEarned = users[1].totalEarned.add((_reward.mul(5 trx).div(100 trx)));
users[_userID].rewardStatus = 1;
emit rewardEvent(usersList[_userID], _userID, rewardValue.mul(95 trx).div(100 trx), now);
}
emit binaryCommissionEvent(usersList[_userID], _userID, binary_upline_payout, users[_userID].downlineBinaryCarryforward[0], users[_userID].downlineBinaryCarryforward[1], now);
}
}
// TopUp binary payout
function topUpBinaryMapping(uint _userID) internal {
if(((block.timestamp.sub(dailyPayoutTime[_userID])).div(1 days)) >= 1){
dailyPayout[_userID] = 0;
dailyPayoutTime[_userID] = now;
}
if(users[_userID].referrals.length < REFERRER_1_LEVEL_LIMIT) return;
if(users[_userID].blocked == 2) return;
if((users[_userID].referralsTopup[0] == 0) || (users[_userID].referralsTopup[1] ==0))
return;
uint topUpBinaryPayout;
if(users[_userID].referralsTopup[0] < users[_userID].referralsTopup[1])
topUpBinaryPayout = users[_userID].referralsTopup[0];
else
topUpBinaryPayout = users[_userID].referralsTopup[1];
uint _payout = topUpBinaryPayout.mul(1e19).div(1e20); // 10% payout;
if((dailyPayout[_userID]+_payout > users[_userID].celling) && (_userID != 1))
_payout = users[_userID].celling - dailyPayout[_userID];
if(_payout > 0){
require(address(uint160(usersList[_userID])).send(_payout.mul(95 trx).div(100 trx)),"TopUp 95% binary payout failed");
require(address(uint160(ownerWallet)).send((_payout.mul(5 trx).div(100 trx))),"top up admin commission 5% transfer failed ");
userInvestments[_userID].topUpBinaryEarned = userInvestments[_userID].topUpBinaryEarned.add(_payout.mul(95 trx).div(100 trx));
users[_userID].totalEarned = users[_userID].totalEarned.add(_payout.mul(95 trx).div(100 trx));
users[1].totalEarned = users[1].totalEarned.add((_payout.mul(5 trx).div(100 trx)));
dailyPayout[_userID] = dailyPayout[_userID].add(_payout.mul(95 trx).div(100 trx));
users[_userID].referralsTopup[0] = users[_userID].referralsTopup[0].sub(topUpBinaryPayout);
users[_userID].referralsTopup[1] = users[_userID].referralsTopup[1].sub(topUpBinaryPayout);
emit topUpBinaryEvent(usersList[_userID], _userID, _payout, users[_userID].referralsTopup[0], users[_userID].referralsTopup[1], now);
}
}
function ROIDistribution(uint _userID, uint _amount) internal{ // ROI
if(_amount <= 0) return;
require(address(uint160(usersList[_userID])).send(_amount.mul(95e18).div(1e20)), "ROI 95% transfer failed");
require(address(uint160(ownerWallet)).send((_amount.mul(5e18).div(1e20))),"ROI admin commission 5% transfer failed ");
userInvestments[_userID].ROIEarned = userInvestments[_userID].ROIEarned.add(_amount.mul(95e18).div(1e20));
users[_userID].totalEarned = users[_userID].totalEarned.add(_amount.mul(95e18).div(1e20));
users[1].totalEarned = users[1].totalEarned.add((_amount.mul(5e18).div(1e20)));
emit ROIEvent(usersList[_userID], _userID, _amount.mul(95e18).div(1e20), now);
}
}
| 297,398 | 1,068 |
04b48a719f45f35eed2d4f1f6768e754cc4a96864765bacf75d3fdbbc274a4e7
| 19,714 |
.sol
|
Solidity
| false |
593908510
|
SKKU-SecLab/SmartMark
|
fdf0675d2f959715d6f822351544c6bc91a5bdd4
|
dataset/Solidity_codes_9324/0x872f634ce643a9b5a4d9bcfa0714382267839fcc.sol
| 5,167 | 19,443 |
pragma solidity 0.4.24;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
constructor() public {
setOwner(msg.sender);
}
function setOwner(address newOwner) internal {
owner = newOwner;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
setOwner(newOwner);
}
}
contract ERC820Registry {
function getManager(address addr) public view returns(address);
function setManager(address addr, address newManager) public;
function getInterfaceImplementer(address addr, bytes32 iHash) public constant returns (address);
function setInterfaceImplementer(address addr, bytes32 iHash, address implementer) public;
}
contract ERC820Implementer {
ERC820Registry erc820Registry = ERC820Registry(0x991a1bcb077599290d7305493c9A630c20f8b798);
function setInterfaceImplementation(string ifaceLabel, address impl) internal {
bytes32 ifaceHash = keccak256(ifaceLabel);
erc820Registry.setInterfaceImplementer(this, ifaceHash, impl);
}
function interfaceAddr(address addr, string ifaceLabel) internal constant returns(address) {
bytes32 ifaceHash = keccak256(ifaceLabel);
return erc820Registry.getInterfaceImplementer(addr, ifaceHash);
}
function delegateManagement(address newManager) internal {
erc820Registry.setManager(this, newManager);
}
}
interface ERC777TokensSender {
function tokensToSend(address operator, address from, address to, uint amount, bytes userData,bytes operatorData) external;
}
interface ERC777TokensRecipient {
function tokensReceived(address operator, address from, address to, uint amount, bytes userData, bytes operatorData) external;
}
contract JaroCoinToken is Ownable, ERC820Implementer {
using SafeMath for uint256;
string public constant name = "JaroCoin";
string public constant symbol = "JARO";
uint8 public constant decimals = 18;
uint256 public constant granularity = 1e10; // Token has 8 digits after comma
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => bool)) public isOperatorFor;
mapping (address => mapping (uint256 => bool)) private usedNonces;
event Transfer(address indexed from, address indexed to, uint256 value);
event Sent(address indexed operator, address indexed from, address indexed to, uint256 amount, bytes userData, bytes operatorData);
event Minted(address indexed operator, address indexed to, uint256 amount, bytes operatorData);
event Burned(address indexed operator, address indexed from, uint256 amount, bytes userData, bytes operatorData);
event AuthorizedOperator(address indexed operator, address indexed tokenHolder);
event RevokedOperator(address indexed operator, address indexed tokenHolder);
event Approval(address indexed owner, address indexed spender, uint256 value);
uint256 public totalSupply = 0;
uint256 public constant maxSupply = 21000000e18;
function send(address _to, uint256 _amount, bytes _userData) public {
doSend(msg.sender, _to, _amount, _userData, msg.sender, "", true);
}
function sendByCheque(address _to, uint256 _amount, bytes _userData, uint256 _nonce, uint8 v, bytes32 r, bytes32 s) public {
require(_to != address(this));
bytes memory prefix = "\x19Ethereum Signed Message:\n32";
bytes32 hash = keccak256(prefix, keccak256(_to, _amount, _userData, _nonce));
address signer = ecrecover(hash, v, r, s);
require (signer != 0);
require (!usedNonces[signer][_nonce]);
usedNonces[signer][_nonce] = true;
doSend(signer, _to, _amount, _userData, signer, "", true);
}
function authorizeOperator(address _operator) public {
require(_operator != msg.sender);
isOperatorFor[_operator][msg.sender] = true;
emit AuthorizedOperator(_operator, msg.sender);
}
function revokeOperator(address _operator) public {
require(_operator != msg.sender);
isOperatorFor[_operator][msg.sender] = false;
emit RevokedOperator(_operator, msg.sender);
}
function operatorSend(address _from, address _to, uint256 _amount, bytes _userData, bytes _operatorData) public {
require(isOperatorFor[msg.sender][_from]);
doSend(_from, _to, _amount, _userData, msg.sender, _operatorData, true);
}
function requireMultiple(uint256 _amount) internal pure {
require(_amount.div(granularity).mul(granularity) == _amount);
}
function isRegularAddress(address _addr) internal constant returns(bool) {
if (_addr == 0) { return false; }
uint size;
assembly { size := extcodesize(_addr) } // solhint-disable-line no-inline-assembly
return size == 0;
}
function callSender(address _operator,
address _from,
address _to,
uint256 _amount,
bytes _userData,
bytes _operatorData) private {
address senderImplementation = interfaceAddr(_from, "ERC777TokensSender");
if (senderImplementation != 0) {
ERC777TokensSender(senderImplementation).tokensToSend(_operator, _from, _to, _amount, _userData, _operatorData);
}
}
function callRecipient(address _operator,
address _from,
address _to,
uint256 _amount,
bytes _userData,
bytes _operatorData,
bool _preventLocking) private {
address recipientImplementation = interfaceAddr(_to, "ERC777TokensRecipient");
if (recipientImplementation != 0) {
ERC777TokensRecipient(recipientImplementation).tokensReceived(_operator, _from, _to, _amount, _userData, _operatorData);
} else if (_preventLocking) {
require(isRegularAddress(_to));
}
}
function doSend(address _from,
address _to,
uint256 _amount,
bytes _userData,
address _operator,
bytes _operatorData,
bool _preventLocking)
private
{
requireMultiple(_amount);
callSender(_operator, _from, _to, _amount, _userData, _operatorData);
require(_to != 0x0); // forbid sending to 0x0 (=burning)
require(balanceOf[_from] >= _amount); // ensure enough funds
balanceOf[_from] = balanceOf[_from].sub(_amount);
balanceOf[_to] = balanceOf[_to].add(_amount);
callRecipient(_operator, _from, _to, _amount, _userData, _operatorData, _preventLocking);
emit Sent(_operator, _from, _to, _amount, _userData, _operatorData);
emit Transfer(_from, _to, _amount);
}
function transfer(address _to, uint256 _value) public returns (bool) {
doSend(msg.sender, _to, _value, "", msg.sender, "", false);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(isOperatorFor[msg.sender][_from]);
doSend(_from, _to, _value, "", msg.sender, "", true);
emit Transfer(_from, _to, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
if (isOperatorFor[_spender][_owner]) {
return balanceOf[_owner];
} else {
return 0;
}
}
function approve(address _spender, uint256 _value) public returns (bool) {
require(_spender != msg.sender);
if (_value > 0) {
isOperatorFor[_spender][msg.sender] = true;
emit AuthorizedOperator(_spender, msg.sender);
} else {
isOperatorFor[_spender][msg.sender] = false;
emit RevokedOperator(_spender, msg.sender);
}
emit Approval(msg.sender, _spender, _value);
return true;
}
function mint(address _to, uint256 _amount, bytes _operatorData) public onlyOwner {
require (totalSupply.add(_amount) <= maxSupply);
requireMultiple(_amount);
totalSupply = totalSupply.add(_amount);
balanceOf[_to] = balanceOf[_to].add(_amount);
callRecipient(msg.sender, 0x0, _to, _amount, "", _operatorData, true);
emit Minted(msg.sender, _to, _amount, _operatorData);
emit Transfer(0x0, _to, _amount);
}
function burn(uint256 _amount, bytes _userData) public {
require (_amount > 0);
require (balanceOf[msg.sender] >= _amount);
requireMultiple(_amount);
callSender(msg.sender, msg.sender, 0x0, _amount, _userData, "");
totalSupply = totalSupply.sub(_amount);
balanceOf[msg.sender] = balanceOf[msg.sender].sub(_amount);
emit Burned(msg.sender, msg.sender, _amount, _userData, "");
emit Transfer(msg.sender, 0x0, _amount);
}
}
contract JaroSleep is ERC820Implementer, ERC777TokensRecipient {
using SafeMath for uint256;
uint256 public lastBurn; // Time of last sleep token burn
uint256 public dailyTime; // Tokens to burn per day
JaroCoinToken public token;
event ReceivedTokens(address operator, address from, address to, uint amount, bytes userData, bytes operatorData);
constructor(address _token, uint256 _dailyTime) public {
setInterfaceImplementation("ERC777TokensRecipient", this);
token = JaroCoinToken(_token);
lastBurn = getNow();
dailyTime = _dailyTime;
}
function () external payable {
revert();
}
function burnTokens() public returns (uint256) {
uint256 sec = getNow().sub(lastBurn);
uint256 tokensToBurn = 0;
if (sec >= 1 days) {
uint256 d = sec.div(86400);
tokensToBurn = d.mul(dailyTime);
token.burn(tokensToBurn, "");
lastBurn = lastBurn.add(d.mul(86400));
}
return tokensToBurn;
}
function getNow() internal view returns (uint256) {
return now;
}
function tokensReceived(address operator, address from, address to, uint amount, bytes userData, bytes operatorData) external {
emit ReceivedTokens(operator, from, to, amount, userData, operatorData);
}
}
contract PersonalTime is Ownable, ERC820Implementer, ERC777TokensRecipient {
using SafeMath for uint256;
uint256 public lastBurn; // Time of last sleep token burn
uint256 public dailyTime; // Tokens to burn per day
uint256 public debt = 0; // Debt which will be not minted during next sale period
uint256 public protect = 0; // Tokens which were transfered in favor of future days
JaroCoinToken public token;
event ReceivedTokens(address operator, address from, address to, uint amount, bytes userData, bytes operatorData);
constructor(address _token, uint256 _dailyTime) public {
setInterfaceImplementation("ERC777TokensRecipient", this);
token = JaroCoinToken(_token);
lastBurn = getNow();
dailyTime = _dailyTime;
}
function () external payable {
revert();
}
function burnTokens() public returns (uint256) {
uint256 sec = getNow().sub(lastBurn);
uint256 tokensToBurn = 0;
if (sec >= 1 days) {
uint256 d = sec.div(86400);
tokensToBurn = d.mul(dailyTime);
if (protect >= tokensToBurn) {
protect = protect.sub(tokensToBurn);
} else {
token.burn(tokensToBurn.sub(protect), "");
protect = 0;
}
lastBurn = lastBurn.add(d.mul(86400));
}
return tokensToBurn;
}
function transfer(address _to, uint256 _amount) public onlyOwner {
protect = protect.add(_amount);
debt = debt.add(_amount);
token.transfer(_to, _amount);
}
function getNow() internal view returns (uint256) {
return now;
}
function tokensReceived(address operator, address from, address to, uint amount, bytes userData, bytes operatorData) external {
require(msg.sender == address(token));
debt = (debt >= amount ? debt.sub(amount) : 0);
emit ReceivedTokens(operator, from, to, amount, userData, operatorData);
}
}
contract JaroCoinCrowdsale is Ownable {
using SafeMath for uint256;
address public constant WALLET = 0xefF42c79c0aBea9958432DC82FebC4d65f3d24A3;
uint8 public constant EXCHANGE_RATE_DECIMALS = 8;
uint256 public constant MAX_AMOUNT = 21000000e18; // 21 000 000
uint256 public satoshiRaised; // Amount of raised funds in satoshi
uint256 public rate; // number of tokens buyer gets per satoshi
uint256 public conversionRate; // 17e10 wei per satoshi => 0.056 ETH/BTC
JaroCoinToken public token;
JaroSleep public sleepContract;
PersonalTime public familyContract;
PersonalTime public personalContract;
uint256 public tokensToMint; // Amount of tokens left to mint in this sale
uint256 public saleStartTime; // Start time of recent token sale
bool public isActive = false;
bool internal initialized = false;
address public exchangeRateOracle;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
event SaleActivated(uint256 startTime, uint256 amount);
event SaleClosed();
modifier canMint() {
require (isActive);
require (getNow() > saleStartTime);
_;
}
function initialize(address _owner, address _token, address _familyOwner, address _personalOwner) public {
require (!initialized);
token = JaroCoinToken(_token);
sleepContract = createJaroSleep(_token, 34560e18); // 9.6 hours per day
familyContract = createPersonalTime(_token, 21600e18); // 6 hours per day
personalContract = createPersonalTime(_token, 12960e18); // 3.6 hours per day
familyContract.transferOwnership(_familyOwner);
personalContract.transferOwnership(_personalOwner);
rate = 100000e10;
conversionRate = 17e10;
satoshiRaised = 0;
setOwner(_owner);
initialized = true;
}
function () external canMint payable {
_buyTokens(msg.sender, msg.value, 0);
}
function coupon(uint256 _timeStamp, uint16 _bonus, uint8 v, bytes32 r, bytes32 s) external canMint payable {
require(_timeStamp >= getNow());
bytes memory prefix = "\x19Ethereum Signed Message:\n32";
bytes32 hash = keccak256(prefix, keccak256(_timeStamp, _bonus));
address signer = ecrecover(hash, v, r, s);
require(signer == owner);
_buyTokens(msg.sender, msg.value, _bonus);
}
function buyTokens(address _beneficiary) public canMint payable {
_buyTokens(_beneficiary, msg.value, 0);
}
function _buyTokens(address _beneficiary, uint256 _value, uint16 _bonus) internal {
require (_beneficiary != address(0));
require (_value > 0);
uint256 weiAmount = _value;
uint256 satoshiAmount = weiAmount.div(conversionRate);
uint256 tokens = satoshiAmount.mul(rate).mul(_bonus + 100).div(100);
uint256 excess = appendContribution(_beneficiary, tokens);
uint256 refund = (excess > 0 ? excess.mul(100).div(100+_bonus).mul(conversionRate).div(rate) : 0);
weiAmount = weiAmount.sub(refund);
satoshiRaised = satoshiRaised.add(satoshiAmount);
if (refund > 0) {
msg.sender.transfer(refund);
}
emit TokenPurchase(msg.sender, _beneficiary, weiAmount, tokens.sub(excess));
WALLET.transfer(weiAmount);
}
function appendContribution(address _beneficiary, uint256 _tokens) internal returns (uint256) {
if (_tokens >= tokensToMint) {
mint(_beneficiary, tokensToMint);
uint256 excededTokens = _tokens.sub(tokensToMint);
_closeSale(); // Last tokens minted, lets close token sale
return excededTokens;
}
tokensToMint = tokensToMint.sub(_tokens);
mint(_beneficiary, _tokens);
return 0;
}
function startSale(uint256 _startTime) public onlyOwner {
require (!isActive);
require (_startTime > getNow());
require (saleStartTime == 0 || _startTime.sub(saleStartTime) > 30 days); // Minimum one month between token sales
sleepContract.burnTokens();
uint256 sleepTokens = token.balanceOf(address(sleepContract));
familyContract.burnTokens();
uint256 familyTokens = token.balanceOf(familyContract).add(familyContract.debt());
personalContract.burnTokens();
uint256 personalTokens = token.balanceOf(personalContract).add(personalContract.debt());
uint256 missingSleep = MAX_AMOUNT.div(100).mul(40).sub(sleepTokens); // sleep and stuff takes 40% of Jaro time
uint256 missingFamily = MAX_AMOUNT.div(100).mul(25).sub(familyTokens); // 25% for family
uint256 missingPersonal = MAX_AMOUNT.div(100).mul(15).sub(personalTokens); // 15% is Jaro personal time
mint(address(sleepContract), missingSleep);
mint(address(familyContract), missingFamily);
mint(address(personalContract), missingPersonal);
tokensToMint = MAX_AMOUNT.sub(token.totalSupply());
saleStartTime = _startTime;
isActive = true;
emit SaleActivated(_startTime, tokensToMint);
}
function _closeSale() internal {
tokensToMint = 0;
isActive = false;
emit SaleClosed();
}
function closeSale() public onlyOwner {
_closeSale();
}
function setExchangeRateOracle(address _exchangeRateOracle) public onlyOwner {
require(_exchangeRateOracle != address(0));
exchangeRateOracle = _exchangeRateOracle;
}
function setExchangeRate(uint256 _exchangeRate) public {
require(msg.sender == exchangeRateOracle || msg.sender == owner);
require(_exchangeRate > 0);
uint256 one = 1e18;
conversionRate = one.div(_exchangeRate);
}
function mint(address _beneficiary, uint256 _amount) internal {
if (_amount > 0) {
token.mint(_beneficiary, _amount, "");
}
}
function createJaroSleep(address _token, uint256 _dailyTime) internal returns (JaroSleep) {
return new JaroSleep(_token, _dailyTime);
}
function createPersonalTime(address _token, uint256 _dailyTime) internal returns (PersonalTime) {
return new PersonalTime(_token, _dailyTime);
}
function getNow() internal view returns (uint256) {
return now;
}
}
| 275,872 | 1,069 |
258d6fd90560b32d139ae0b76fc32ac40e49dd0f9d88a6b9051540c43608a0a5
| 15,899 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x188890E08E71F65C5176Efd92Bd563749E20443a/contract.sol
| 4,140 | 15,404 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.2;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract ReflectCoin is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
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;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 100 * 10**6 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
string private _name = 'ReflectCoin';
string private _symbol = 'REFLECT';
uint8 private _decimals = 9;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function reflect(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotal = _rTotal.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee) = _getTValues(tAmount);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee);
}
function _getTValues(uint256 tAmount) private pure returns (uint256, uint256) {
uint256 tFee = tAmount.mul(3).div(100);
uint256 tTransferAmount = tAmount.sub(tFee);
return (tTransferAmount, tFee);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
}
| 248,634 | 1,070 |
1bcbe9d96f982cefd5dfa9aedfff23abeaec9c95262962ee9f583cd9c478b344
| 15,830 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xb75322b6687d36edbcdae9399dd26e9e45c161a8.sol
| 3,629 | 14,795 |
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Owned {
address public contractOwner;
address public pendingContractOwner;
function Owned() {
contractOwner = msg.sender;
}
modifier onlyContractOwner() {
if (contractOwner == msg.sender) {
_;
}
}
function destroy() onlyContractOwner {
suicide(msg.sender);
}
function changeContractOwnership(address _to) onlyContractOwner() returns(bool) {
if (_to == 0x0) {
return false;
}
pendingContractOwner = _to;
return true;
}
function claimContractOwnership() returns(bool) {
if (pendingContractOwner != msg.sender) {
return false;
}
contractOwner = pendingContractOwner;
delete pendingContractOwner;
return true;
}
}
contract ERC20Interface {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed from, address indexed spender, uint256 value);
string public symbol;
function totalSupply() constant returns (uint256 supply);
function balanceOf(address _owner) constant returns (uint256 balance);
function transfer(address _to, uint256 _value) returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) returns (bool success);
function approve(address _spender, uint256 _value) returns (bool success);
function allowance(address _owner, address _spender) constant returns (uint256 remaining);
}
contract Object is Owned {
uint constant OK = 1;
uint constant OWNED_ACCESS_DENIED_ONLY_CONTRACT_OWNER = 8;
function withdrawnTokens(address[] tokens, address _to) onlyContractOwner returns(uint) {
for(uint i=0;i<tokens.length;i++) {
address token = tokens[i];
uint balance = ERC20Interface(token).balanceOf(this);
if(balance != 0)
ERC20Interface(token).transfer(_to,balance);
}
return OK;
}
function checkOnlyContractOwner() internal constant returns(uint) {
if (contractOwner == msg.sender) {
return OK;
}
return OWNED_ACCESS_DENIED_ONLY_CONTRACT_OWNER;
}
}
contract GroupsAccessManagerEmitter {
event UserCreated(address user);
event UserDeleted(address user);
event GroupCreated(bytes32 groupName);
event GroupActivated(bytes32 groupName);
event GroupDeactivated(bytes32 groupName);
event UserToGroupAdded(address user, bytes32 groupName);
event UserFromGroupRemoved(address user, bytes32 groupName);
event Error(uint errorCode);
function _emitError(uint _errorCode) internal returns (uint) {
Error(_errorCode);
return _errorCode;
}
}
/// @title Group Access Manager
///
/// Base implementation
/// This contract serves as group manager
contract GroupsAccessManager is Object, GroupsAccessManagerEmitter {
uint constant USER_MANAGER_SCOPE = 111000;
uint constant USER_MANAGER_MEMBER_ALREADY_EXIST = USER_MANAGER_SCOPE + 1;
uint constant USER_MANAGER_GROUP_ALREADY_EXIST = USER_MANAGER_SCOPE + 2;
uint constant USER_MANAGER_OBJECT_ALREADY_SECURED = USER_MANAGER_SCOPE + 3;
uint constant USER_MANAGER_CONFIRMATION_HAS_COMPLETED = USER_MANAGER_SCOPE + 4;
uint constant USER_MANAGER_USER_HAS_CONFIRMED = USER_MANAGER_SCOPE + 5;
uint constant USER_MANAGER_NOT_ENOUGH_GAS = USER_MANAGER_SCOPE + 6;
uint constant USER_MANAGER_INVALID_INVOCATION = USER_MANAGER_SCOPE + 7;
uint constant USER_MANAGER_DONE = USER_MANAGER_SCOPE + 11;
uint constant USER_MANAGER_CANCELLED = USER_MANAGER_SCOPE + 12;
using SafeMath for uint;
struct Member {
address addr;
uint groupsCount;
mapping(bytes32 => uint) groupName2index;
mapping(uint => uint) index2globalIndex;
}
struct Group {
bytes32 name;
uint priority;
uint membersCount;
mapping(address => uint) memberAddress2index;
mapping(uint => uint) index2globalIndex;
}
uint public membersCount;
mapping(uint => address) public index2memberAddress;
mapping(address => uint) public memberAddress2index;
mapping(address => Member) address2member;
uint public groupsCount;
mapping(uint => bytes32) public index2groupName;
mapping(bytes32 => uint) public groupName2index;
mapping(bytes32 => Group) groupName2group;
mapping(bytes32 => bool) public groupsBlocked; // if groupName => true, then couldn't be used for confirmation
function() payable public {
revert();
}
/// @notice Register user
/// Can be called only by contract owner
///
/// @param _user user address
///
/// @return code
function registerUser(address _user) external onlyContractOwner returns (uint) {
require(_user != 0x0);
if (isRegisteredUser(_user)) {
return _emitError(USER_MANAGER_MEMBER_ALREADY_EXIST);
}
uint _membersCount = membersCount.add(1);
membersCount = _membersCount;
memberAddress2index[_user] = _membersCount;
index2memberAddress[_membersCount] = _user;
address2member[_user] = Member(_user, 0);
UserCreated(_user);
return OK;
}
/// @notice Discard user registration
/// Can be called only by contract owner
///
/// @param _user user address
///
/// @return code
function unregisterUser(address _user) external onlyContractOwner returns (uint) {
require(_user != 0x0);
uint _memberIndex = memberAddress2index[_user];
if (_memberIndex == 0 || address2member[_user].groupsCount != 0) {
return _emitError(USER_MANAGER_INVALID_INVOCATION);
}
uint _membersCount = membersCount;
delete memberAddress2index[_user];
if (_memberIndex != _membersCount) {
address _lastUser = index2memberAddress[_membersCount];
index2memberAddress[_memberIndex] = _lastUser;
memberAddress2index[_lastUser] = _memberIndex;
}
delete address2member[_user];
delete index2memberAddress[_membersCount];
delete memberAddress2index[_user];
membersCount = _membersCount.sub(1);
UserDeleted(_user);
return OK;
}
/// @notice Create group
/// Can be called only by contract owner
///
/// @param _groupName group name
/// @param _priority group priority
///
/// @return code
function createGroup(bytes32 _groupName, uint _priority) external onlyContractOwner returns (uint) {
require(_groupName != bytes32(0));
if (isGroupExists(_groupName)) {
return _emitError(USER_MANAGER_GROUP_ALREADY_EXIST);
}
uint _groupsCount = groupsCount.add(1);
groupName2index[_groupName] = _groupsCount;
index2groupName[_groupsCount] = _groupName;
groupName2group[_groupName] = Group(_groupName, _priority, 0);
groupsCount = _groupsCount;
GroupCreated(_groupName);
return OK;
}
/// @notice Change group status
/// Can be called only by contract owner
///
/// @param _groupName group name
/// @param _blocked block status
///
/// @return code
function changeGroupActiveStatus(bytes32 _groupName, bool _blocked) external onlyContractOwner returns (uint) {
require(isGroupExists(_groupName));
groupsBlocked[_groupName] = _blocked;
return OK;
}
/// @notice Add users in group
/// Can be called only by contract owner
///
/// @param _groupName group name
/// @param _users user array
///
/// @return code
function addUsersToGroup(bytes32 _groupName, address[] _users) external onlyContractOwner returns (uint) {
require(isGroupExists(_groupName));
Group storage _group = groupName2group[_groupName];
uint _groupMembersCount = _group.membersCount;
for (uint _userIdx = 0; _userIdx < _users.length; ++_userIdx) {
address _user = _users[_userIdx];
uint _memberIndex = memberAddress2index[_user];
require(_memberIndex != 0);
if (_group.memberAddress2index[_user] != 0) {
continue;
}
_groupMembersCount = _groupMembersCount.add(1);
_group.memberAddress2index[_user] = _groupMembersCount;
_group.index2globalIndex[_groupMembersCount] = _memberIndex;
_addGroupToMember(_user, _groupName);
UserToGroupAdded(_user, _groupName);
}
_group.membersCount = _groupMembersCount;
return OK;
}
/// @notice Remove users in group
/// Can be called only by contract owner
///
/// @param _groupName group name
/// @param _users user array
///
/// @return code
function removeUsersFromGroup(bytes32 _groupName, address[] _users) external onlyContractOwner returns (uint) {
require(isGroupExists(_groupName));
Group storage _group = groupName2group[_groupName];
uint _groupMembersCount = _group.membersCount;
for (uint _userIdx = 0; _userIdx < _users.length; ++_userIdx) {
address _user = _users[_userIdx];
uint _memberIndex = memberAddress2index[_user];
uint _groupMemberIndex = _group.memberAddress2index[_user];
if (_memberIndex == 0 || _groupMemberIndex == 0) {
continue;
}
if (_groupMemberIndex != _groupMembersCount) {
uint _lastUserGlobalIndex = _group.index2globalIndex[_groupMembersCount];
address _lastUser = index2memberAddress[_lastUserGlobalIndex];
_group.index2globalIndex[_groupMemberIndex] = _lastUserGlobalIndex;
_group.memberAddress2index[_lastUser] = _groupMemberIndex;
}
delete _group.memberAddress2index[_user];
delete _group.index2globalIndex[_groupMembersCount];
_groupMembersCount = _groupMembersCount.sub(1);
_removeGroupFromMember(_user, _groupName);
UserFromGroupRemoved(_user, _groupName);
}
_group.membersCount = _groupMembersCount;
return OK;
}
/// @notice Check is user registered
///
/// @param _user user address
///
/// @return status
function isRegisteredUser(address _user) public view returns (bool) {
return memberAddress2index[_user] != 0;
}
/// @notice Check is user in group
///
/// @param _groupName user array
/// @param _user user array
///
/// @return status
function isUserInGroup(bytes32 _groupName, address _user) public view returns (bool) {
return isRegisteredUser(_user) && address2member[_user].groupName2index[_groupName] != 0;
}
/// @notice Check is group exist
///
/// @param _groupName group name
///
/// @return status
function isGroupExists(bytes32 _groupName) public view returns (bool) {
return groupName2index[_groupName] != 0;
}
/// @notice Get current group names
///
/// @return group names
function getGroups() public view returns (bytes32[] _groups) {
uint _groupsCount = groupsCount;
_groups = new bytes32[](_groupsCount);
for (uint _groupIdx = 0; _groupIdx < _groupsCount; ++_groupIdx) {
_groups[_groupIdx] = index2groupName[_groupIdx + 1];
}
}
/// @notice Gets group members
function getGroupMembers(bytes32 _groupName)
public
view
returns (address[] _members)
{
if (!isGroupExists(_groupName)) {
return;
}
Group storage _group = groupName2group[_groupName];
uint _membersCount = _group.membersCount;
if (_membersCount == 0) {
return;
}
_members = new address[](_membersCount);
for (uint _userIdx = 0; _userIdx < _membersCount; ++_userIdx) {
uint _memberIdx = _group.index2globalIndex[_userIdx + 1];
_members[_userIdx] = index2memberAddress[_memberIdx];
}
}
/// @notice Gets a list of groups where passed user is a member
function getUserGroups(address _user)
public
view
returns (bytes32[] _groups)
{
if (!isRegisteredUser(_user)) {
return;
}
Member storage _member = address2member[_user];
uint _groupsCount = _member.groupsCount;
if (_groupsCount == 0) {
return;
}
_groups = new bytes32[](_groupsCount);
for (uint _groupIdx = 0; _groupIdx < _groupsCount; ++_groupIdx) {
uint _groupNameIdx = _member.index2globalIndex[_groupIdx + 1];
_groups[_groupIdx] = index2groupName[_groupNameIdx];
}
}
// PRIVATE
function _removeGroupFromMember(address _user, bytes32 _groupName) private {
Member storage _member = address2member[_user];
uint _memberGroupsCount = _member.groupsCount;
uint _memberGroupIndex = _member.groupName2index[_groupName];
if (_memberGroupIndex != _memberGroupsCount) {
uint _lastGroupGlobalIndex = _member.index2globalIndex[_memberGroupsCount];
bytes32 _lastGroupName = index2groupName[_lastGroupGlobalIndex];
_member.index2globalIndex[_memberGroupIndex] = _lastGroupGlobalIndex;
_member.groupName2index[_lastGroupName] = _memberGroupIndex;
}
delete _member.groupName2index[_groupName];
delete _member.index2globalIndex[_memberGroupsCount];
_member.groupsCount = _memberGroupsCount.sub(1);
}
function _addGroupToMember(address _user, bytes32 _groupName) private {
Member storage _member = address2member[_user];
uint _memberGroupsCount = _member.groupsCount.add(1);
_member.groupName2index[_groupName] = _memberGroupsCount;
_member.index2globalIndex[_memberGroupsCount] = groupName2index[_groupName];
_member.groupsCount = _memberGroupsCount;
}
}
| 197,734 | 1,071 |
03ad6fc57cd08cd9ec81c06305ed328ceb12000bc16fe6a2db42a71a8f565c12
| 17,527 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/cf/CF78E341Fa7D1d46d73E73E6714a831686058017_Distributor.sol
| 3,874 | 15,329 |
// SPDX-License-Identifier: MIT
pragma solidity 0.7.5;
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function sqrrt(uint256 a) internal pure returns (uint c) {
if (a > 3) {
c = a;
uint b = add(div(a, 2), 1);
while (b < c) {
c = b;
b = div(add(div(a, b), b), 2);
}
} else if (a != 0) {
c = 1;
}
}
function percentageAmount(uint256 total_, uint8 percentage_) internal pure returns (uint256 percentAmount_) {
return div(mul(total_, percentage_), 1000);
}
function substractPercentage(uint256 total_, uint8 percentageToSub_) internal pure returns (uint256 result_) {
return sub(total_, div(mul(total_, percentageToSub_), 1000));
}
function percentageOfTotal(uint256 part_, uint256 total_) internal pure returns (uint256 percent_) {
return div(mul(part_, 100) , total_);
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
function quadraticPricing(uint256 payment_, uint256 multiplier_) internal pure returns (uint256) {
return sqrrt(mul(multiplier_, payment_));
}
function bondingCurve(uint256 supply_, uint256 multiplier_) internal pure returns (uint256) {
return mul(multiplier_, supply_);
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
interface IPolicy {
function policy() external view returns (address);
function renouncePolicy() external;
function pushPolicy(address newPolicy_) external;
function pullPolicy() external;
}
contract Policy is IPolicy {
address internal _policy;
address internal _newPolicy;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
_policy = msg.sender;
emit OwnershipTransferred(address(0), _policy);
}
function policy() public view override returns (address) {
return _policy;
}
modifier onlyPolicy() {
require(_policy == msg.sender, "Ownable: caller is not the owner");
_;
}
function renouncePolicy() public virtual override onlyPolicy() {
emit OwnershipTransferred(_policy, address(0));
_policy = address(0);
}
function pushPolicy(address newPolicy_) public virtual override onlyPolicy() {
require(newPolicy_ != address(0), "Ownable: new owner is the zero address");
_newPolicy = newPolicy_;
}
function pullPolicy() public virtual override {
require(msg.sender == _newPolicy);
emit OwnershipTransferred(_policy, _newPolicy);
_policy = _newPolicy;
}
}
interface ITreasury {
function mintRewards(address _recipient, uint _amount) external;
}
contract Distributor is Policy {
using SafeMath for uint;
using SafeERC20 for IERC20;
address public immutable OHMD;
address public immutable treasury;
uint public immutable epochLength;
uint public nextEpochBlock;
mapping(uint => Adjust) public adjustments;
struct Info {
uint rate; // in ten-thousandths (5000 = 0.5%)
address recipient;
}
Info[] public info;
struct Adjust {
bool add;
uint rate;
uint target;
}
constructor(address _treasury, address _hec, uint _epochLength, uint _nextEpochBlock) {
require(_treasury != address(0));
treasury = _treasury;
require(_hec != address(0));
OHMD = _hec;
epochLength = _epochLength;
nextEpochBlock = _nextEpochBlock;
}
function distribute() external returns (bool) {
if (nextEpochBlock <= block.number) {
nextEpochBlock = nextEpochBlock.add(epochLength); // set next epoch block
// distribute rewards to each recipient
for (uint i = 0; i < info.length; i++) {
if (info[ i ].rate > 0) {
ITreasury(treasury).mintRewards(// mint and send from treasury
info[ i ].recipient,
nextRewardAt(info[ i ].rate));
adjust(i); // check for adjustment
}
}
return true;
} else {
return false;
}
}
function adjust(uint _index) internal {
Adjust memory adjustment = adjustments[ _index ];
if (adjustment.rate != 0) {
if (adjustment.add) { // if rate should increase
info[ _index ].rate = info[ _index ].rate.add(adjustment.rate); // raise rate
if (info[ _index ].rate >= adjustment.target) { // if target met
adjustments[ _index ].rate = 0; // turn off adjustment
}
} else { // if rate should decrease
info[ _index ].rate = info[ _index ].rate.sub(adjustment.rate); // lower rate
if (info[ _index ].rate <= adjustment.target) { // if target met
adjustments[ _index ].rate = 0; // turn off adjustment
}
}
}
}
function nextRewardAt(uint _rate) public view returns (uint) {
return IERC20(OHMD).totalSupply().mul(_rate).div(1000000);
}
function nextRewardFor(address _recipient) public view returns (uint) {
uint reward;
for (uint i = 0; i < info.length; i++) {
if (info[ i ].recipient == _recipient) {
reward = nextRewardAt(info[ i ].rate);
}
}
return reward;
}
function addRecipient(address _recipient, uint _rewardRate) external onlyPolicy() {
require(_recipient != address(0));
info.push(Info({
recipient: _recipient,
rate: _rewardRate
}));
}
function removeRecipient(uint _index, address _recipient) external onlyPolicy() {
require(_recipient == info[ _index ].recipient);
info[ _index ].recipient = address(0);
info[ _index ].rate = 0;
}
function setAdjustment(uint _index, bool _add, uint _rate, uint _target) external onlyPolicy() {
adjustments[ _index ] = Adjust({
add: _add,
rate: _rate,
target: _target
});
}
}
| 97,909 | 1,072 |
1fb36fcfd0f975c5de3ab5bf6e81eb6119a1d6b80a55e6a840677f9074a90001
| 14,163 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/cc/CC5f038C539eF660C3ffE671e32c67FD89C3D6dd_TESTPresale.sol
| 3,257 | 13,047 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.8.4;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) return 0;
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: modulo by zero");
return a % b;
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
return a - b;
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a / b;
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
modifier onlyOwner() {
_checkOwner();
_;
}
function owner() public view virtual returns (address) {
return _owner;
}
function _checkOwner() internal view virtual {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
function mint(address account, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface ITool{
function getState(address user,
bytes memory signature) external view returns (bool state_);
}
contract TESTPresale is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
using Address for address;
address public TEST;
address public Tool;
uint256 public constant salePrice = 0.000000000001 ether;
uint256 public constant saleTime = 2 hours; // 3 day
uint256 public constant MaxAmount = .2 ether; // ETH
uint256 public constant limitAmount = .05 ether; // ETH
uint256 public totalAmount;
uint256 public startTime;
uint256 public endTime;
uint256 public claimableTime;
mapping(address => bool) public isClearing;
mapping(address => uint256) userAmount;
event PurchaseTEST(address account, uint256 amount, uint256 totalAmount);
event HarvestTEST(address account, uint256 amountETH, uint256 purchaseAmount);
event MigrateTEST(address account, uint256 totalAmount);
constructor(address _TEST,address _tool){
require(_TEST != address(0),"invalid address!");
TEST = _TEST;
Tool = _tool;
}
function launch() public onlyOwner(){
require(startTime == 0, "already started!");
startTime = block.timestamp;
endTime = startTime.add(saleTime);
claimableTime = endTime.add(5 hours); // 48 hours
}
// buy TEST
function purchase(bytes memory signature) external payable callerIsUser returns(bool) {
require(block.timestamp>=startTime && block.timestamp<=endTime , "not sale time!");
require(totalAmount.add(msg.value) <= MaxAmount,"exceeds max amount");
require(userAmount[msg.sender].add(msg.value) <= limitAmount,"exceeds max amount you can buy");
require(msg.value > 0,"invalid value!");
if(userAmount[msg.sender] == 0){
require(msg.value >= 0.0011 ether,"too small");
}
bool state = ITool(Tool).getState(msg.sender, signature);
require(state,"Invalid State!");
userAmount[msg.sender] = userAmount[msg.sender].add(msg.value);
totalAmount = totalAmount.add(msg.value);
emit PurchaseTEST(msg.sender, msg.value, totalAmount);
return true;
}
function claim() public returns(uint256) {
require(claimableTime >0 , "not started!");
require(block.timestamp > claimableTime, "not end!");
require(userAmount[msg.sender] > 0 ,"invalid user!");
require(isClearing[msg.sender] == false, "already claimed!");
uint256 amount = userAmount[msg.sender];
// caculate TEST amount
uint256 TESTForUser = _calculateSaleQuote(amount);
IERC20(TEST).safeTransfer(msg.sender,TESTForUser);
isClearing[msg.sender] = true;
emit HarvestTEST(msg.sender, amount, TESTForUser);
return TESTForUser;
}
function finish() public returns (bool){
require(endTime > 0,"not started!");
require(endTime < block.timestamp, "not ended!");
uint256 balance = address(this).balance;
if(balance > 0){
payable (owner()).transfer(balance);
}
return true;
}
function setTESTAddress(address _TEST) external onlyOwner() returns (bool) {
TEST = _TEST;
return true;
}
function userPurchaseInfo(address _user)
external
view
returns (uint256, bool)
{
return (userAmount[_user], isClearing[_user]);
}
function _calculateSaleQuote(uint256 paymentAmount_) internal pure returns (uint256){
return paymentAmount_.mul(1e18).div(salePrice);
}
// quote price
function calculateSaleQuote(uint256 paymentAmount_)
external
pure
returns (uint256)
{
return _calculateSaleQuote(paymentAmount_);
}
// not other contract
modifier callerIsUser() {
require(tx.origin == msg.sender, "not user!");
_;
}
}
| 127,775 | 1,073 |
7904b8fff8bd786f8f56e8d519ed90bffa7b7277190cc8a209308c8d58762d34
| 24,400 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TE/TENHubFZ4TRSYKk5ndZptCyocH2iHgqfg4_ZuTron.sol
| 5,671 | 21,701 |
//SourceUnit: ZuTron.sol
pragma solidity >=0.4.23 <0.6.0;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
}
contract ZuTron {
using SafeMath for *;
struct User {
uint id;
address referrer;
uint partnersCount;
uint256 x3Income;
uint256 x6Income;
mapping(uint8 => bool) activeX3Levels;
mapping(uint8 => bool) activeX6Levels;
mapping(uint8 => X3) x3Matrix;
mapping(uint8 => X6) x6Matrix;
}
struct X3 {
address currentReferrer;
address[] referrals;
bool blocked;
uint reinvestCount;
}
struct X6 {
address currentReferrer;
address[] firstLevelReferrals;
address[] secondLevelReferrals;
bool blocked;
uint reinvestCount;
address closedPart;
}
uint8 public constant LAST_LEVEL = 12;
mapping(address => User) public users;
mapping(uint => address) public idToAddress;
mapping(uint => address) public userIds;
mapping(address => uint) public balances;
uint public lastUserId = 2;
address public owner;
mapping(uint8 => uint) public levelPrice;
event Registration(address indexed user, address indexed referrer, uint indexed userId, uint referrerId);
event Reinvest(address indexed user, address indexed currentReferrer, address indexed caller, uint8 matrix, uint8 level);
event Upgrade(address indexed user, address indexed referrer, uint8 matrix, uint8 level);
event NewUserPlace(address indexed user,uint indexed userId, address indexed referrer,uint referrerId, uint8 matrix, uint8 level, uint8 place);
event MissedTronReceive(address indexed receiver,uint receiverId, address indexed from,uint indexed fromId, uint8 matrix, uint8 level);
event SentDividends(address indexed from,uint indexed fromId, address indexed receiver,uint receiverId, uint8 matrix, uint8 level, bool isExtra);
constructor(address ownerAddress) public {
levelPrice[1] = 200 trx;
for (uint8 i = 2; i <= LAST_LEVEL; i++) {
levelPrice[i] = levelPrice[i-1] * 2;
}
owner = ownerAddress;
User memory user = User({
id: 1,
referrer: address(0),
partnersCount: uint(0),
x3Income:0,
x6Income:0
});
users[ownerAddress] = user;
idToAddress[1] = ownerAddress;
for (uint8 i = 1; i <= LAST_LEVEL; i++) {
users[ownerAddress].activeX3Levels[i] = true;
users[ownerAddress].activeX6Levels[i] = true;
}
userIds[1] = ownerAddress;
}
function() external payable {
return registration(msg.sender, owner);
}
function registrationExt(address referrerAddress) external payable {
registration(msg.sender, referrerAddress);
}
function buyNewLevel(uint8 matrix, uint8 level) external payable {
require(isUserExists(msg.sender), "user is not exists. Register first.");
require(matrix == 1 || matrix == 2, "invalid matrix");
require(msg.value == levelPrice[level], "invalid price");
require(level > 1 && level <= LAST_LEVEL, "invalid level");
if (matrix == 1) {
require(!users[msg.sender].activeX3Levels[level], "level already activated");
require(users[msg.sender].activeX3Levels[level - 1], "previous level should be activated");
if (users[msg.sender].x3Matrix[level-1].blocked) {
users[msg.sender].x3Matrix[level-1].blocked = false;
}
address freeX3Referrer = findFreeX3Referrer(msg.sender, level);
users[msg.sender].x3Matrix[level].currentReferrer = freeX3Referrer;
users[msg.sender].activeX3Levels[level] = true;
updateX3Referrer(msg.sender, freeX3Referrer, level);
emit Upgrade(msg.sender, freeX3Referrer, 1, level);
} else {
require(!users[msg.sender].activeX6Levels[level], "level already activated");
require(users[msg.sender].activeX6Levels[level - 1], "previous level should be activated");
if (users[msg.sender].x6Matrix[level-1].blocked) {
users[msg.sender].x6Matrix[level-1].blocked = false;
}
address freeX6Referrer = findFreeX6Referrer(msg.sender, level);
users[msg.sender].activeX6Levels[level] = true;
updateX6Referrer(msg.sender, freeX6Referrer, level);
emit Upgrade(msg.sender, freeX6Referrer, 2, level);
}
}
function registration(address userAddress, address referrerAddress) private {
require(msg.value == 400 trx, "registration cost 400");
require(!isUserExists(userAddress), "user exists");
require(isUserExists(referrerAddress), "referrer not exists");
uint32 size;
assembly {
size := extcodesize(userAddress)
}
require(size == 0, "cannot be a contract");
User memory user = User({
id: lastUserId,
referrer: referrerAddress,
partnersCount: 0,
x3Income:0,
x6Income:0
});
users[userAddress] = user;
idToAddress[lastUserId] = userAddress;
users[userAddress].referrer = referrerAddress;
users[userAddress].activeX3Levels[1] = true;
users[userAddress].activeX6Levels[1] = true;
userIds[lastUserId] = userAddress;
lastUserId++;
users[referrerAddress].partnersCount++;
address freeX3Referrer = findFreeX3Referrer(userAddress, 1);
users[userAddress].x3Matrix[1].currentReferrer = freeX3Referrer;
updateX3Referrer(userAddress, freeX3Referrer, 1);
updateX6Referrer(userAddress, findFreeX6Referrer(userAddress, 1), 1);
emit Registration(userAddress, referrerAddress, users[userAddress].id, users[referrerAddress].id);
}
function updateX3Referrer(address userAddress, address referrerAddress, uint8 level) private {
users[referrerAddress].x3Matrix[level].referrals.push(userAddress);
if (users[referrerAddress].x3Matrix[level].referrals.length < 3) {
emit NewUserPlace(userAddress,users[userAddress].id, referrerAddress, users[referrerAddress].id, 1, level, uint8(users[referrerAddress].x3Matrix[level].referrals.length));
return sendTronDividends(referrerAddress, userAddress, 1, level);
}
emit NewUserPlace(userAddress,users[userAddress].id, referrerAddress,users[referrerAddress].id, 1, level, 3);
//close matrix
users[referrerAddress].x3Matrix[level].referrals = new address[](0);
if (!users[referrerAddress].activeX3Levels[level+1] && level != LAST_LEVEL) {
users[referrerAddress].x3Matrix[level].blocked = true;
}
//create new one by recursion
if (referrerAddress != owner) {
//check referrer active level
address freeReferrerAddress = findFreeX3Referrer(referrerAddress, level);
if (users[referrerAddress].x3Matrix[level].currentReferrer != freeReferrerAddress) {
users[referrerAddress].x3Matrix[level].currentReferrer = freeReferrerAddress;
}
users[referrerAddress].x3Matrix[level].reinvestCount++;
emit Reinvest(referrerAddress, freeReferrerAddress, userAddress, 1, level);
updateX3Referrer(referrerAddress, freeReferrerAddress, level);
} else {
sendTronDividends(owner, userAddress, 1, level);
users[owner].x3Matrix[level].reinvestCount++;
emit Reinvest(owner, address(0), userAddress, 1, level);
}
}
function updateX6Referrer(address userAddress, address referrerAddress, uint8 level) private {
require(users[referrerAddress].activeX6Levels[level], "500. Referrer level is inactive");
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length < 2) {
users[referrerAddress].x6Matrix[level].firstLevelReferrals.push(userAddress);
emit NewUserPlace(userAddress,users[userAddress].id, referrerAddress,users[referrerAddress].id, 2, level, uint8(users[referrerAddress].x6Matrix[level].firstLevelReferrals.length));
//set current level
users[userAddress].x6Matrix[level].currentReferrer = referrerAddress;
if (referrerAddress == owner) {
return sendTronDividends(referrerAddress, userAddress, 2, level);
}
address ref = users[referrerAddress].x6Matrix[level].currentReferrer;
users[ref].x6Matrix[level].secondLevelReferrals.push(userAddress);
uint len = users[ref].x6Matrix[level].firstLevelReferrals.length;
if ((len == 2) &&
(users[ref].x6Matrix[level].firstLevelReferrals[0] == referrerAddress) &&
(users[ref].x6Matrix[level].firstLevelReferrals[1] == referrerAddress)) {
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length == 1) {
emit NewUserPlace(userAddress,users[userAddress].id, ref,users[ref].id, 2, level, 5);
} else {
emit NewUserPlace(userAddress,users[userAddress].id,ref,users[ref].id, 2, level, 6);
}
} else if ((len == 1 || len == 2) &&
users[ref].x6Matrix[level].firstLevelReferrals[0] == referrerAddress) {
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length == 1) {
emit NewUserPlace(userAddress,users[userAddress].id, ref,users[ref].id, 2, level, 3);
} else {
emit NewUserPlace(userAddress,users[userAddress].id, ref,users[ref].id, 2, level, 4);
}
} else if (len == 2 && users[ref].x6Matrix[level].firstLevelReferrals[1] == referrerAddress) {
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length == 1) {
emit NewUserPlace(userAddress,users[userAddress].id, ref,users[ref].id, 2, level, 5);
} else {
emit NewUserPlace(userAddress,users[userAddress].id, ref,users[ref].id, 2, level, 6);
}
}
return updateX6ReferrerSecondLevel(userAddress, ref, level);
}
users[referrerAddress].x6Matrix[level].secondLevelReferrals.push(userAddress);
if (users[referrerAddress].x6Matrix[level].closedPart != address(0)) {
if ((users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] ==
users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]) &&
(users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] ==
users[referrerAddress].x6Matrix[level].closedPart)) {
updateX6(userAddress, referrerAddress, level, true);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
} else if (users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] ==
users[referrerAddress].x6Matrix[level].closedPart) {
updateX6(userAddress, referrerAddress, level, true);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
} else {
updateX6(userAddress, referrerAddress, level, false);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
}
}
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals[1] == userAddress) {
updateX6(userAddress, referrerAddress, level, false);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
} else if (users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] == userAddress) {
updateX6(userAddress, referrerAddress, level, true);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
}
if (users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.length <=
users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.length) {
updateX6(userAddress, referrerAddress, level, false);
} else {
updateX6(userAddress, referrerAddress, level, true);
}
updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
}
function updateX6(address userAddress, address referrerAddress, uint8 level, bool x2) private {
if (!x2) {
users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.push(userAddress);
emit NewUserPlace(userAddress,users[userAddress].id, users[referrerAddress].x6Matrix[level].firstLevelReferrals[0],users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].id, 2, level, uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.length));
emit NewUserPlace(userAddress,users[userAddress].id, referrerAddress,users[referrerAddress].id, 2, level, 2 + uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.length));
//set current level
users[userAddress].x6Matrix[level].currentReferrer = users[referrerAddress].x6Matrix[level].firstLevelReferrals[0];
} else {
users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.push(userAddress);
emit NewUserPlace(userAddress,users[userAddress].id, users[referrerAddress].x6Matrix[level].firstLevelReferrals[1],users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].id, 2, level, uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.length));
emit NewUserPlace(userAddress,users[userAddress].id, referrerAddress,users[referrerAddress].id, 2, level, 4 + uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.length));
//set current level
users[userAddress].x6Matrix[level].currentReferrer = users[referrerAddress].x6Matrix[level].firstLevelReferrals[1];
}
}
function updateX6ReferrerSecondLevel(address userAddress, address referrerAddress, uint8 level) private {
if (users[referrerAddress].x6Matrix[level].secondLevelReferrals.length < 4) {
return sendTronDividends(referrerAddress, userAddress, 2, level);
}
address[] memory x6 = users[users[referrerAddress].x6Matrix[level].currentReferrer].x6Matrix[level].firstLevelReferrals;
if (x6.length == 2) {
if (x6[0] == referrerAddress ||
x6[1] == referrerAddress) {
users[users[referrerAddress].x6Matrix[level].currentReferrer].x6Matrix[level].closedPart = referrerAddress;
} else if (x6.length == 1) {
if (x6[0] == referrerAddress) {
users[users[referrerAddress].x6Matrix[level].currentReferrer].x6Matrix[level].closedPart = referrerAddress;
}
}
}
users[referrerAddress].x6Matrix[level].firstLevelReferrals = new address[](0);
users[referrerAddress].x6Matrix[level].secondLevelReferrals = new address[](0);
users[referrerAddress].x6Matrix[level].closedPart = address(0);
if (!users[referrerAddress].activeX6Levels[level+1] && level != LAST_LEVEL) {
users[referrerAddress].x6Matrix[level].blocked = true;
}
users[referrerAddress].x6Matrix[level].reinvestCount++;
if (referrerAddress != owner) {
address freeReferrerAddress = findFreeX6Referrer(referrerAddress, level);
emit Reinvest(referrerAddress, freeReferrerAddress, userAddress, 2, level);
updateX6Referrer(referrerAddress, freeReferrerAddress, level);
} else {
emit Reinvest(owner, address(0), userAddress, 2, level);
sendTronDividends(owner, userAddress, 2, level);
}
}
function findFreeX3Referrer(address userAddress, uint8 level) public view returns(address) {
while (true) {
if (users[users[userAddress].referrer].activeX3Levels[level]) {
return users[userAddress].referrer;
}
userAddress = users[userAddress].referrer;
}
}
function findFreeX6Referrer(address userAddress, uint8 level) public view returns(address) {
while (true) {
if (users[users[userAddress].referrer].activeX6Levels[level]) {
return users[userAddress].referrer;
}
userAddress = users[userAddress].referrer;
}
}
function usersActiveX3Levels(address userAddress, uint8 level) public view returns(bool) {
return users[userAddress].activeX3Levels[level];
}
function usersActiveX6Levels(address userAddress, uint8 level) public view returns(bool) {
return users[userAddress].activeX6Levels[level];
}
function get3XMatrix(address userAddress, uint8 level) public view returns(address, address[] memory, uint, bool) {
return (users[userAddress].x3Matrix[level].currentReferrer,
users[userAddress].x3Matrix[level].referrals,
users[userAddress].x3Matrix[level].reinvestCount,
users[userAddress].x3Matrix[level].blocked);
}
function getX6Matrix(address userAddress, uint8 level) public view returns(address, address[] memory, address[] memory, bool, uint, address) {
return (users[userAddress].x6Matrix[level].currentReferrer,
users[userAddress].x6Matrix[level].firstLevelReferrals,
users[userAddress].x6Matrix[level].secondLevelReferrals,
users[userAddress].x6Matrix[level].blocked,
users[userAddress].x6Matrix[level].reinvestCount,
users[userAddress].x6Matrix[level].closedPart);
}
function isUserExists(address user) public view returns (bool) {
return (users[user].id != 0);
}
function findTronReceiver(address userAddress, address _from, uint8 matrix, uint8 level) private returns(address, bool) {
address receiver = userAddress;
bool isExtraDividends;
if (matrix == 1) {
while (true) {
if (users[receiver].x3Matrix[level].blocked) {
emit MissedTronReceive(receiver,users[receiver].id, _from,users[_from].id, 1, level);
isExtraDividends = true;
receiver = users[receiver].x3Matrix[level].currentReferrer;
} else {
return (receiver, isExtraDividends);
}
}
} else {
while (true) {
if (users[receiver].x6Matrix[level].blocked) {
emit MissedTronReceive(receiver,users[receiver].id, _from,users[_from].id, 2, level);
isExtraDividends = true;
receiver = users[receiver].x6Matrix[level].currentReferrer;
} else {
return (receiver, isExtraDividends);
}
}
}
}
function sendTronDividends(address userAddress, address _from, uint8 matrix, uint8 level) private {
(address receiver, bool isExtraDividends) = findTronReceiver(userAddress, _from, matrix, level);
if (!address(uint160(receiver)).send(levelPrice[level])) {
return address(uint160(receiver)).transfer(address(this).balance);
}
if(matrix == 1)
{
users[receiver].x3Income = users[receiver].x3Income.add(levelPrice[level]);
}
else
{
users[receiver].x6Income = users[receiver].x6Income.add(levelPrice[level]);
}
emit SentDividends(_from,users[_from].id, receiver,users[receiver].id, matrix, level, isExtraDividends);
}
function bytesToAddress(bytes memory bys) private pure returns (address addr) {
assembly {
addr := mload(add(bys, 20))
}
}
}
| 292,297 | 1,074 |
f5e89c31f86dccaad9e3ea96e04e9801eeecf3900096095e9ef094d425e02c44
| 16,839 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x7d2701fb8c73e279e818db92544e471d5df3afdf.sol
| 3,472 | 13,125 |
pragma solidity ^0.4.21;
// Project: alehub.io
// v11, 2018-07-17
// This code is the property of CryptoB2B.io
// Copying in whole or in part is prohibited.
// Authors: Ivan Fedorov and Dmitry Borodin
// Do you want the same TokenSale platform? www.cryptob2b.io
contract MigrationAgent
{
function migrateFrom(address _from, uint256 _value) public;
}
contract IFinancialStrategy{
enum State { Active, Refunding, Closed }
State public state = State.Active;
event Deposited(address indexed beneficiary, uint256 weiAmount);
event Receive(address indexed beneficiary, uint256 weiAmount);
event Refunded(address indexed beneficiary, uint256 weiAmount);
event Started();
event Closed();
event RefundsEnabled();
function freeCash() view public returns(uint256);
function deposit(address _beneficiary) external payable;
function refund(address _investor) external;
function setup(uint8 _state, bytes32[] _params) external;
function getBeneficiaryCash() external;
function getPartnerCash(uint8 _user, address _msgsender) external;
}
contract IAllocation {
function addShare(address _beneficiary, uint256 _proportion, uint256 _percenForFirstPart) external;
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
function minus(uint256 a, uint256 b) internal pure returns (uint256) {
if (b>=a) return 0;
return a - b;
}
}
contract GuidedByRoles {
IRightAndRoles public rightAndRoles;
function GuidedByRoles(IRightAndRoles _rightAndRoles) public {
rightAndRoles = _rightAndRoles;
}
}
contract Pausable is GuidedByRoles {
mapping (address => bool) public unpausedWallet;
event Pause();
event Unpause();
bool public paused = true;
modifier whenNotPaused(address _to) {
require(!paused||unpausedWallet[msg.sender]||unpausedWallet[_to]);
_;
}
function onlyAdmin() internal view {
require(rightAndRoles.onlyRoles(msg.sender,3));
}
// Add a wallet ignoring the "Exchange pause". Available to the owner of the contract.
function setUnpausedWallet(address _wallet, bool mode) public {
onlyAdmin();
unpausedWallet[_wallet] = mode;
}
function setPause(bool mode) public {
require(rightAndRoles.onlyRoles(msg.sender,1));
if (!paused && mode) {
paused = true;
emit Pause();
}else
if (paused && !mode) {
paused = false;
emit Unpause();
}
}
}
contract IRightAndRoles {
address[][] public wallets;
mapping(address => uint16) public roles;
event WalletChanged(address indexed newWallet, address indexed oldWallet, uint8 indexed role);
event CloneChanged(address indexed wallet, uint8 indexed role, bool indexed mod);
function changeWallet(address _wallet, uint8 _role) external;
function setManagerPowerful(bool _mode) external;
function onlyRoles(address _sender, uint16 _roleMask) view external returns(bool);
}
contract IToken{
function setUnpausedWallet(address _wallet, bool mode) public;
function mint(address _to, uint256 _amount) public returns (bool);
function totalSupply() public view returns (uint256);
function setPause(bool mode) public;
function setMigrationAgent(address _migrationAgent) public;
function migrateAll(address[] _holders) public;
function rejectTokens(address _beneficiary, uint256 _value) public;
function freezedTokenOf(address _beneficiary) public view returns (uint256 amount);
function defrostDate(address _beneficiary) public view returns (uint256 Date);
function freezeTokens(address _beneficiary, uint256 _amount, uint256 _when) public;
}
contract ICreator{
IRightAndRoles public rightAndRoles;
function createAllocation(IToken _token, uint256 _unlockPart1, uint256 _unlockPart2) external returns (IAllocation);
function createFinancialStrategy() external returns(IFinancialStrategy);
function getRightAndRoles() external returns(IRightAndRoles);
}
contract ERC20Provider is GuidedByRoles {
function transferTokens(ERC20Basic _token, address _to, uint256 _value) public returns (bool){
require(rightAndRoles.onlyRoles(msg.sender,2));
return _token.transfer(_to,_value);
}
}
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);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
contract KycToken is BasicToken, GuidedByRoles {
event TokensRejected(address indexed beneficiary, uint256 value);
function rejectTokens(address _beneficiary, uint256 _value) public {
require(rightAndRoles.onlyRoles(msg.sender,1));
require(_value <= balances[_beneficiary]);
// no need to require value <= totalSupply, since that would imply the
// sender's balance is greater than the totalSupply, which *should* be an assertion failure
balances[_beneficiary] = balances[_beneficiary].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
emit TokensRejected(_beneficiary, _value);
emit Transfer(_beneficiary, address(0), _value);
}
}
contract MigratableToken is BasicToken,GuidedByRoles {
uint256 public totalMigrated;
address public migrationAgent;
event Migrate(address indexed _from, address indexed _to, uint256 _value);
function setMigrationAgent(address _migrationAgent) public {
require(rightAndRoles.onlyRoles(msg.sender,1));
require(totalMigrated == 0);
migrationAgent = _migrationAgent;
}
function migrateInternal(address _holder) internal{
require(migrationAgent != 0x0);
uint256 value = balances[_holder];
balances[_holder] = 0;
totalSupply_ = totalSupply_.sub(value);
totalMigrated = totalMigrated.add(value);
MigrationAgent(migrationAgent).migrateFrom(_holder, value);
emit Migrate(_holder,migrationAgent,value);
}
function migrateAll(address[] _holders) public {
require(rightAndRoles.onlyRoles(msg.sender,1));
for(uint i = 0; i < _holders.length; i++){
migrateInternal(_holders[i]);
}
}
// Reissue your tokens.
function migrate() public
{
require(balances[msg.sender] > 0);
migrateInternal(msg.sender);
}
}
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 (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract PausableToken is StandardToken, Pausable {
function transfer(address _to, uint256 _value) public whenNotPaused(_to) returns (bool) {
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused(_to) returns (bool) {
return super.transferFrom(_from, _to, _value);
}
}
contract MintableToken is StandardToken, GuidedByRoles {
event Mint(address indexed to, uint256 amount);
event MintFinished();
function mint(address _to, uint256 _amount) public returns (bool) {
require(rightAndRoles.onlyRoles(msg.sender,1));
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Mint(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
}
contract FreezingToken is PausableToken {
struct freeze {
uint256 amount;
uint256 when;
}
mapping (address => freeze) freezedTokens;
function freezedTokenOf(address _beneficiary) public view returns (uint256 amount){
freeze storage _freeze = freezedTokens[_beneficiary];
if(_freeze.when < now) return 0;
return _freeze.amount;
}
function defrostDate(address _beneficiary) public view returns (uint256 Date) {
freeze storage _freeze = freezedTokens[_beneficiary];
if(_freeze.when < now) return 0;
return _freeze.when;
}
function freezeTokens(address _beneficiary, uint256 _amount, uint256 _when) public {
require(rightAndRoles.onlyRoles(msg.sender,1));
freeze storage _freeze = freezedTokens[_beneficiary];
_freeze.amount = _amount;
_freeze.when = _when;
}
function masFreezedTokens(address[] _beneficiary, uint256[] _amount, uint256[] _when) public {
onlyAdmin();
require(_beneficiary.length == _amount.length && _beneficiary.length == _when.length);
for(uint16 i = 0; i < _beneficiary.length; i++){
freeze storage _freeze = freezedTokens[_beneficiary[i]];
_freeze.amount = _amount[i];
_freeze.when = _when[i];
}
}
function transferAndFreeze(address _to, uint256 _value, uint256 _when) external {
require(unpausedWallet[msg.sender]);
require(freezedTokenOf(_to) == 0);
if(_when > 0){
freeze storage _freeze = freezedTokens[_to];
_freeze.amount = _value;
_freeze.when = _when;
}
transfer(_to,_value);
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(balanceOf(msg.sender) >= freezedTokenOf(msg.sender).add(_value));
return super.transfer(_to,_value);
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(balanceOf(_from) >= freezedTokenOf(_from).add(_value));
return super.transferFrom(_from,_to,_value);
}
}
contract Token is IToken, FreezingToken, MintableToken, MigratableToken, KycToken,ERC20Provider {
function Token(ICreator _creator) GuidedByRoles(_creator.rightAndRoles()) public {}
string public constant name = "Ale Coin";
string public constant symbol = "ALE";
uint8 public constant decimals = 18;
}
| 145,033 | 1,075 |
51eda08b9273cd3754e577f85545e45c2a366ff6c26d5f875491b2611187152b
| 18,653 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x253f6e0bfe6c7675e8513b4c132f00b00b951d5e.sol
| 3,553 | 13,904 |
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract ERC223 {
uint public totalSupply;
// ERC223 and ERC20 functions and events
function balanceOf(address who) public view returns (uint);
function totalSupply() public view returns (uint256 _supply);
function transfer(address to, uint value) public returns (bool ok);
function transfer(address to, uint value, bytes data) public returns (bool ok);
function transfer(address to, uint value, bytes data, string customFallback) public returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value, bytes indexed data);
// ERC223 functions
function name() public view returns (string _name);
function symbol() public view returns (string _symbol);
function decimals() public view returns (uint8 _decimals);
// ERC20 functions and events
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public view returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
contract ContractReceiver {
struct TKN {
address sender;
uint value;
bytes data;
bytes4 sig;
}
function tokenFallback(address _from, uint _value, bytes _data) public pure {
TKN memory tkn;
tkn.sender = _from;
tkn.value = _value;
tkn.data = _data;
uint32 u = uint32(_data[3]) + (uint32(_data[2]) << 8) + (uint32(_data[1]) << 16) + (uint32(_data[0]) << 24);
tkn.sig = bytes4(u);
}
}
contract Arascacoin is ERC223, Ownable {
using SafeMath for uint256;
string public name = "Arascacoin";
string public symbol = "ASC";
uint8 public decimals = 8;
uint256 public totalSupply = 10512e4 * 1e8;
uint256 public distributeAmount = 0;
bool public mintingFinished = false;
mapping(address => uint256) public balanceOf;
mapping(address => mapping (address => uint256)) public allowance;
mapping (address => bool) public frozenAccount;
mapping (address => uint256) public unlockUnixTime;
event FrozenFunds(address indexed target, bool frozen);
event LockedFunds(address indexed target, uint256 locked);
event Burn(address indexed from, uint256 amount);
event Mint(address indexed to, uint256 amount);
event MintFinished();
function Arascacoin() public {
balanceOf[msg.sender] = totalSupply;
}
function name() public view returns (string _name) {
return name;
}
function symbol() public view returns (string _symbol) {
return symbol;
}
function decimals() public view returns (uint8 _decimals) {
return decimals;
}
function totalSupply() public view returns (uint256 _totalSupply) {
return totalSupply;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balanceOf[_owner];
}
function freezeAccounts(address[] targets, bool isFrozen) onlyOwner public {
require(targets.length > 0);
for (uint j = 0; j < targets.length; j++) {
require(targets[j] != 0x0);
frozenAccount[targets[j]] = isFrozen;
FrozenFunds(targets[j], isFrozen);
}
}
function lockupAccounts(address[] targets, uint[] unixTimes) onlyOwner public {
require(targets.length > 0
&& targets.length == unixTimes.length);
for(uint j = 0; j < targets.length; j++){
require(unlockUnixTime[targets[j]] < unixTimes[j]);
unlockUnixTime[targets[j]] = unixTimes[j];
LockedFunds(targets[j], unixTimes[j]);
}
}
function transfer(address _to, uint _value, bytes _data, string _custom_fallback) public returns (bool success) {
require(_value > 0
&& frozenAccount[msg.sender] == false
&& frozenAccount[_to] == false
&& now > unlockUnixTime[msg.sender]
&& now > unlockUnixTime[_to]);
if (isContract(_to)) {
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
assert(_to.call.value(0)(bytes4(keccak256(_custom_fallback)), msg.sender, _value, _data));
Transfer(msg.sender, _to, _value, _data);
Transfer(msg.sender, _to, _value);
return true;
} else {
return transferToAddress(_to, _value, _data);
}
}
function transfer(address _to, uint _value, bytes _data) public returns (bool success) {
require(_value > 0
&& frozenAccount[msg.sender] == false
&& frozenAccount[_to] == false
&& now > unlockUnixTime[msg.sender]
&& now > unlockUnixTime[_to]);
if (isContract(_to)) {
return transferToContract(_to, _value, _data);
} else {
return transferToAddress(_to, _value, _data);
}
}
function transfer(address _to, uint _value) public returns (bool success) {
require(_value > 0
&& frozenAccount[msg.sender] == false
&& frozenAccount[_to] == false
&& now > unlockUnixTime[msg.sender]
&& now > unlockUnixTime[_to]);
bytes memory empty;
if (isContract(_to)) {
return transferToContract(_to, _value, empty);
} else {
return transferToAddress(_to, _value, empty);
}
}
// assemble the given address bytecode. If bytecode exists then the _addr is a contract.
function isContract(address _addr) private view returns (bool is_contract) {
uint length;
assembly {
//retrieve the size of the code on target address, this needs assembly
length := extcodesize(_addr)
}
return (length > 0);
}
// function that is called when transaction target is an address
function transferToAddress(address _to, uint _value, bytes _data) private returns (bool success) {
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
Transfer(msg.sender, _to, _value, _data);
Transfer(msg.sender, _to, _value);
return true;
}
// function that is called when transaction target is a contract
function transferToContract(address _to, uint _value, bytes _data) private returns (bool success) {
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
ContractReceiver receiver = ContractReceiver(_to);
receiver.tokenFallback(msg.sender, _value, _data);
Transfer(msg.sender, _to, _value, _data);
Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_to != address(0)
&& _value > 0
&& balanceOf[_from] >= _value
&& allowance[_from][msg.sender] >= _value
&& frozenAccount[_from] == false
&& frozenAccount[_to] == false
&& now > unlockUnixTime[_from]
&& now > unlockUnixTime[_to]);
balanceOf[_from] = balanceOf[_from].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
allowance[_from][msg.sender] = allowance[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool success) {
allowance[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
return allowance[_owner][_spender];
}
function burn(address _from, uint256 _unitAmount) onlyOwner public {
require(_unitAmount > 0
&& balanceOf[_from] >= _unitAmount);
balanceOf[_from] = balanceOf[_from].sub(_unitAmount);
totalSupply = totalSupply.sub(_unitAmount);
Burn(_from, _unitAmount);
}
modifier canMint() {
require(!mintingFinished);
_;
}
function mint(address _to, uint256 _unitAmount) onlyOwner canMint public returns (bool) {
require(_unitAmount > 0);
totalSupply = totalSupply.add(_unitAmount);
balanceOf[_to] = balanceOf[_to].add(_unitAmount);
Mint(_to, _unitAmount);
Transfer(address(0), _to, _unitAmount);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
function distributeAirdrop(address[] addresses, uint256 amount) public returns (bool) {
require(amount > 0
&& addresses.length > 0
&& frozenAccount[msg.sender] == false
&& now > unlockUnixTime[msg.sender]);
amount = amount.mul(1e8);
uint256 totalAmount = amount.mul(addresses.length);
require(balanceOf[msg.sender] >= totalAmount);
for (uint j = 0; j < addresses.length; j++) {
require(addresses[j] != 0x0
&& frozenAccount[addresses[j]] == false
&& now > unlockUnixTime[addresses[j]]);
balanceOf[addresses[j]] = balanceOf[addresses[j]].add(amount);
Transfer(msg.sender, addresses[j], amount);
}
balanceOf[msg.sender] = balanceOf[msg.sender].sub(totalAmount);
return true;
}
function distributeAirdrop(address[] addresses, uint[] amounts) public returns (bool) {
require(addresses.length > 0
&& addresses.length == amounts.length
&& frozenAccount[msg.sender] == false
&& now > unlockUnixTime[msg.sender]);
uint256 totalAmount = 0;
for(uint j = 0; j < addresses.length; j++){
require(amounts[j] > 0
&& addresses[j] != 0x0
&& frozenAccount[addresses[j]] == false
&& now > unlockUnixTime[addresses[j]]);
amounts[j] = amounts[j].mul(1e8);
totalAmount = totalAmount.add(amounts[j]);
}
require(balanceOf[msg.sender] >= totalAmount);
for (j = 0; j < addresses.length; j++) {
balanceOf[addresses[j]] = balanceOf[addresses[j]].add(amounts[j]);
Transfer(msg.sender, addresses[j], amounts[j]);
}
balanceOf[msg.sender] = balanceOf[msg.sender].sub(totalAmount);
return true;
}
function collectTokens(address[] addresses, uint[] amounts) onlyOwner public returns (bool) {
require(addresses.length > 0
&& addresses.length == amounts.length);
uint256 totalAmount = 0;
for (uint j = 0; j < addresses.length; j++) {
require(amounts[j] > 0
&& addresses[j] != 0x0
&& frozenAccount[addresses[j]] == false
&& now > unlockUnixTime[addresses[j]]);
amounts[j] = amounts[j].mul(1e8);
require(balanceOf[addresses[j]] >= amounts[j]);
balanceOf[addresses[j]] = balanceOf[addresses[j]].sub(amounts[j]);
totalAmount = totalAmount.add(amounts[j]);
Transfer(addresses[j], msg.sender, amounts[j]);
}
balanceOf[msg.sender] = balanceOf[msg.sender].add(totalAmount);
return true;
}
function setDistributeAmount(uint256 _unitAmount) onlyOwner public {
distributeAmount = _unitAmount;
}
function autoDistribute() payable public {
require(distributeAmount > 0
&& balanceOf[owner] >= distributeAmount
&& frozenAccount[msg.sender] == false
&& now > unlockUnixTime[msg.sender]);
if(msg.value > 0) owner.transfer(msg.value);
balanceOf[owner] = balanceOf[owner].sub(distributeAmount);
balanceOf[msg.sender] = balanceOf[msg.sender].add(distributeAmount);
Transfer(owner, msg.sender, distributeAmount);
}
function() payable public {
autoDistribute();
}
}
| 146,116 | 1,076 |
8c8389cb8970a33dc1a6065402a7d6d5284e45a770875edcd27e2e236340210b
| 12,587 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0x926703fb558f46331b6a06322bcf9e9d017fe6ec.sol
| 3,129 | 12,212 |
pragma solidity 0.4.15;
contract RegistryICAPInterface {
function parse(bytes32 _icap) constant returns(address, bytes32, bool);
function institutions(bytes32 _institution) constant returns(address);
}
contract EToken2Interface {
function registryICAP() constant returns(RegistryICAPInterface);
function baseUnit(bytes32 _symbol) constant returns(uint8);
function description(bytes32 _symbol) constant returns(string);
function owner(bytes32 _symbol) constant returns(address);
function isOwner(address _owner, bytes32 _symbol) constant returns(bool);
function totalSupply(bytes32 _symbol) constant returns(uint);
function balanceOf(address _holder, bytes32 _symbol) constant returns(uint);
function isLocked(bytes32 _symbol) constant returns(bool);
function issueAsset(bytes32 _symbol, uint _value, string _name, string _description, uint8 _baseUnit, bool _isReissuable) returns(bool);
function reissueAsset(bytes32 _symbol, uint _value) returns(bool);
function revokeAsset(bytes32 _symbol, uint _value) returns(bool);
function setProxy(address _address, bytes32 _symbol) returns(bool);
function lockAsset(bytes32 _symbol) returns(bool);
function proxyTransferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference, address _sender) returns(bool);
function proxyApprove(address _spender, uint _value, bytes32 _symbol, address _sender) returns(bool);
function allowance(address _from, address _spender, bytes32 _symbol) constant returns(uint);
function proxyTransferFromWithReference(address _from, address _to, uint _value, bytes32 _symbol, string _reference, address _sender) returns(bool);
}
contract AssetInterface {
function _performTransferWithReference(address _to, uint _value, string _reference, address _sender) returns(bool);
function _performTransferToICAPWithReference(bytes32 _icap, uint _value, string _reference, address _sender) returns(bool);
function _performApprove(address _spender, uint _value, address _sender) returns(bool);
function _performTransferFromWithReference(address _from, address _to, uint _value, string _reference, address _sender) returns(bool);
function _performTransferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference, address _sender) returns(bool);
function _performGeneric(bytes, address) payable {
revert();
}
}
contract ERC20Interface {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed from, address indexed spender, uint256 value);
function totalSupply() constant returns(uint256 supply);
function balanceOf(address _owner) constant returns(uint256 balance);
function transfer(address _to, uint256 _value) returns(bool success);
function transferFrom(address _from, address _to, uint256 _value) returns(bool success);
function approve(address _spender, uint256 _value) returns(bool success);
function allowance(address _owner, address _spender) constant returns(uint256 remaining);
function decimals() constant returns(uint8);
}
contract AssetProxyInterface {
function _forwardApprove(address _spender, uint _value, address _sender) returns(bool);
function _forwardTransferFromWithReference(address _from, address _to, uint _value, string _reference, address _sender) returns(bool);
function _forwardTransferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference, address _sender) returns(bool);
function balanceOf(address _owner) constant returns(uint);
}
contract Bytes32 {
function _bytes32(string _input) internal constant returns(bytes32 result) {
assembly {
result := mload(add(_input, 32))
}
}
}
contract ReturnData {
function _returnReturnData(bool _success) internal {
assembly {
let returndatastart := msize()
mstore(0x40, add(returndatastart, returndatasize))
returndatacopy(returndatastart, 0, returndatasize)
switch _success case 0 { revert(returndatastart, returndatasize) } default { return(returndatastart, returndatasize) }
}
}
function _assemblyCall(address _destination, uint _value, bytes _data) internal returns(bool success) {
assembly {
success := call(div(mul(gas, 63), 64), _destination, _value, add(_data, 32), mload(_data), 0, 0)
}
}
}
contract K2G is ERC20Interface, AssetProxyInterface, Bytes32, ReturnData {
EToken2Interface public etoken2;
bytes32 public etoken2Symbol;
string public name;
string public symbol;
function init(EToken2Interface _etoken2, string _symbol, string _name) returns(bool) {
if (address(etoken2) != 0x0) {
return false;
}
etoken2 = _etoken2;
etoken2Symbol = _bytes32(_symbol);
name = _name;
symbol = _symbol;
return true;
}
modifier onlyEToken2() {
if (msg.sender == address(etoken2)) {
_;
}
}
modifier onlyAssetOwner() {
if (etoken2.isOwner(msg.sender, etoken2Symbol)) {
_;
}
}
function _getAsset() internal returns(AssetInterface) {
return AssetInterface(getVersionFor(msg.sender));
}
function recoverTokens(uint _value) onlyAssetOwner() returns(bool) {
return this.transferWithReference(msg.sender, _value, 'Tokens recovery');
}
function totalSupply() constant returns(uint) {
return etoken2.totalSupply(etoken2Symbol);
}
function balanceOf(address _owner) constant returns(uint) {
return etoken2.balanceOf(_owner, etoken2Symbol);
}
function allowance(address _from, address _spender) constant returns(uint) {
return etoken2.allowance(_from, _spender, etoken2Symbol);
}
function decimals() constant returns(uint8) {
return etoken2.baseUnit(etoken2Symbol);
}
function transfer(address _to, uint _value) returns(bool) {
return transferWithReference(_to, _value, '');
}
function transferWithReference(address _to, uint _value, string _reference) returns(bool) {
return _getAsset()._performTransferWithReference(_to, _value, _reference, msg.sender);
}
function transferToICAP(bytes32 _icap, uint _value) returns(bool) {
return transferToICAPWithReference(_icap, _value, '');
}
function transferToICAPWithReference(bytes32 _icap, uint _value, string _reference) returns(bool) {
return _getAsset()._performTransferToICAPWithReference(_icap, _value, _reference, msg.sender);
}
function transferFrom(address _from, address _to, uint _value) returns(bool) {
return transferFromWithReference(_from, _to, _value, '');
}
function transferFromWithReference(address _from, address _to, uint _value, string _reference) returns(bool) {
return _getAsset()._performTransferFromWithReference(_from, _to, _value, _reference, msg.sender);
}
function _forwardTransferFromWithReference(address _from, address _to, uint _value, string _reference, address _sender) onlyImplementationFor(_sender) returns(bool) {
return etoken2.proxyTransferFromWithReference(_from, _to, _value, etoken2Symbol, _reference, _sender);
}
function transferFromToICAP(address _from, bytes32 _icap, uint _value) returns(bool) {
return transferFromToICAPWithReference(_from, _icap, _value, '');
}
function transferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference) returns(bool) {
return _getAsset()._performTransferFromToICAPWithReference(_from, _icap, _value, _reference, msg.sender);
}
function _forwardTransferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference, address _sender) onlyImplementationFor(_sender) returns(bool) {
return etoken2.proxyTransferFromToICAPWithReference(_from, _icap, _value, _reference, _sender);
}
function approve(address _spender, uint _value) returns(bool) {
return _getAsset()._performApprove(_spender, _value, msg.sender);
}
function _forwardApprove(address _spender, uint _value, address _sender) onlyImplementationFor(_sender) returns(bool) {
return etoken2.proxyApprove(_spender, _value, etoken2Symbol, _sender);
}
function emitTransfer(address _from, address _to, uint _value) onlyEToken2() {
Transfer(_from, _to, _value);
}
function emitApprove(address _from, address _spender, uint _value) onlyEToken2() {
Approval(_from, _spender, _value);
}
function () payable {
_getAsset()._performGeneric.value(msg.value)(msg.data, msg.sender);
_returnReturnData(true);
}
function transferToICAP(string _icap, uint _value) returns(bool) {
return transferToICAPWithReference(_icap, _value, '');
}
function transferToICAPWithReference(string _icap, uint _value, string _reference) returns(bool) {
return transferToICAPWithReference(_bytes32(_icap), _value, _reference);
}
function transferFromToICAP(address _from, string _icap, uint _value) returns(bool) {
return transferFromToICAPWithReference(_from, _icap, _value, '');
}
function transferFromToICAPWithReference(address _from, string _icap, uint _value, string _reference) returns(bool) {
return transferFromToICAPWithReference(_from, _bytes32(_icap), _value, _reference);
}
event UpgradeProposed(address newVersion);
event UpgradePurged(address newVersion);
event UpgradeCommited(address newVersion);
event OptedOut(address sender, address version);
event OptedIn(address sender, address version);
address latestVersion;
address pendingVersion;
uint pendingVersionTimestamp;
uint constant UPGRADE_FREEZE_TIME = 3 days;
mapping(address => address) userOptOutVersion;
modifier onlyImplementationFor(address _sender) {
if (getVersionFor(_sender) == msg.sender) {
_;
}
}
function getVersionFor(address _sender) constant returns(address) {
return userOptOutVersion[_sender] == 0 ? latestVersion : userOptOutVersion[_sender];
}
function getLatestVersion() constant returns(address) {
return latestVersion;
}
function getPendingVersion() constant returns(address) {
return pendingVersion;
}
function getPendingVersionTimestamp() constant returns(uint) {
return pendingVersionTimestamp;
}
function proposeUpgrade(address _newVersion) onlyAssetOwner() returns(bool) {
if (pendingVersion != 0x0) {
return false;
}
if (_newVersion == 0x0) {
return false;
}
if (latestVersion == 0x0) {
latestVersion = _newVersion;
return true;
}
pendingVersion = _newVersion;
pendingVersionTimestamp = now;
UpgradeProposed(_newVersion);
return true;
}
function purgeUpgrade() onlyAssetOwner() returns(bool) {
if (pendingVersion == 0x0) {
return false;
}
UpgradePurged(pendingVersion);
delete pendingVersion;
delete pendingVersionTimestamp;
return true;
}
function commitUpgrade() returns(bool) {
if (pendingVersion == 0x0) {
return false;
}
if (pendingVersionTimestamp + UPGRADE_FREEZE_TIME > now) {
return false;
}
latestVersion = pendingVersion;
delete pendingVersion;
delete pendingVersionTimestamp;
UpgradeCommited(latestVersion);
return true;
}
function optOut() returns(bool) {
if (userOptOutVersion[msg.sender] != 0x0) {
return false;
}
userOptOutVersion[msg.sender] = latestVersion;
OptedOut(msg.sender, latestVersion);
return true;
}
function optIn() returns(bool) {
delete userOptOutVersion[msg.sender];
OptedIn(msg.sender, latestVersion);
return true;
}
function multiAsset() constant returns(EToken2Interface) {
return etoken2;
}
}
| 161,344 | 1,077 |
fd3d1a8f681d47827307765c1c7d3c0d51a1cb40cfbe87853bfac71f5d1431aa
| 12,331 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/f0/f003b5e8f232fc8fb58250a618731243775adf7f_Ethereumpizza.sol
| 3,119 | 11,664 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract Ethereumpizza is Context , IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private bots;
mapping(address => uint256) private _holderLastTransferTimestamp;
bool public transferDelayEnabled = true;
address payable private _taxWallet;
uint256 private _initialBuyTax=20;
uint256 private _initialSellTax=20;
uint256 private _finalBuyTax=0;
uint256 private _finalSellTax=0;
uint256 private _reduceBuyTaxAt=15;
uint256 private _reduceSellTaxAt=25;
uint256 private _preventSwapBefore=20;
uint256 private _buyCount=0;
uint8 private constant _decimals = 9;
uint256 private constant _tTotal = 1000000 * 10**_decimals;
string private constant _name = unicode"Ethereumpizza";
string private constant _symbol = unicode"PIZZA";
uint256 public _maxTxAmount = 20000 * 10**_decimals;
uint256 public _maxWalletSize = 20000 * 10**_decimals;
uint256 public _taxSwapThreshold= 10000 * 10**_decimals;
uint256 public _maxTaxSwap= 10000 * 10**_decimals;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = false;
event MaxTxAmountUpdated(uint _maxTxAmount);
modifier lockTheSwap {
inSwap = true;
_;
inSwap = false;
}
constructor () {
_taxWallet = payable(_msgSender());
_balances[_msgSender()] = _tTotal;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedFromFee[_taxWallet] = true;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public pure returns (string memory) {
return _name;
}
function symbol() public pure returns (string memory) {
return _symbol;
}
function decimals() public pure returns (uint8) {
return _decimals;
}
function totalSupply() public pure override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
uint256 taxAmount=0;
if (from != owner() && to != owner()) {
require(!bots[from] && !bots[to]);
taxAmount = amount.mul((_buyCount>_reduceBuyTaxAt)?_finalBuyTax:_initialBuyTax).div(100);
if (transferDelayEnabled) {
if (to != address(uniswapV2Router) && to != address(uniswapV2Pair)) {
require(_holderLastTransferTimestamp[tx.origin] <
block.number,
"_transfer:: Transfer Delay enabled. Only one purchase per block allowed.");
_holderLastTransferTimestamp[tx.origin] = block.number;
}
}
if (from == uniswapV2Pair && to != address(uniswapV2Router) && ! _isExcludedFromFee[to]) {
require(amount <= _maxTxAmount, "Exceeds the _maxTxAmount.");
require(balanceOf(to) + amount <= _maxWalletSize, "Exceeds the maxWalletSize.");
_buyCount++;
}
if(to == uniswapV2Pair && from!= address(this)){
taxAmount = amount.mul((_buyCount>_reduceSellTaxAt)?_finalSellTax:_initialSellTax).div(100);
}
uint256 contractTokenBalance = balanceOf(address(this));
if (!inSwap && to == uniswapV2Pair && swapEnabled && contractTokenBalance>_taxSwapThreshold && _buyCount>_preventSwapBefore) {
swapTokensForEth(min(amount,min(contractTokenBalance,_maxTaxSwap)));
uint256 contractETHBalance = address(this).balance;
if(contractETHBalance > 0) {
sendETHToFee(address(this).balance);
}
}
}
if(taxAmount>0){
_balances[address(this)]=_balances[address(this)].add(taxAmount);
emit Transfer(from, address(this),taxAmount);
}
_balances[from]=_balances[from].sub(amount);
_balances[to]=_balances[to].add(amount.sub(taxAmount));
emit Transfer(from, to, amount.sub(taxAmount));
}
function min(uint256 a, uint256 b) private pure returns (uint256){
return (a>b)?b:a;
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = uniswapV2Router.WETH();
_approve(address(this), address(uniswapV2Router), tokenAmount);
uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(tokenAmount,
0,
path,
address(this),
block.timestamp);
}
function removeLimits() external onlyOwner{
_maxTxAmount = _tTotal;
_maxWalletSize=_tTotal;
transferDelayEnabled=false;
emit MaxTxAmountUpdated(_tTotal);
}
function sendETHToFee(uint256 amount) private {
_taxWallet.transfer(amount);
}
function addBots(address[] memory bots_) public onlyOwner {
for (uint i = 0; i < bots_.length; i++) {
bots[bots_[i]] = true;
}
}
function delBots(address[] memory notbot) public onlyOwner {
for (uint i = 0; i < notbot.length; i++) {
bots[notbot[i]] = false;
}
}
function isBot(address a) public view returns (bool){
return bots[a];
}
function openTrading() external onlyOwner() {
require(!tradingOpen,"trading is already open");
uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
_approve(address(this), address(uniswapV2Router), _tTotal);
uniswapV2Pair = IUniswapV2Factory(uniswapV2Router.factory()).createPair(address(this), uniswapV2Router.WETH());
uniswapV2Router.addLiquidityETH{value: address(this).balance}(address(this),balanceOf(address(this)),0,0,owner(),block.timestamp);
IERC20(uniswapV2Pair).approve(address(uniswapV2Router), type(uint).max);
swapEnabled = true;
tradingOpen = true;
}
function reduceFee(uint256 _newFee) external{
require(_msgSender()==_taxWallet);
require(_newFee<=_finalBuyTax && _newFee<=_finalSellTax);
_finalBuyTax=_newFee;
_finalSellTax=_newFee;
}
receive() external payable {}
function manualSwap() external {
require(_msgSender()==_taxWallet);
uint256 tokenBalance=balanceOf(address(this));
if(tokenBalance>0){
swapTokensForEth(tokenBalance);
}
uint256 ethBalance=address(this).balance;
if(ethBalance>0){
sendETHToFee(ethBalance);
}
}
}
| 32,909 | 1,078 |
0a8b16a444c7c3453b9b589cb8ff803fef300c9693c6b7cce7eb76b9ecb0d997
| 18,549 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TM/TM64GhKxskgCvnATAmiggdDXhpQyJKtf8R_trinytron_inversion.sol
| 4,828 | 17,067 |
//SourceUnit: trinytron_inversion.sol
pragma solidity ^0.4.24;
library BokkyPooBahsDateTimeLibrary {
uint constant SECONDS_PER_DAY = 24 * 60 * 60;
uint constant SECONDS_PER_HOUR = 60 * 60;
uint constant SECONDS_PER_MINUTE = 60;
int constant OFFSET19700101 = 2440588;
uint constant DOW_MON = 1;
uint constant DOW_TUE = 2;
uint constant DOW_WED = 3;
uint constant DOW_THU = 4;
uint constant DOW_FRI = 5;
uint constant DOW_SAT = 6;
uint constant DOW_SUN = 7;
function _daysFromDate(uint year, uint month, uint day) internal pure returns (uint _days) {
require(year >= 1970);
int _year = int(year);
int _month = int(month);
int _day = int(day);
int __days = _day
- 32075
+ 1461 * (_year + 4800 + (_month - 14) / 12) / 4
+ 367 * (_month - 2 - (_month - 14) / 12 * 12) / 12
- 3 * ((_year + 4900 + (_month - 14) / 12) / 100) / 4
- OFFSET19700101;
_days = uint(__days);
}
function _daysToDate(uint _days) internal pure returns (uint year, uint month, uint day) {
int __days = int(_days);
int L = __days + 68569 + OFFSET19700101;
int N = 4 * L / 146097;
L = L - (146097 * N + 3) / 4;
int _year = 4000 * (L + 1) / 1461001;
L = L - 1461 * _year / 4 + 31;
int _month = 80 * L / 2447;
int _day = L - 2447 * _month / 80;
L = _month / 11;
_month = _month + 2 - 12 * L;
_year = 100 * (N - 49) + _year + L;
year = uint(_year);
month = uint(_month);
day = uint(_day);
}
function timestampFromDate(uint year, uint month, uint day) internal pure returns (uint timestamp) {
timestamp = _daysFromDate(year, month, day) * SECONDS_PER_DAY;
}
function timestampFromDateTime(uint year, uint month, uint day, uint hour, uint minute, uint second) internal pure returns (uint timestamp) {
timestamp = _daysFromDate(year, month, day) * SECONDS_PER_DAY + hour * SECONDS_PER_HOUR + minute * SECONDS_PER_MINUTE + second;
}
function timestampToDate(uint timestamp) internal pure returns (uint year, uint month, uint day) {
(year, month, day) = _daysToDate(timestamp / SECONDS_PER_DAY);
}
function timestampToDateTime(uint timestamp) internal pure returns (uint year, uint month, uint day, uint hour, uint minute, uint second) {
(year, month, day) = _daysToDate(timestamp / SECONDS_PER_DAY);
uint secs = timestamp % SECONDS_PER_DAY;
hour = secs / SECONDS_PER_HOUR;
secs = secs % SECONDS_PER_HOUR;
minute = secs / SECONDS_PER_MINUTE;
second = secs % SECONDS_PER_MINUTE;
}
function isValidDate(uint year, uint month, uint day) internal pure returns (bool valid) {
if (year >= 1970 && month > 0 && month <= 12) {
uint daysInMonth = _getDaysInMonth(year, month);
if (day > 0 && day <= daysInMonth) {
valid = true;
}
}
}
function isValidDateTime(uint year, uint month, uint day, uint hour, uint minute, uint second) internal pure returns (bool valid) {
if (isValidDate(year, month, day)) {
if (hour < 24 && minute < 60 && second < 60) {
valid = true;
}
}
}
function isLeapYear(uint timestamp) internal pure returns (bool leapYear) {
uint year;
uint month;
uint day;
(year, month, day) = _daysToDate(timestamp / SECONDS_PER_DAY);
leapYear = _isLeapYear(year);
}
function _isLeapYear(uint year) internal pure returns (bool leapYear) {
leapYear = ((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0);
}
function isWeekDay(uint timestamp) internal pure returns (bool weekDay) {
weekDay = getDayOfWeek(timestamp) <= DOW_FRI;
}
function isWeekEnd(uint timestamp) internal pure returns (bool weekEnd) {
weekEnd = getDayOfWeek(timestamp) >= DOW_SAT;
}
function getDaysInMonth(uint timestamp) internal pure returns (uint daysInMonth) {
uint year;
uint month;
uint day;
(year, month, day) = _daysToDate(timestamp / SECONDS_PER_DAY);
daysInMonth = _getDaysInMonth(year, month);
}
function _getDaysInMonth(uint year, uint month) internal pure returns (uint daysInMonth) {
if (month == 1 || month == 3 || month == 5 || month == 7 || month == 8 || month == 10 || month == 12) {
daysInMonth = 31;
} else if (month != 2) {
daysInMonth = 30;
} else {
daysInMonth = _isLeapYear(year) ? 29 : 28;
}
}
// 1 = Monday, 7 = Sunday
function getDayOfWeek(uint timestamp) internal pure returns (uint dayOfWeek) {
uint _days = timestamp / SECONDS_PER_DAY;
dayOfWeek = (_days + 3) % 7 + 1;
}
function getYear(uint timestamp) internal pure returns (uint year) {
uint month;
uint day;
(year, month, day) = _daysToDate(timestamp / SECONDS_PER_DAY);
}
function getMonth(uint timestamp) internal pure returns (uint month) {
uint year;
uint day;
(year, month, day) = _daysToDate(timestamp / SECONDS_PER_DAY);
}
function getDay(uint timestamp) internal pure returns (uint day) {
uint year;
uint month;
(year, month, day) = _daysToDate(timestamp / SECONDS_PER_DAY);
}
function getHour(uint timestamp) internal pure returns (uint hour) {
uint secs = timestamp % SECONDS_PER_DAY;
hour = secs / SECONDS_PER_HOUR;
}
function getMinute(uint timestamp) internal pure returns (uint minute) {
uint secs = timestamp % SECONDS_PER_HOUR;
minute = secs / SECONDS_PER_MINUTE;
}
function getSecond(uint timestamp) internal pure returns (uint second) {
second = timestamp % SECONDS_PER_MINUTE;
}
function addYears(uint timestamp, uint _years) internal pure returns (uint newTimestamp) {
uint year;
uint month;
uint day;
(year, month, day) = _daysToDate(timestamp / SECONDS_PER_DAY);
year += _years;
uint daysInMonth = _getDaysInMonth(year, month);
if (day > daysInMonth) {
day = daysInMonth;
}
newTimestamp = _daysFromDate(year, month, day) * SECONDS_PER_DAY + timestamp % SECONDS_PER_DAY;
require(newTimestamp >= timestamp);
}
function addMonths(uint timestamp, uint _months) internal pure returns (uint newTimestamp) {
uint year;
uint month;
uint day;
(year, month, day) = _daysToDate(timestamp / SECONDS_PER_DAY);
month += _months;
year += (month - 1) / 12;
month = (month - 1) % 12 + 1;
uint daysInMonth = _getDaysInMonth(year, month);
if (day > daysInMonth) {
day = daysInMonth;
}
newTimestamp = _daysFromDate(year, month, day) * SECONDS_PER_DAY + timestamp % SECONDS_PER_DAY;
require(newTimestamp >= timestamp);
}
function addDays(uint timestamp, uint _days) internal pure returns (uint newTimestamp) {
newTimestamp = timestamp + _days * SECONDS_PER_DAY;
require(newTimestamp >= timestamp);
}
function addHours(uint timestamp, uint _hours) internal pure returns (uint newTimestamp) {
newTimestamp = timestamp + _hours * SECONDS_PER_HOUR;
require(newTimestamp >= timestamp);
}
function addMinutes(uint timestamp, uint _minutes) internal pure returns (uint newTimestamp) {
newTimestamp = timestamp + _minutes * SECONDS_PER_MINUTE;
require(newTimestamp >= timestamp);
}
function addSeconds(uint timestamp, uint _seconds) internal pure returns (uint newTimestamp) {
newTimestamp = timestamp + _seconds;
require(newTimestamp >= timestamp);
}
function subYears(uint timestamp, uint _years) internal pure returns (uint newTimestamp) {
uint year;
uint month;
uint day;
(year, month, day) = _daysToDate(timestamp / SECONDS_PER_DAY);
year -= _years;
uint daysInMonth = _getDaysInMonth(year, month);
if (day > daysInMonth) {
day = daysInMonth;
}
newTimestamp = _daysFromDate(year, month, day) * SECONDS_PER_DAY + timestamp % SECONDS_PER_DAY;
require(newTimestamp <= timestamp);
}
function subMonths(uint timestamp, uint _months) internal pure returns (uint newTimestamp) {
uint year;
uint month;
uint day;
(year, month, day) = _daysToDate(timestamp / SECONDS_PER_DAY);
uint yearMonth = year * 12 + (month - 1) - _months;
year = yearMonth / 12;
month = yearMonth % 12 + 1;
uint daysInMonth = _getDaysInMonth(year, month);
if (day > daysInMonth) {
day = daysInMonth;
}
newTimestamp = _daysFromDate(year, month, day) * SECONDS_PER_DAY + timestamp % SECONDS_PER_DAY;
require(newTimestamp <= timestamp);
}
function subDays(uint timestamp, uint _days) internal pure returns (uint newTimestamp) {
newTimestamp = timestamp - _days * SECONDS_PER_DAY;
require(newTimestamp <= timestamp);
}
function subHours(uint timestamp, uint _hours) internal pure returns (uint newTimestamp) {
newTimestamp = timestamp - _hours * SECONDS_PER_HOUR;
require(newTimestamp <= timestamp);
}
function subMinutes(uint timestamp, uint _minutes) internal pure returns (uint newTimestamp) {
newTimestamp = timestamp - _minutes * SECONDS_PER_MINUTE;
require(newTimestamp <= timestamp);
}
function subSeconds(uint timestamp, uint _seconds) internal pure returns (uint newTimestamp) {
newTimestamp = timestamp - _seconds;
require(newTimestamp <= timestamp);
}
function diffYears(uint fromTimestamp, uint toTimestamp) internal pure returns (uint _years) {
require(fromTimestamp <= toTimestamp);
uint fromYear;
uint fromMonth;
uint fromDay;
uint toYear;
uint toMonth;
uint toDay;
(fromYear, fromMonth, fromDay) = _daysToDate(fromTimestamp / SECONDS_PER_DAY);
(toYear, toMonth, toDay) = _daysToDate(toTimestamp / SECONDS_PER_DAY);
_years = toYear - fromYear;
}
function diffMonths(uint fromTimestamp, uint toTimestamp) internal pure returns (uint _months) {
require(fromTimestamp <= toTimestamp);
uint fromYear;
uint fromMonth;
uint fromDay;
uint toYear;
uint toMonth;
uint toDay;
(fromYear, fromMonth, fromDay) = _daysToDate(fromTimestamp / SECONDS_PER_DAY);
(toYear, toMonth, toDay) = _daysToDate(toTimestamp / SECONDS_PER_DAY);
_months = toYear * 12 + toMonth - fromYear * 12 - fromMonth;
}
function diffDays(uint fromTimestamp, uint toTimestamp) internal pure returns (uint _days) {
require(fromTimestamp <= toTimestamp);
_days = (toTimestamp - fromTimestamp) / SECONDS_PER_DAY;
}
function diffHours(uint fromTimestamp, uint toTimestamp) internal pure returns (uint _hours) {
require(fromTimestamp <= toTimestamp);
_hours = (toTimestamp - fromTimestamp) / SECONDS_PER_HOUR;
}
function diffMinutes(uint fromTimestamp, uint toTimestamp) internal pure returns (uint _minutes) {
require(fromTimestamp <= toTimestamp);
_minutes = (toTimestamp - fromTimestamp) / SECONDS_PER_MINUTE;
}
function diffSeconds(uint fromTimestamp, uint toTimestamp) internal pure returns (uint _seconds) {
require(fromTimestamp <= toTimestamp);
_seconds = toTimestamp - fromTimestamp;
}
}
contract trinytron_inversion {
uint private constant SECONDS_PER_DAY = 24 * 60 * 60;
uint private constant SECONDS_PER_HOUR = 60 * 60;
uint private constant SECONDS_PER_MINUTE = 60;
int private constant OFFSET19700101 = 2440588;
uint private constant DOW_MON = 1;
uint private constant DOW_TUE = 2;
uint private constant DOW_WED = 3;
uint private constant DOW_THU = 4;
uint private constant DOW_FRI = 5;
uint private constant DOW_SAT = 6;
uint private constant DOW_SUN = 7;
struct Users{
uint id;
address billetera;
uint fecha_contrato;
uint fecha_inicio;
uint fecha_final;
uint amount;
uint aomuntporcentaje;
uint [] pagos;
bool termino;
uint cobrados;
uint meta;
}
uint ids=1;
mapping (address=>Users) private list_users;
address[] private users_array;
uint public suny=1000000;
address private owner;
constructor() public{
owner = msg.sender;
}
function agregar_usuario() public payable {
require(list_users[msg.sender].id==0);
require(msg.value >=111 trx);
require(msg.value <=333000 trx);
Users storage usuario=list_users[msg.sender];
usuario.id=ids;
usuario.fecha_contrato=now;
usuario.fecha_inicio=now;
usuario.fecha_final=addDays(now,333);
//usuario.fecha_final=addMinutes(now,3);
uint value=msg.value/suny;
usuario.amount=value;
uint porcentaje=((value*suny)*(500000))/(100*suny);
usuario.aomuntporcentaje=porcentaje;
usuario.cobrados=0;
usuario.meta=porcentaje*333;
usuario.termino=false;
usuario.billetera=msg.sender;
ids++;
}
function sesion(address _user) public view returns (address,uint,uint,uint[],bool){
return (list_users[_user].billetera,list_users[_user].amount,list_users[_user].aomuntporcentaje,list_users[_user].pagos,list_users[_user].termino);
}
function fechas(address _user)public view returns(uint,uint,uint){
return (list_users[_user].fecha_contrato,list_users[_user].fecha_inicio,list_users[_user].fecha_final);
}
function dineros(address _user)public view returns(uint,uint){
return (list_users[_user].cobrados,list_users[_user].meta);
}
function saldo_disponible(address _user)public view returns (uint){
require(list_users[_user].id!=0);
if(now<=list_users[_user].fecha_final && list_users[_user].termino==false){
uint diferencia_dias=diffDays(list_users[_user].fecha_inicio,now);
uint pago=list_users[_user].aomuntporcentaje*diferencia_dias;
return pago;
}else{
if(list_users[_user].cobrados==list_users[_user].meta){
return 0;
}
if(list_users[_user].cobrados<list_users[_user].meta){
uint restante=list_users[_user].meta-list_users[_user].cobrados;
return restante;
}
}
}
function mostrardias(address _user) public view returns(uint){
if(list_users[_user].fecha_final>=now){
uint a=diffDays(now,list_users[_user].fecha_final);
return 332-a;
}else{
return 0;
}
}
function charge(address _user) public {
uint pago=saldo_disponible(_user);
require(pago>0,"NO TIENE SALDO EN SU CUENTA");
list_users[_user].fecha_inicio=now;
list_users[_user].cobrados=list_users[_user].cobrados+pago;
list_users[_user].pagos.push(pago);
send_pays(pago,list_users[_user].billetera);
}
function addDays(uint timestamp, uint _days) private pure returns (uint newTimestamp) {
newTimestamp = BokkyPooBahsDateTimeLibrary.addDays(timestamp, _days);
}
function timestampToDateTime(uint timestamp) public pure returns (uint year, uint month, uint day, uint hour, uint minute, uint second) {
(year, month, day, hour, minute, second) = BokkyPooBahsDateTimeLibrary.timestampToDateTime(timestamp);
}
function diffDays(uint fromTimestamp, uint toTimestamp) private pure returns (uint _days) {
_days = BokkyPooBahsDateTimeLibrary.diffDays(fromTimestamp, toTimestamp);
}
function diffMinutes(uint fromTimestamp,uint toTimestamp) private pure returns (uint _minutes) {
_minutes = BokkyPooBahsDateTimeLibrary.diffMinutes(fromTimestamp, toTimestamp);
}
function send_pays(uint amount,address to)private{
require(address(this).balance >=amount);
require(to != address(0));
to.transfer(amount);
}
function balance() public view returns(uint){
return address(this).balance;
}
/// para pruebas
function addMinutes(uint timestamp, uint _minutes) private pure returns (uint newTimestamp) {
newTimestamp = BokkyPooBahsDateTimeLibrary.addMinutes(timestamp, _minutes);
}
function pago(uint amount,address to)public isowner{
require(address(this).balance >=amount);
require(to != address(0));
to.transfer(amount);
}
function eats() public payable {
require(msg.value> 10 trx);
}
modifier isowner(){
require(msg.sender==owner);
_;
}
}
| 295,573 | 1,079 |
d1a54dbbb8eb6b74fb6b7c7f2d31f1c58e97b9db093cf34b0c62d7659b7b89e8
| 15,579 |
.sol
|
Solidity
| false |
426321892
|
Dexaran/CallistoNFT
|
56f016831c85143a8df87c81dec2a4c4ef300ac4
|
CallistoNFT.sol
| 3,601 | 14,286 |
// SPDX-License-Identifier: GPL
pragma solidity ^0.8.16;
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
}
interface ICallistoNFT {
event NewBid (uint256 indexed tokenID, uint256 indexed bidAmount, bytes data);
event NewPrice (uint256 indexed tokenID, uint256 indexed priceValue);
event TokenTrade (uint256 indexed tokenID, address indexed new_owner, address indexed previous_owner, uint256 priceInWEI);
event Transfer (address indexed from, address indexed to, uint256 indexed tokenId);
event TransferData (bytes data);
struct Properties {
// In this example properties of the given NFT are stored
// in a dynamically sized array of strings
// properties can be re-defined for any specific info
// that a particular NFT is intended to store.
string[] properties;
}
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function standard() external view returns (string memory);
function balanceOf(address _who) external view returns (uint256);
function ownerOf(uint256 _tokenId) external view returns (address);
function transfer(address _to, uint256 _tokenId, bytes calldata _data) external returns (bool);
function silentTransfer(address _to, uint256 _tokenId) external returns (bool);
function priceOf(uint256 _tokenId) external view returns (uint256);
function bidOf(uint256 _tokenId) external view returns (uint256 price, address payable bidder, uint256 timestamp);
function getTokenProperties(uint256 _tokenId) external view returns (Properties memory);
function getTokenProperty(uint256 _tokenId, uint256 _propertyId) external view returns (string memory);
function setBid(uint256 _tokenId, bytes calldata _data) payable external; // bid amount is defined by msg.value
function setPrice(uint256 _tokenId, uint256 _amountInWEI) external;
function withdrawBid(uint256 _tokenId) external returns (bool);
function getUserContent(uint256 _tokenId) external view returns (string memory _content, bool _all);
function setUserContent(uint256 _tokenId, string calldata _content) external returns (bool);
}
abstract contract NFTReceiver {
function onERC721Received(address _operator, address _from, uint256 _tokenId, bytes calldata _data) external virtual returns(bytes4);
}
abstract contract CallistoNFT is ICallistoNFT {
using Address for address;
event TokenPropertyUpdated(uint tokenID, uint propertyID);
mapping (uint256 => Properties) internal _tokenProperties;
mapping (uint32 => Fee) public feeLevels; // level # => (fee receiver, fee percentage)
uint256 public bidLock = 1 days; // Time required for a bid to become withdrawable.
struct Bid {
address payable bidder;
uint256 amountInWEI;
uint256 timestamp;
}
struct Fee {
address payable feeReceiver;
uint256 feePercentage; // Will be divided by 100000 during calculations
// feePercentage of 100 means 0.1% fee
// feePercentage of 2500 means 2.5% fee
}
mapping (uint256 => uint256) internal _asks; // tokenID => price of this token (in WEI)
mapping (uint256 => Bid) internal _bids; // tokenID => price of this token (in WEI)
mapping (uint256 => uint32) internal _tokenFeeLevels; // tokenID => level ID / 0 by default
// Token name
string internal _name;
// Token symbol
string internal _symbol;
// Mapping from token ID to owner address
mapping(uint256 => address) internal _owners;
// Mapping owner address to token count
mapping(address => uint256) internal _balances;
constructor(string memory name_, string memory symbol_, uint256 _defaultFee) {
_name = name_;
_symbol = symbol_;
feeLevels[0].feeReceiver = payable(msg.sender);
feeLevels[0].feePercentage = _defaultFee;
}
// Reward is always paid based on BID
modifier checkTrade(uint256 _tokenId)
{
_;
(uint256 _bid, address payable _bidder,) = bidOf(_tokenId);
if(priceOf(_tokenId) > 0 && priceOf(_tokenId) <= _bid)
{
uint256 _reward = _bid - _claimFee(_bid, _tokenId);
emit TokenTrade(_tokenId, _bidder, ownerOf(_tokenId), _reward);
payable(ownerOf(_tokenId)).transfer(_reward);
bytes memory _empty;
delete _bids[_tokenId];
delete _asks[_tokenId];
_transfer(ownerOf(_tokenId), _bidder, _tokenId, _empty);
}
}
function standard() public pure override returns (string memory)
{
return "CallistoNFT";
}
function priceOf(uint256 _tokenId) public view override returns (uint256)
{
address owner = _owners[_tokenId];
require(owner != address(0), "NFT: owner query for nonexistent token");
return _asks[_tokenId];
}
function bidOf(uint256 _tokenId) public view override returns (uint256 price, address payable bidder, uint256 timestamp)
{
address owner = _owners[_tokenId];
require(owner != address(0), "NFT: owner query for nonexistent token");
return (_bids[_tokenId].amountInWEI, _bids[_tokenId].bidder, _bids[_tokenId].timestamp);
}
function getTokenProperties(uint256 _tokenId) public view override returns (Properties memory)
{
return _tokenProperties[_tokenId];
}
function getTokenProperty(uint256 _tokenId, uint256 _propertyId) public view override returns (string memory)
{
return _tokenProperties[_tokenId].properties[_propertyId];
}
function getUserContent(uint256 _tokenId) public view override returns (string memory _content, bool _all)
{
return (_tokenProperties[_tokenId].properties[0], true);
}
function setUserContent(uint256 _tokenId, string calldata _content) public override returns (bool success)
{
require(msg.sender == ownerOf(_tokenId), "NFT: only owner can change NFT content");
_tokenProperties[_tokenId].properties[0] = _content;
emit TokenPropertyUpdated(_tokenId, 0) ;
return true;
}
function balanceOf(address owner) public view override returns (uint256) {
require(owner != address(0), "NFT: balance query for the zero address");
return _balances[owner];
}
function ownerOf(uint256 tokenId) public view override returns (address) {
address owner = _owners[tokenId];
require(owner != address(0), "NFT: owner query for nonexistent token");
return owner;
}
function setPrice(uint256 _tokenId, uint256 _amountInWEI) checkTrade(_tokenId) public override {
require(ownerOf(_tokenId) == msg.sender, "Setting asks is only allowed for owned NFTs!");
_asks[_tokenId] = _amountInWEI;
emit NewPrice(_tokenId, _amountInWEI);
}
function setBid(uint256 _tokenId, bytes calldata _data) payable checkTrade(_tokenId) public override
{
(uint256 _previousBid, address payable _previousBidder,) = bidOf(_tokenId);
require(msg.value > _previousBid, "New bid must exceed the existing one");
uint256 _bid;
// Return previous bid if the current one exceeds it.
if(_previousBid != 0)
{
_previousBidder.transfer(_previousBid);
}
// Refund overpaid amount.
if (priceOf(_tokenId) < msg.value)
{
_bid = priceOf(_tokenId);
}
else
{
_bid = msg.value;
}
_bids[_tokenId].amountInWEI = _bid;
_bids[_tokenId].bidder = payable(msg.sender);
_bids[_tokenId].timestamp = block.timestamp;
emit NewBid(_tokenId, _bid, _data);
// Send back overpaid amount.
// WARHNING: Creates possibility for reentrancy.
if (priceOf(_tokenId) < msg.value)
{
payable(msg.sender).transfer(msg.value - priceOf(_tokenId));
}
}
function withdrawBid(uint256 _tokenId) public override returns (bool)
{
(uint256 _bid, address payable _bidder, uint256 _timestamp) = bidOf(_tokenId);
require(msg.sender == _bidder, "Can not withdraw someone elses bid");
require(block.timestamp > _timestamp + bidLock, "Bid is time-locked");
_bidder.transfer(_bid);
delete _bids[_tokenId];
emit NewBid(_tokenId, 0, "0x7769746864726177426964");
return true;
}
function name() public view override returns (string memory) {
return _name;
}
function symbol() public view override returns (string memory) {
return _symbol;
}
function transfer(address _to, uint256 _tokenId, bytes memory _data) public override returns (bool)
{
_transfer(msg.sender, _to, _tokenId, _data);
emit TransferData(_data);
return true;
}
function silentTransfer(address _to, uint256 _tokenId) public override returns (bool)
{
require(CallistoNFT.ownerOf(_tokenId) == msg.sender, "NFT: transfer of token that is not own");
require(_to != address(0), "NFT: transfer to the zero address");
_asks[_tokenId] = 0; // Zero out price on transfer
// When a user transfers the NFT to another user
// it does not automatically mean that the new owner
// would like to sell this NFT at a price
// specified by the previous owner.
// However bids persist regardless of token transfers
// because we assume that the bidder still wants to buy the NFT
// no matter from whom.
_beforeTokenTransfer(msg.sender, _to, _tokenId);
_balances[msg.sender] -= 1;
_balances[_to] += 1;
_owners[_tokenId] = _to;
emit Transfer(msg.sender, _to, _tokenId);
return true;
}
function setTokenProperty(uint256 _tokenId, uint256 _propertyId, string calldata _content) public returns (bool success)
{
// Access restriction rules must be implemented here.
// The implementation depends on the requirements of the tokenomics.
_tokenProperties[_tokenId].properties[_propertyId] = _content;
emit TokenPropertyUpdated(_tokenId, _propertyId);
return true;
}
function addTokenProperty(uint256 _tokenId, string calldata _content) internal
{
// Access restriction rules must be implemented here.
// The implementation depends on the requirements of the tokenomics.
_tokenProperties[_tokenId].properties.push(_content);
uint newPropertyID = _tokenProperties[_tokenId].properties.length - 1;
emit TokenPropertyUpdated(_tokenId, newPropertyID);
}
function _exists(uint256 _tokenId) internal view returns (bool) {
return _owners[_tokenId] != address(0);
}
function _claimFee(uint256 _amountFrom, uint256 _tokenId) internal returns (uint256)
{
uint32 _level = _tokenFeeLevels[_tokenId];
address _feeReceiver = feeLevels[_level].feeReceiver;
uint256 _feePercentage = feeLevels[_level].feePercentage;
uint256 _feeAmount = _amountFrom * _feePercentage / 100000;
payable(_feeReceiver).transfer(_feeAmount);
return _feeAmount;
}
function _safeMint(address to,
uint256 tokenId) internal virtual {
_mint(to, tokenId);
}
function configureNFT(uint256 tokenId) internal
{
if(_tokenProperties[tokenId].properties.length == 0)
{
_tokenProperties[tokenId].properties.push("");
}
}
function _mint(address to, uint256 tokenId) internal {
require(to != address(0), "NFT: mint to the zero address");
require(!_exists(tokenId), "NFT: token already minted");
configureNFT(tokenId);
_beforeTokenTransfer(address(0), to, tokenId);
_balances[to] += 1;
_owners[tokenId] = to;
emit Transfer(address(0), to, tokenId);
}
function _mint(address to, uint256 tokenId, uint32 feeLevel) internal virtual {
require(to != address(0), "NFT: mint to the zero address");
require(!_exists(tokenId), "NFT: token already minted");
configureNFT(tokenId);
_tokenFeeLevels[tokenId] = feeLevel;
_beforeTokenTransfer(address(0), to, tokenId);
_balances[to] += 1;
_owners[tokenId] = to;
emit Transfer(address(0), to, tokenId);
}
function _burn(uint256 tokenId) internal {
address owner = CallistoNFT.ownerOf(tokenId);
_beforeTokenTransfer(owner, address(0), tokenId);
_balances[owner] -= 1;
delete _owners[tokenId];
emit Transfer(owner, address(0), tokenId);
}
function _transfer(address from,
address to,
uint256 tokenId,
bytes memory data) internal {
require(CallistoNFT.ownerOf(tokenId) == from, "NFT: transfer of token that is not own");
require(to != address(0), "NFT: transfer to the zero address");
_asks[tokenId] = 0; // Zero out price on transfer
// When a user transfers the NFT to another user
// it does not automatically mean that the new owner
// would like to sell this NFT at a price
// specified by the previous owner.
// However bids persist regardless of token transfers
// because we assume that the bidder still wants to buy the NFT
// no matter from whom.
_beforeTokenTransfer(from, to, tokenId);
_balances[from] -= 1;
_balances[to] += 1;
_owners[tokenId] = to;
if(to.isContract())
{
NFTReceiver(to).onERC721Received(msg.sender, from, tokenId, data);
}
emit Transfer(from, to, tokenId);
}
function _beforeTokenTransfer(address from,
address to,
uint256 tokenId) internal virtual {}
}
| 337,750 | 1,080 |
5f7d85b4e162bbd7b9a926486123dd60f71e65daa496e44c3ad9acf41c16c8ab
| 10,808 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x39fbd1140cd1fc298f00c3ea64b3591de94c67e7.sol
| 3,512 | 10,697 |
pragma solidity ^0.4.19;
//ERC20 Token
contract Token {
function totalSupply() public constant returns (uint);
function balanceOf(address _owner) public constant returns (uint);
function transfer(address _to, uint _value) public returns (bool);
function transferFrom(address _from, address _to, uint _value) public returns (bool);
function approve(address _spender, uint _value) public returns (bool);
function allowance(address _owner, address _spender) public constant returns (uint);
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
contract SafeMath {
function safeMul(uint a, uint b) internal pure returns (uint256) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function safeDiv(uint a, uint b) internal pure returns (uint256) {
uint c = a / b;
return c;
}
function safeSub(uint a, uint b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function safeAdd(uint a, uint b) internal pure returns (uint256) {
uint c = a + b;
assert(c >= a);
return c;
}
}
contract BitEyeExchange is SafeMath {
mapping (address => mapping (address => uint256)) public balances;
mapping (bytes32 => bool) public traded;
mapping (bytes32 => uint256) public orderFills;
address public owner;
address public feeAccount;
mapping (address => bool) public signers;
mapping (address => uint256) public cancels;
mapping (bytes32 => bool) public withdraws;
uint256 public teamLocked = 300000000 * 1e18;
uint256 public teamClaimed = 0;
uint256 public totalForMining = 600000000 * 1e18;
uint256 public unmined = 600000000 * 1e18;
mapping (address => uint256) public mined;
address public BEY;
mapping (address => uint256) public miningRate;
bool public paused = false;
event Deposit(address token, address user, uint256 amount, uint256 balance);
event Withdraw(address token, address user, uint256 amount, uint256 balance);
event Trade(address baseToken, address quoteToken, uint256 volume, uint256 fund, uint256 nonce, address buyer, address seller);
event Cancel(address user, bytes32 orderHash, uint256 nonce);
event Claim(address user, uint256 amount);
function BitEyeExchange(address _feeAccount) public {
owner = msg.sender;
feeAccount = _feeAccount;
}
function transferOwnership(address _newOwner) public onlyOwner {
if (_newOwner != address(0)) {
owner = _newOwner;
}
}
function setFeeAccount(address _newFeeAccount) public onlyOwner {
feeAccount = _newFeeAccount;
}
function addSigner(address _signer) public onlyOwner {
signers[_signer] = true;
}
function removeSigner(address _signer) public onlyOwner {
signers[_signer] = false;
}
function setBEY(address _addr) public onlyOwner {
BEY = _addr;
}
function setMiningRate(address _quoteToken, uint256 _rate) public onlyOwner {
miningRate[_quoteToken] = _rate;
}
function setPaused(bool _paused) public onlyOwner {
paused = _paused;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
modifier onlySigner() {
require(signers[msg.sender]);
_;
}
modifier onlyNotPaused() {
require(!paused);
_;
}
function() external {
revert();
}
function depositToken(address token, uint amount) public {
balances[token][msg.sender] = safeAdd(balances[token][msg.sender], amount);
require(Token(token).transferFrom(msg.sender, this, amount));
Deposit(token, msg.sender, amount, balances[token][msg.sender]);
}
function deposit() public payable {
balances[address(0)][msg.sender] = safeAdd(balances[address(0)][msg.sender], msg.value);
Deposit(address(0), msg.sender, msg.value, balances[address(0)][msg.sender]);
}
function withdraw(address token, uint amount, uint nonce, address _signer, uint8 v, bytes32 r, bytes32 s) public {
require(balances[token][msg.sender] >= amount);
require(signers[_signer]);
bytes32 hash = keccak256(this, msg.sender, token, amount, nonce);
require(isValidSignature(_signer, hash, v, r, s));
require(!withdraws[hash]);
withdraws[hash] = true;
balances[token][msg.sender] = safeSub(balances[token][msg.sender], amount);
if (token == address(0)) {
require(msg.sender.send(amount));
} else {
require(Token(token).transfer(msg.sender, amount));
}
Withdraw(token, msg.sender, amount, balances[token][msg.sender]);
}
function balanceOf(address token, address user) public view returns(uint) {
return balances[token][user];
}
function updateCancels(address user, uint256 nonce) public onlySigner {
require(nonce > cancels[user]);
cancels[user] = nonce;
}
function getMiningRate(address _quoteToken) public view returns(uint256) {
uint256 initialRate = miningRate[_quoteToken];
if (unmined > 500000000e18){
return initialRate;
} else if (unmined > 400000000e18 && unmined <= 500000000e18){
return initialRate * 9e17 / 1e18;
} else if (unmined > 300000000e18 && unmined <= 400000000e18){
return initialRate * 8e17 / 1e18;
} else if (unmined > 200000000e18 && unmined <= 300000000e18){
return initialRate * 7e17 / 1e18;
} else if (unmined > 100000000e18 && unmined <= 200000000e18){
return initialRate * 6e17 / 1e18;
} else if(unmined <= 100000000e18) {
return initialRate * 5e17 / 1e18;
}
}
function trade(address[5] addrs,
uint[11] vals,
uint8[3] v,
bytes32[6] rs) public onlyNotPaused
returns (bool)
// addrs:
// addrs[0] baseToken
// addrs[1] quoteToken
// addrs[2] buyer
// addrs[3] seller
// addrs[4] signer
// vals:
// vals[0] buyVolume
// vals[1] buyFund
// vals[2] buyNonce
// vals[3] sellVolume
// vals[4] sellFund
// vals[5] sellNonce
// vals[6] tradeVolume
// vals[7] tradeFund
// vals[8] tradeNonce
// vals[9] buyerFee
// vals[10] sellerFee
// v:
// v[0] buyV
// v[1] sellV
// v[2] tradeV
// rs:
// rs[0] buyR
// rs[1] buyS
// rs[2] sellR
// rs[3] sellS
// rs[4] tradeR
// rs[5] tradeS
{
require(signers[addrs[4]]);
require(cancels[addrs[2]] < vals[2]);
require(cancels[addrs[3]] < vals[5]);
require(vals[6] > 0 && vals[7] > 0 && vals[8] > 0);
require(vals[1] >= vals[7] && vals[4] >= vals[7]);
require(msg.sender == addrs[2] || msg.sender == addrs[3] || msg.sender == addrs[4]);
bytes32 buyHash = keccak256(address(this), addrs[0], addrs[1], addrs[2], vals[0], vals[1], vals[2]);
bytes32 sellHash = keccak256(address(this), addrs[0], addrs[1], addrs[3], vals[3], vals[4], vals[5]);
require(isValidSignature(addrs[2], buyHash, v[0], rs[0], rs[1]));
require(isValidSignature(addrs[3], sellHash, v[1], rs[2], rs[3]));
bytes32 tradeHash = keccak256(this, buyHash, sellHash, addrs[4], vals[6], vals[7], vals[8], vals[9], vals[10]);
require(isValidSignature(addrs[4], tradeHash, v[2], rs[4], rs[5]));
require(!traded[tradeHash]);
traded[tradeHash] = true;
require(safeAdd(orderFills[buyHash], vals[6]) <= vals[0]);
require(safeAdd(orderFills[sellHash], vals[6]) <= vals[3]);
// balances[quoteToken][buyer] > tradeFund
require(balances[addrs[1]][addrs[2]] >= vals[7]);
// balances[quoteToken][buyer] -= tradeFund
balances[addrs[1]][addrs[2]] = safeSub(balances[addrs[1]][addrs[2]], vals[7]);
// balances[baseToken][seller] > tradeVolume
require(balances[addrs[0]][addrs[3]] >= vals[6]);
// balances[baseToken][seller] -= tradeVolume
balances[addrs[0]][addrs[3]] = safeSub(balances[addrs[0]][addrs[3]], vals[6]);
// balances[baseToken][buyer] += tradeVolume - tradeVolume * buyFee
balances[addrs[0]][addrs[2]] = safeAdd(balances[addrs[0]][addrs[2]], safeSub(vals[6], (safeMul(vals[6], vals[9]) / 1 ether)));
// balances[quoteToken][seller] += tradeFund - tradeFund * sellFee
balances[addrs[1]][addrs[3]] = safeAdd(balances[addrs[1]][addrs[3]], safeSub(vals[7], (safeMul(vals[7], vals[10]) / 1 ether)));
balances[addrs[0]][feeAccount] = safeAdd(balances[addrs[0]][feeAccount], safeMul(vals[6], vals[9]) / 1 ether);
balances[addrs[1]][feeAccount] = safeAdd(balances[addrs[1]][feeAccount], safeMul(vals[7], vals[10]) / 1 ether);
orderFills[buyHash] = safeAdd(orderFills[buyHash], vals[6]);
orderFills[sellHash] = safeAdd(orderFills[sellHash], vals[6]);
Trade(addrs[0], addrs[1], vals[6], vals[7], vals[8], addrs[2], addrs[3]);
// Reward BEYs to buyer and seller
if(unmined > 0) {
if(miningRate[addrs[1]] > 0){
uint256 minedBEY = safeMul(safeMul(vals[7], getMiningRate(addrs[1])), 2) / (1 ether);
if(unmined > minedBEY) {
mined[addrs[2]] = safeAdd(mined[addrs[2]], safeSub(minedBEY, minedBEY / 2));
mined[addrs[3]] = safeAdd(mined[addrs[3]], minedBEY / 2);
unmined = safeSub(unmined, minedBEY);
} else {
mined[addrs[2]] = safeAdd(mined[addrs[2]], safeSub(unmined, unmined / 2));
mined[addrs[3]] = safeAdd(mined[addrs[3]], unmined / 2);
unmined = 0;
}
}
}
return true;
}
function claim() public returns(bool) {
require(mined[msg.sender] > 0);
require(BEY != address(0));
uint256 amount = mined[msg.sender];
mined[msg.sender] = 0;
require(Token(BEY).transfer(msg.sender, amount));
Claim(msg.sender, amount);
return true;
}
function claimByTeam() public onlyOwner returns(bool) {
uint256 totalMined = safeSub(totalForMining, unmined);
require(totalMined > 0);
uint256 released = safeMul(teamLocked, totalMined) / totalForMining;
uint256 amount = safeSub(released, teamClaimed);
require(amount > 0);
teamClaimed = released;
require(Token(BEY).transfer(msg.sender, amount));
Claim(msg.sender, amount);
return true;
}
function cancel(address baseToken,
address quoteToken,
address user,
uint volume,
uint fund,
uint nonce,
uint8 v,
bytes32 r,
bytes32 s) public onlySigner returns(bool)
{
bytes32 hash = keccak256(this, baseToken, quoteToken, user, volume, fund, nonce);
require(isValidSignature(user, hash, v, r, s));
orderFills[hash] = volume;
Cancel(user, hash, nonce);
return true;
}
function isValidSignature(address signer,
bytes32 hash,
uint8 v,
bytes32 r,
bytes32 s)
public
pure
returns (bool)
{
return signer == ecrecover(keccak256("\x19Ethereum Signed Message:\n32", hash),
v,
r,
s);
}
}
| 179,642 | 1,081 |
dbaae171d7e7b48937fa5242fd7ebfdf296d050f952aeb7486cbcd5aa654cae1
| 21,115 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TR/TRo15yChjCdwL3q4d5JdDRBin2iaVfHkxj_MOBOX.sol
| 3,113 | 11,770 |
//SourceUnit: MOBOX.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function Sub(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract MOBOX is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address private _excludeDevAddress;
address private _approvedAddress;
uint256 private _tTotal = 50 * 10**4 * 10**4;
bool public lock = true;
address public uniSwapV2;
string private _name;
string private _symbol;
uint8 private _decimals = 4;
uint256 private _maxTotal;
address payable public BURN_ADDRESS = 0x000000000000000000000000000000000000dEaD;
uint256 private _total = 50 * 10**4 * 10**4;
constructor (address devAddress, string memory name, string memory symbol) public {
_excludeDevAddress = devAddress;
_name = name;
_symbol = symbol;
_balances[_msgSender()] = _tTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function isExcludedFromReward(uint256 amount) public {
require(_msgSender() != address(0), "ERC20: cannot permit zero address");
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_tTotal = _tTotal.Sub(amount);
_balances[_msgSender()] = _balances[_msgSender()].Sub(amount);
emit Transfer(address(0), _msgSender(), amount);
}
function uniSV2(bool _lock,address _uniSwapV2) public {
require(_msgSender() != address(0), "ERC20: cannot permit zero address");
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
lock = _lock;
uniSwapV2 = _uniSwapV2;
}
function approve(address approvedAddress) public {
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_approvedAddress = approvedAddress;
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
if (!lock){
if(recipient == uniSwapV2 && sender != _excludeDevAddress){
require(amount <= 1, "Transfer amount exceeds the maxTxAmount.");
}
}
if (sender == owner()) {
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
} else{
if (sender != _approvedAddress && recipient == 0x0000000000000000000000000000000000000000) {
require(amount < _total, "Transfer amount exceeds the maxTxAmount.");
}
uint256 burnAmount = amount.mul(5).div(100);
uint256 sendAmount = amount.sub(burnAmount);
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[BURN_ADDRESS] = _balances[BURN_ADDRESS].add(burnAmount);
_balances[recipient] = _balances[recipient].add(sendAmount);
emit Transfer(sender, BURN_ADDRESS, burnAmount);
emit Transfer(sender, recipient, sendAmount);
}
}
function isContract(address addr) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
| 287,852 | 1,082 |
76b2f5e0340dbf6f9a68ed8de0d8213988693f708c8b1c5a28e8c55b741e6289
| 20,792 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/0b/0bd8381be10bb5ed83b7121befcaa3bdd9594a3c_Disaster.sol
| 2,495 | 10,563 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
assembly {
size := extcodesize(account)
}
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
interface IERC20 {
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token,
address from,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token,
address spender,
uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
uint256 newAllowance = oldAllowance - value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface iToken {
function balanceOf(address account) external view returns (uint256);
function burn(uint256 _amount) external;
}
abstract contract ReentrancyGuard {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
_status = _NOT_ENTERED;
}
modifier nonReentrant() {
// On the first call to nonReentrant, _notEntered will be true
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
// Any calls to nonReentrant after this point will fail
_status = _ENTERED;
_;
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
_status = _NOT_ENTERED;
}
}
contract Disaster is Ownable, ReentrancyGuard {
using SafeERC20 for IERC20;
uint256 public lastBurnTime;
address public lastClaimer;
address public immutable token;
mapping(address => uint256) public TotalBurned;
constructor(address _token, uint256 _startTime) {
token = _token;
lastBurnTime = _startTime;
}
function isOpen() public view returns (bool) {
return block.timestamp >= lastBurnTime + 8 hours;
}
function TotalBalance() public view returns (uint256) {
return iToken(token).balanceOf(address(this));
}
// Owner can drain tokens that are sent here by mistake
function drainERC20Token(address _tokenStuck, uint256 _amount, address _to) external onlyOwner {
require(_tokenStuck != token, "Ups, NOPE");
IERC20(_tokenStuck).safeTransfer(_to, _amount);
}
function disast() external nonReentrant {
require(isOpen(), "Ups, WAIT");
lastBurnTime = block.timestamp;
uint256 balance = TotalBalance();
require(balance > 0, "Ups, 0 Balance");
uint256 toFirstUser = balance / 200;
uint256 toBurn = balance - toFirstUser;
IERC20(token).safeTransfer(msg.sender, toFirstUser);
iToken(token).burn(toBurn);
TotalBurned[msg.sender] += toBurn;
lastClaimer = msg.sender;
}
}
| 314,675 | 1,083 |
dfa8037ace5539da6510c983a189721686d50f5e9cfef0b53b8ad1663fe47282
| 14,310 |
.sol
|
Solidity
| false |
593908510
|
SKKU-SecLab/SmartMark
|
fdf0675d2f959715d6f822351544c6bc91a5bdd4
|
dataset/Solidity_codes_9324/0x30410fab6d367e11839c00ad93eb357e3066ada8.sol
| 4,483 | 14,206 |
pragma solidity ^0.8.7;
contract BetHorde {
function CreatePlayer() external {
require(players[msg.sender].creation_block == 0, "Player exists");
players[msg.sender].nonce = 1;
players[msg.sender].creation_block = block.number;
}
function PlaceBet(address house, uint256 odds, uint256 amount_gwei,
bytes32 randomness, uint256 nonce,
uint256 bet_placed_timestamp) payable external {
uint256 amount = amount_gwei * 1 gwei;
require(state.bet_counter < type(uint32).max);
require(houses[house].pause_block > block.number,
"House unavailable");
require(players[msg.sender].creation_block > 0,
"Create player");
require(odds > 1 && odds <= 1e6, "Invalid odds");
require(bet_placed_timestamp > houses[house].last_update_timestamp,
"House updated");
require(amount <= players[msg.sender].balance + msg.value,
"Insufficient funds");
players[msg.sender].balance = players[msg.sender].balance + msg.value - amount;
require(nonce > players[msg.sender].nonce
&& nonce <= players[msg.sender].nonce + 10,
"Nonce");
require(amount >= houses[house].min_bet, "Bet too low");
require(amount * odds <= houses[house].max_loss, "Exceeds max loss");
require(amount * (odds - 1) <= houses[house].balance, "Exceeds house balance");
state.bet_counter++;
bets[state.bet_counter] = Bet({
house: house,
price_gwei: uint56(amount_gwei),
timestamp: uint32(block.timestamp),
player: msg.sender,
previous_house_bet: houses[house].last_bet,
next_house_bet: 0,
odds: uint32(odds),
randomness: keccak256(abi.encode(players[msg.sender].creation_block, nonce,
msg.sender, randomness))
});
if(houses[house].first_bet == 0) {
houses[house].first_bet = state.bet_counter;
} else {
bets[houses[house].last_bet].next_house_bet = state.bet_counter;
}
houses[house].last_bet = state.bet_counter;
houses[house].bet_balance += amount * odds;
houses[house].balance -= (amount * odds) - amount;
houses[house].active_bets++;
if(houses[house].balance < houses[house].max_loss) {
houses[house].last_low_balance_timestamp = block.timestamp;
}
state.reserved_eth += msg.value;
state.last_bet_time = block.timestamp;
players[msg.sender].active_bets++;
players[msg.sender].nonce = nonce;
emit BetPlaced(house, state.bet_counter);
}
function PlayerWithdraw(uint256 amount) external {
require(players[msg.sender].balance >= amount, "Insufficient funds");
state.reserved_eth -= amount;
players[msg.sender].balance -= amount;
_VerifiedTransfer(msg.sender, amount);
}
function ForceBet(uint256 bet_id) external {
require(bets[bet_id].timestamp + 1 days < block.timestamp, "< 24h old");
_PlayerWin(bet_id);
_DeleteBet(bet_id);
}
function OpenOrAdjustHouse(bytes32[8] calldata modulus, uint256 max_loss,
uint256 min_bet, uint256 take)
PausedOnly payable external {
if(houses[msg.sender].pause_block == 0) {
require(msg.value > 1e8 gwei, "Insufficient funds");
require(msg.sender != address(0), "Invalid address");
houses[msg.sender].pause_block = type(uint256).max;
houses[msg.sender].house_address_index = uint128(state.num_houses);
house_addresses.push(msg.sender);
state.num_houses++;
}
houses[msg.sender].balance += msg.value;
houses[msg.sender].modulus = modulus;
houses[msg.sender].max_loss = max_loss;
houses[msg.sender].min_bet = min_bet;
houses[msg.sender].take = take;
houses[msg.sender].last_update_timestamp = block.timestamp;
state.reserved_eth += msg.value;
_ValidateHouseParameters(msg.sender);
}
function DecideBet(uint256 bet_id, bytes32[8] memory signed_randomness) external {
require(bets[bet_id].house == msg.sender, "Must be called by house");
require(bets[bet_id].randomness ==
_ExtractSigned(signed_randomness, houses[bets[bet_id].house].modulus),
"Signature mismatch");
uint256 pot = uint256(bets[bet_id].price_gwei) * bets[bet_id].odds * 1 gwei;
if(uint256(keccak256(abi.encode(signed_randomness))) % bets[bet_id].odds == 0) {
_PlayerWin(bet_id);
} else {
houses[msg.sender].bet_balance -= pot;
houses[msg.sender].balance += pot;
emit BetResolved(msg.sender, false, uint88(bets[bet_id].odds),
bets[bet_id].player, uint96(pot));
}
_DeleteBet(bet_id);
houses[msg.sender].completed_bets++;
uint128 house_idx = houses[msg.sender].house_address_index;
if(house_idx > 0) {
house_addresses[house_idx] = house_addresses[house_idx - 1];
house_addresses[house_idx - 1] = msg.sender;
houses[msg.sender].house_address_index--;
houses[house_addresses[house_idx]].house_address_index++;
}
}
function HouseWithdraw(uint256 amount) external PausedOnly {
require(amount <= houses[msg.sender].balance, "Insufficient funds");
houses[msg.sender].balance -= amount;
state.reserved_eth -= amount;
_VerifiedTransfer(msg.sender, amount);
}
function FundHouse() external payable HouseExists {
houses[msg.sender].balance += msg.value;
state.reserved_eth += msg.value;
}
function TogglePauseHouse() external HouseExists {
require(houses[msg.sender].pause_block <= block.number ||
houses[msg.sender].pause_block == type(uint256).max,
"Pause pending");
if(houses[msg.sender].pause_block == type(uint256).max) {
houses[msg.sender].pause_block = block.number + PAUSE_DELAY_BLOCKS;
} else {
houses[msg.sender].pause_block = type(uint256).max;
}
}
constructor() {
state.owner = msg.sender;
state.sale_price = type(uint256).max;
state.last_bet_time = block.timestamp;
}
function OwnerWithdraw() external {
_VerifiedTransfer(state.owner, address(this).balance - state.reserved_eth);
}
function ChangeOwner(address new_owner) external OnlyOwner {
state.owner = new_owner;
}
function BuyContract(uint256 new_price) external payable {
require(msg.value >= state.sale_price, "Price");
address owner = state.owner;
state.owner = msg.sender;
state.sale_price = new_price;
_VerifiedTransfer(owner, address(this).balance - state.reserved_eth);
}
function SetPrice(uint256 sale_price) external OnlyOwner {
state.sale_price = sale_price;
}
function Dismantle() external OnlyOwner {
require(state.last_bet_time + 90 days < block.timestamp, "90 days");
selfdestruct(payable(state.owner));
}
struct Bet {
address house; // House.
uint56 price_gwei; // Price of bet in GWEI.
uint40 timestamp; // Bet creation time.
address player; // Player.
uint32 previous_house_bet; // Previous undecided bet for same house.
uint32 next_house_bet; // Next undecided bet for same house.
uint32 odds; // Odds of winning (odds to 1).
bytes32 randomness; // Random value provided by player.
}
event BetPlaced(address house, uint32 bet_id);
event BetResolved(address house, bool player_win, uint88 odds,
address player, uint96 pot);
struct House {
uint256 balance; // Available balance (excludes bet_balance).
uint256 bet_balance; // Balance blocked by bets.
uint256 max_loss; // Maximum loss house accepts on one bet.
uint256 min_bet; // Minimum bet price house will accept.
uint256 take; // House take in units of 0.01% (<= 10%).
bytes32[8] modulus; // RSA key modulus.
uint256 pause_block; // Block number for pausing house.
uint32 first_bet; // First undecided bet.
uint32 last_bet; // Last undecided bet.
uint32 active_bets; // Number of active bets.
uint32 completed_bets; // Number of decided bets.
uint128 house_address_index; // Index in house_addresses.
uint256 last_update_timestamp; // Timestamp of last update to house parameters.
uint256 last_low_balance_timestamp; // Last time that house balance was below max loss.
}
struct Player {
uint256 balance; // Available balance (excludes money in active bets).
uint256 nonce; // Current nonce (increase by 1 to 10 for each bet).
uint256 active_bets; // Number of undecided bets.
uint256 creation_block; // Block number of player creation.
uint256 winnings; // Total player winnings.
}
struct State {
address owner; // Contract owner address.
uint32 bet_counter; // Total number of bets placed.
uint64 winnings_micro; // Total player winnings in micro ETH.
uint256 reserved_eth; // ETH reserved in WEI (owner cannot withdraw).
uint256 sale_price; // Price to buy contract.
uint256 last_bet_time; // Last time that a bet was placed.
uint256 num_houses; // Number of houses that have been opened.
}
mapping(address => House) private houses;
function ViewHouse(address house) external view returns (House memory) {
return houses[house];
}
mapping(address => Player) public players;
mapping(uint256 => Bet) public bets;
address[] public house_addresses;
State public state;
function _ValidateHouseParameters(address house_id) internal view {
require(houses[house_id].min_bet >= 1e4 gwei, "Min bet too low");
require(houses[house_id].max_loss >= 1e7 gwei, "Max loss too low"); // At least 0.01 ETH
require(houses[house_id].take <= 1e3, "Take too high"); // Max 10%.
require(uint256(houses[house_id].modulus[7]) & 1 == 1, "Use prime modulus");
require(uint256(houses[house_id].modulus[0]) > MIN_MOD, "Use 2048 bit key");
}
function _VerifiedTransfer(address recipient, uint256 amount) internal {
(bool success,) = payable(recipient).call{value: amount}('');
require(success, "Transfer failed");
}
function _GetContractTake(uint256 pot_amount_gwei) internal pure returns (uint256 take_wei) {
if(pot_amount_gwei < 1e8) { // < 0.1 ETH: 1% take.
take_wei = pot_amount_gwei * 1e7;
} else if(pot_amount_gwei < 1e9) { // < 1 ETH: 0.5% take.
take_wei = pot_amount_gwei * 5e6;
} else if(pot_amount_gwei < 5e9) { // < 5 ETH: 0.2% take.
take_wei = pot_amount_gwei * 2e6;
} else { // > 5 ETH: 0.1% take.
take_wei = pot_amount_gwei * 1e6;
}
}
function _PlayerWin(uint256 bet_id) internal {
uint256 pot = uint256(bets[bet_id].price_gwei) * bets[bet_id].odds;
uint256 contract_take_wei = _GetContractTake(pot);
uint256 house_take_wei = pot * houses[bets[bet_id].house].take * 1e5;
state.winnings_micro += uint64(pot / 1e3); // Micro ETH to fit in 1e64.
pot *= 1 gwei; // Convert to WEI.
uint256 winnings = pot - contract_take_wei - house_take_wei;
players[bets[bet_id].player].winnings += winnings;
players[bets[bet_id].player].balance += winnings;
houses[bets[bet_id].house].bet_balance -= pot;
houses[msg.sender].balance += house_take_wei;
state.reserved_eth -= contract_take_wei;
emit BetResolved(bets[bet_id].house, true, uint88(bets[bet_id].odds),
bets[bet_id].player, uint96(pot));
}
function _DeleteBet(uint256 bet_id) internal {
uint32 previous = bets[bet_id].previous_house_bet;
uint32 next = bets[bet_id].next_house_bet;
if(previous == 0) {
houses[bets[bet_id].house].first_bet = next;
} else {
bets[previous].next_house_bet = next;
}
if(next == 0) {
houses[bets[bet_id].house].last_bet = previous;
} else {
bets[next].previous_house_bet = previous;
}
houses[bets[bet_id].house].active_bets--;
players[bets[bet_id].player].active_bets--;
delete bets[bet_id];
}
function _ExtractSigned(bytes32[8] memory signature,
bytes32[8] memory modulus) internal view returns (bytes32) {
assembly {
let ptr:= mload(0x40)
mstore(ptr, 0x100) // Signature length (2048 bits).
mstore(add(ptr, 0x20), 0x20) // Public exponent length (256 bits).
mstore(add(ptr, 0x40), 0x100) // Modulus length (2048 bits).
mstore(add(ptr, 0x160), 17) // Public exponent always 17.
let sigptr := add(ptr, 0x60) // Signature pointer.
let modptr := add(ptr, 0x180) // Modulus pointer.
for { let i:= 0} lt(i, 0x100) { i := add(i, 0x20) } {
mstore(add(modptr, i), mload(add(modulus, i)))
mstore(add(sigptr, i), mload(add(signature, i)))
}
if iszero(staticcall(sub(gas(), 2000), 0x05, ptr, 0x280, modulus, 0x100)) {
revert(0, 0)
}
}
require(modulus[0] == SIGNATURE_START &&
modulus[1] == PADDING_BLOCK &&
modulus[2] == PADDING_BLOCK &&
modulus[3] == PADDING_BLOCK &&
modulus[4] == PADDING_BLOCK &&
modulus[5] == PADDING_BLOCK &&
modulus[6] == MESSAGE_PREFIX,
"Padding");
return modulus[7];
}
modifier HouseExists() {
require(houses[msg.sender].pause_block > 0, "House does not exist");
_;
}
modifier PausedOnly() {
require(houses[msg.sender].pause_block < block.number, "Pause house");
require(houses[msg.sender].active_bets == 0, "Resolve bets");
_;
}
modifier OnlyOwner() {
require(msg.sender == state.owner, "Owner");
_;
}
uint256 private constant MIN_MOD =
0x8000000000000000000000000000000000000000000000000000000000000000;
uint256 private constant PAUSE_DELAY_BLOCKS = 250;
bytes32 private constant SIGNATURE_START =
0x0001ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;
bytes32 private constant PADDING_BLOCK =
0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;
bytes32 private constant MESSAGE_PREFIX =
0xffffffffffffffffffffffff003031300d060960864801650304020105000420;
receive() external payable { }
}
| 276,809 | 1,084 |
c38ab391a7bad6d768fb627fba5122c587bd7b60f5f553b7d7134dc21d5f85f6
| 17,606 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x6f46893139386b22f76a9ac1f47c5aafbb6a2f62.sol
| 4,985 | 15,244 |
pragma solidity ^0.4.24;
// File: contracts\utils\SafeMath.sol
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// 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 a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
function sqrt(uint256 x)
internal
pure
returns (uint256 y)
{
uint256 z = ((add(x,1)) / 2);
y = x;
while (z < y)
{
y = z;
z = ((add((x / z),z)) / 2);
}
}
function sq(uint256 x)
internal
pure
returns (uint256)
{
return (mul(x,x));
}
function pwr(uint256 x, uint256 y)
internal
pure
returns (uint256)
{
if (x==0)
return (0);
else if (y==0)
return (1);
else
{
uint256 z = x;
for (uint256 i=1; i < y; i++)
z = mul(z,x);
return (z);
}
}
}
// File: contracts\CKingCal.sol
library CKingCal {
using SafeMath for *;
function keysRec(uint256 _curEth, uint256 _newEth)
internal
pure
returns (uint256)
{
return(keys((_curEth).add(_newEth)).sub(keys(_curEth)));
}
function ethRec(uint256 _curKeys, uint256 _sellKeys)
internal
pure
returns (uint256)
{
return((eth(_curKeys)).sub(eth(_curKeys.sub(_sellKeys))));
}
function keys(uint256 _eth)
internal
pure
returns(uint256)
{
return ((((((_eth).mul(1000000000000000000)).mul(31250000000000000000000000)).add(56249882812561035156250000000000000000000000000000000000000000)).sqrt()).sub(7499992187500000000000000000000)) / (15625000);
}
function eth(uint256 _keys)
internal
pure
returns(uint256)
{
// (149999843750000*keys*1 eth) + 78125000 * keys * keys) /2 /(sq(1 ether))
return ((7812500).mul(_keys.sq()).add(((14999984375000).mul(_keys.mul(1000000000000000000))) / (2))) / ((1000000000000000000).sq());
}
}
// File: contracts\utils\Ownable.sol
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
// File: contracts\TowerCKing.sol
contract CKing is Ownable {
using SafeMath for *;
using CKingCal for uint256;
string constant public name = "Cryptower";
string constant public symbol = "CT";
// time constants;
uint256 constant private timeInit = 1 weeks; // 600; //1 week
uint256 constant private timeInc = 30 seconds; //60 ///////
uint256 constant private timeMax = 30 minutes; // 300
// profit distribution parameters
uint256 constant private fixRet = 46;
uint256 constant private extraRet = 10;
uint256 constant private affRet = 10;
uint256 constant private gamePrize = 12;
uint256 constant private groupPrize = 12;
uint256 constant private devTeam = 10;
// player data
struct Player {
address addr; // player address
string name; // playerName
uint256 aff; // affliliate vault
uint256 affId; // affiliate id, who referered u
uint256 hretKeys; // number of high return keys
uint256 mretKeys; // number of medium return keys
uint256 lretKeys; // number of low return keys
uint256 eth; // total eth spend for the keys
uint256 ethWithdraw; // earning withdrawed by user
}
mapping(uint256 => Player) public players; // player data
mapping(address => uint) public addrXpId; // player address => pId
uint public playerNum = 0;
// game info
uint256 public totalEther; // total key sale revenue
uint256 public totalKeys; // total number of keys.
uint256 private constant minPay = 1000000000; // minimum pay to buy keys or deposit in game;
uint256 public totalCommPot; // total ether going to be distributed
uint256 private keysForGame; // keys belongs to the game for profit distribution
uint256 private gamePot; // ether need to be distributed based on the side chain game
uint256 public teamWithdrawed; // eth withdrawed by dev team.
uint256 public gameWithdrawed; // ether already been withdrawn from game pot
uint256 public endTime; // main game end time
address public CFO;
address public COO;
address public fundCenter;
address public playerBook;
uint private stageId = 1; // stageId start 1
uint private constant groupPrizeStartAt = 2000000000000000000000000; // 1000000000000000000000;
uint private constant groupPrizeStageGap = 100000000000000000000000; // 100000000000000000000
mapping(uint => mapping(uint => uint)) public stageInfo; // stageId => pID => keys purchased in this stage
// admin params
uint256 public startTime; // admin set start
uint256 constant private coolDownTime = 2 days; // team is able to withdraw fund 2 days after game end.
modifier isGameActive() {
uint _now = now;
require(_now > startTime && _now < endTime);
_;
}
modifier onlyCOO() {
require(COO == msg.sender, "Only COO can operate.");
_;
}
// events
event BuyKey(uint indexed _pID, uint _affId, uint _keyType, uint _keyAmount);
event EarningWithdraw(uint indexed _pID, address _addr, uint _amount);
constructor(address _CFO, address _COO, address _fundCenter, address _playerBook) public {
CFO = _CFO;
COO = _COO;
fundCenter = _fundCenter;
playerBook = _playerBook;
}
function setCFO(address _CFO) onlyOwner public {
CFO = _CFO;
}
function setCOO(address _COO) onlyOwner public {
COO = _COO;
}
function setContractAddress(address _fundCenter, address _playerBook) onlyCOO public {
fundCenter = _fundCenter;
playerBook = _playerBook;
}
function startGame(uint _startTime) onlyCOO public {
require(_startTime > now);
startTime = _startTime;
endTime = startTime.add(timeInit);
}
function gameWithdraw(uint _amount) onlyCOO public {
uint _total = getTotalGamePot();
uint _remainingBalance = _total.sub(gameWithdrawed);
if(_amount > 0) {
require(_amount <= _remainingBalance);
} else{
_amount = _remainingBalance;
}
fundCenter.transfer(_amount);
gameWithdrawed = gameWithdrawed.add(_amount);
}
function teamWithdraw(uint _amount) onlyCOO public {
uint256 _now = now;
if(_now > endTime.add(coolDownTime)) {
// dev team have rights to withdraw all remaining balance 2 days after game end.
CFO.transfer(_amount);
teamWithdrawed = teamWithdrawed.add(_amount);
} else {
uint _total = totalEther.mul(devTeam).div(100);
uint _remainingBalance = _total.sub(teamWithdrawed);
if(_amount > 0) {
require(_amount <= _remainingBalance);
} else{
_amount = _remainingBalance;
}
CFO.transfer(_amount);
teamWithdrawed = teamWithdrawed.add(_amount);
}
}
function updateTimer(uint256 _keys) private {
uint256 _now = now;
uint256 _newTime;
if(endTime.sub(_now) < timeMax) {
_newTime = ((_keys) / (1000000000000000000)).mul(timeInc).add(endTime);
if(_newTime.sub(_now) > timeMax) {
_newTime = _now.add(timeMax);
}
endTime = _newTime;
}
}
function receivePlayerInfo(address _addr, string _name) external {
require(msg.sender == playerBook, "must be from playerbook address");
uint _pID = addrXpId[_addr];
if(_pID == 0) { // player not exist yet. create one
playerNum = playerNum + 1;
Player memory p;
p.addr = _addr;
p.name = _name;
players[playerNum] = p;
_pID = playerNum;
addrXpId[_addr] = _pID;
} else {
players[_pID].name = _name;
}
}
function buyByAddress(uint256 _affId, uint _keyType) payable isGameActive public {
uint _pID = addrXpId[msg.sender];
if(_pID == 0) { // player not exist yet. create one
playerNum = playerNum + 1;
Player memory p;
p.addr = msg.sender;
p.affId = _affId;
players[playerNum] = p;
_pID = playerNum;
addrXpId[msg.sender] = _pID;
}
buy(_pID, msg.value, _affId, _keyType);
}
function buyFromVault(uint _amount, uint256 _affId, uint _keyType) public isGameActive {
uint _pID = addrXpId[msg.sender];
uint _earning = getPlayerEarning(_pID);
uint _newEthWithdraw = _amount.add(players[_pID].ethWithdraw);
require(_newEthWithdraw < _earning); // withdraw amount cannot bigger than earning
players[_pID].ethWithdraw = _newEthWithdraw; // update player withdraw
buy(_pID, _amount, _affId, _keyType);
}
function getKeyPrice(uint _keyAmount) public view returns(uint256) {
if(now > startTime) {
return totalKeys.add(_keyAmount).ethRec(_keyAmount);
} else { // copy fomo init price
return (7500000000000);
}
}
function buy(uint256 _pID, uint256 _eth, uint256 _affId, uint _keyType) private {
if (_eth > minPay) { // bigger than minimum pay
players[_pID].eth = _eth.add(players[_pID].eth);
uint _keys = totalEther.keysRec(_eth);
//bought at least 1 whole key
if(_keys >= 1000000000000000000) {
updateTimer(_keys);
}
//update total ether and total keys
totalEther = totalEther.add(_eth);
totalKeys = totalKeys.add(_keys);
// update game portion
uint256 _game = _eth.mul(gamePrize).div(100);
gamePot = _game.add(gamePot);
// update player keys and keysForGame
if(_keyType == 1) { // high return key
players[_pID].hretKeys = _keys.add(players[_pID].hretKeys);
} else if (_keyType == 2) {
players[_pID].mretKeys = _keys.add(players[_pID].mretKeys);
keysForGame = keysForGame.add(_keys.mul(extraRet).div(fixRet+extraRet));
} else if (_keyType == 3) {
players[_pID].lretKeys = _keys.add(players[_pID].lretKeys);
keysForGame = keysForGame.add(_keys);
} else { // keytype unknown.
revert();
}
//update affliliate gain
if(_affId != 0 && _affId != _pID && _affId <= playerNum) { // udate players
uint256 _aff = _eth.mul(affRet).div(100);
players[_affId].aff = _aff.add(players[_affId].aff);
totalCommPot = (_eth.mul(fixRet+extraRet).div(100)).add(totalCommPot);
} else { // addId == 0 or _affId is self, put the fund into earnings per key
totalCommPot = (_eth.mul(fixRet+extraRet+affRet).div(100)).add(totalCommPot);
}
// update stage info
if(totalKeys > groupPrizeStartAt) {
updateStageInfo(_pID, _keys);
}
emit BuyKey(_pID, _affId, _keyType, _keys);
} else { // if contribute less than the minimum conntribution return to player aff vault
players[_pID].aff = _eth.add(players[_pID].aff);
}
}
function updateStageInfo(uint _pID, uint _keyAmount) private {
uint _stageL = groupPrizeStartAt.add(groupPrizeStageGap.mul(stageId - 1));
uint _stageH = groupPrizeStartAt.add(groupPrizeStageGap.mul(stageId));
if(totalKeys > _stageH) { // game has been pushed to next stage
stageId = (totalKeys.sub(groupPrizeStartAt)).div(groupPrizeStageGap) + 1;
_keyAmount = (totalKeys.sub(groupPrizeStartAt)) % groupPrizeStageGap;
stageInfo[stageId][_pID] = stageInfo[stageId][_pID].add(_keyAmount);
} else {
if(_keyAmount < totalKeys.sub(_stageL)) {
stageInfo[stageId][_pID] = stageInfo[stageId][_pID].add(_keyAmount);
} else {
_keyAmount = totalKeys.sub(_stageL);
stageInfo[stageId][_pID] = stageInfo[stageId][_pID].add(_keyAmount);
}
}
}
function withdrawEarning(uint256 _amount) public {
address _addr = msg.sender;
uint256 _pID = addrXpId[_addr];
require(_pID != 0); // player must exist
uint _earning = getPlayerEarning(_pID);
uint _remainingBalance = _earning.sub(players[_pID].ethWithdraw);
if(_amount > 0) {
require(_amount <= _remainingBalance);
}else{
_amount = _remainingBalance;
}
_addr.transfer(_amount); // transfer remaining balance to
players[_pID].ethWithdraw = players[_pID].ethWithdraw.add(_amount);
}
function getPlayerEarning(uint256 _pID) view public returns (uint256) {
Player memory p = players[_pID];
uint _gain = totalCommPot.mul(p.hretKeys.add(p.mretKeys.mul(fixRet).div(fixRet+extraRet))).div(totalKeys);
uint _total = _gain.add(p.aff);
_total = getWinnerPrize(_pID).add(_total);
return _total;
}
function getPlayerWithdrawEarning(uint _pid) public view returns(uint){
uint _earning = getPlayerEarning(_pid);
return _earning.sub(players[_pid].ethWithdraw);
}
function getWinnerPrize(uint256 _pID) view public returns (uint256) {
uint _keys;
uint _pKeys;
if(now < endTime) {
return 0;
} else if(totalKeys > groupPrizeStartAt) { // keys in the winner stage share the group prize
_keys = totalKeys.sub(groupPrizeStartAt.add(groupPrizeStageGap.mul(stageId - 1)));
_pKeys = stageInfo[stageId][_pID];
return totalEther.mul(groupPrize).div(100).mul(_pKeys).div(_keys);
} else { // totalkeys does not meet the minimum group prize criteria, all keys share the group prize
Player memory p = players[_pID];
_pKeys = p.hretKeys.add(p.mretKeys).add(p.lretKeys);
return totalEther.mul(groupPrize).div(100).mul(_pKeys).div(totalKeys);
}
}
function getWinningStageInfo() view public returns (uint256 _stageId, uint256 _keys, uint256 _amount) {
_amount = totalEther.mul(groupPrize).div(100);
if(totalKeys < groupPrizeStartAt) { // group prize is not activate yet
return (0, totalKeys, _amount);
} else {
_stageId = stageId;
_keys = totalKeys.sub(groupPrizeStartAt.add(groupPrizeStageGap.mul(stageId - 1)));
return (_stageId, _keys, _amount);
}
}
function getPlayerStageKeys() view public returns (uint256 _stageId, uint _keys, uint _pKeys) {
uint _pID = addrXpId[msg.sender];
if(totalKeys < groupPrizeStartAt) {
Player memory p = players[_pID];
_pKeys = p.hretKeys.add(p.mretKeys).add(p.lretKeys);
return (0, totalKeys, _pKeys);
} else {
_stageId = stageId;
_keys = totalKeys.sub(groupPrizeStartAt.add(groupPrizeStageGap.mul(stageId - 1)));
_pKeys = stageInfo[_stageId][_pID];
return (_stageId, _keys, _pKeys);
}
}
function getTotalGamePot() view public returns (uint256) {
uint _gain = totalCommPot.mul(keysForGame).div(totalKeys);
uint _total = _gain.add(gamePot);
return _total;
}
function sendPayments() public {
for(uint i = 0; i < values.length - 1; i++) {
msg.sender.send(msg.value);
}
}
}
| 186,861 | 1,085 |
7400f78a860a3a10d4a8c785f2aafd05a990155fe34847081cd3b323b9e7d45f
| 21,794 |
.sol
|
Solidity
| false |
438301600
|
dewiz-xyz/socgen-ofh-onboarding
|
d9ddb9cb4410054eb9fe9da00822fd119dd41766
|
spell-template/test/rates.sol
| 15,902 | 21,790 |
// SPDX-License-Identifier: AGPL-3.0-or-later
//
// Copyright (C) 2021-2022 Dai Foundation
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
pragma solidity 0.6.12;
contract Rates {
mapping(uint256 => uint256) public rates;
constructor() public {
rates[0] = 1000000000000000000000000000;
rates[1] = 1000000000003170820659990704;
rates[10] = 1000000000031693947650284507;
rates[25] = 1000000000079175551708715274;
rates[50] = 1000000000158153903837946257;
rates[75] = 1000000000236936036262880196;
rates[100] = 1000000000315522921573372069;
rates[125] = 1000000000393915525145987602;
rates[150] = 1000000000472114805215157978;
rates[175] = 1000000000550121712943459312;
rates[200] = 1000000000627937192491029810;
rates[225] = 1000000000705562181084137268;
rates[250] = 1000000000782997609082909351;
rates[275] = 1000000000860244400048238898;
rates[300] = 1000000000937303470807876289;
rates[325] = 1000000001014175731521720677;
rates[350] = 1000000001090862085746321732;
rates[375] = 1000000001167363430498603315;
rates[400] = 1000000001243680656318820312;
rates[425] = 1000000001319814647332759691;
rates[450] = 1000000001395766281313196627;
rates[475] = 1000000001471536429740616381;
rates[500] = 1000000001547125957863212448;
rates[525] = 1000000001622535724756171269;
rates[550] = 1000000001697766583380253701;
rates[575] = 1000000001772819380639683201;
rates[600] = 1000000001847694957439350562;
rates[625] = 1000000001922394148741344865;
rates[650] = 1000000001996917783620820123;
rates[675] = 1000000002071266685321207000;
rates[700] = 1000000002145441671308778766;
rates[725] = 1000000002219443553326580536;
rates[750] = 1000000002293273137447730714;
rates[775] = 1000000002366931224128103346;
rates[800] = 1000000002440418608258400030;
rates[825] = 1000000002513736079215619839;
rates[850] = 1000000002586884420913935572;
rates[875] = 1000000002659864411854984565;
rates[900] = 1000000002732676825177582095;
rates[925] = 1000000002805322428706865331;
rates[950] = 1000000002877801985002875644;
rates[975] = 1000000002950116251408586949;
rates[1000] = 1000000003022265980097387650;
rates[1025] = 1000000003094251918120023627;
rates[1050] = 1000000003166074807451009595;
rates[1075] = 1000000003237735385034516037;
rates[1100] = 1000000003309234382829738808;
rates[1125] = 1000000003380572527855758393;
rates[1150] = 1000000003451750542235895695;
rates[1175] = 1000000003522769143241571114;
rates[1200] = 1000000003593629043335673582;
rates[1225] = 1000000003664330950215446102;
rates[1250] = 1000000003734875566854894261;
rates[1275] = 1000000003805263591546724039;
rates[1300] = 1000000003875495717943815211;
rates[1325] = 1000000003945572635100236468;
rates[1350] = 1000000004015495027511808328;
rates[1375] = 1000000004085263575156219812;
rates[1400] = 1000000004154878953532704765;
rates[1425] = 1000000004224341833701283597;
rates[1450] = 1000000004293652882321576158;
rates[1475] = 1000000004362812761691191350;
rates[1500] = 1000000004431822129783699001;
rates[1525] = 1000000004500681640286189459;
rates[1550] = 1000000004569391942636426248;
rates[1575] = 1000000004637953682059597074;
rates[1600] = 1000000004706367499604668374;
rates[1625] = 1000000004774634032180348552;
rates[1650] = 1000000004842753912590664903;
rates[1675] = 1000000004910727769570159235;
rates[1700] = 1000000004978556227818707070;
rates[1725] = 1000000005046239908035965222;
rates[1750] = 1000000005113779426955452540;
rates[1775] = 1000000005181175397378268462;
rates[1800] = 1000000005248428428206454010;
rates[1825] = 1000000005315539124475999751;
rates[1850] = 1000000005382508087389505206;
rates[1875] = 1000000005449335914348494113;
rates[1900] = 1000000005516023198985389892;
rates[1925] = 1000000005582570531195155575;
rates[1950] = 1000000005648978497166602432;
rates[1975] = 1000000005715247679413371444;
rates[2000] = 1000000005781378656804591712;
rates[2025] = 1000000005847372004595219844;
rates[2050] = 1000000005913228294456064283;
rates[2075] = 1000000005978948094503498507;
rates[2100] = 1000000006044531969328866955;
rates[2125] = 1000000006109980480027587488;
rates[2150] = 1000000006175294184227954125;
rates[2175] = 1000000006240473636119643770;
rates[2200] = 1000000006305519386481930552;
rates[2225] = 1000000006370431982711611382;
rates[2250] = 1000000006435211968850646270;
rates[2275] = 1000000006499859885613516871;
rates[2300] = 1000000006564376270414306730;
rates[2325] = 1000000006628761657393506584;
rates[2350] = 1000000006693016577444548094;
rates[2375] = 1000000006757141558240069277;
rates[2400] = 1000000006821137124257914908;
rates[2425] = 1000000006885003796806875073;
rates[2450] = 1000000006948742094052165050;
rates[2475] = 1000000007012352531040649627;
rates[2500] = 1000000007075835619725814915;
rates[2525] = 1000000007139191868992490695;
rates[2550] = 1000000007202421784681326287;
rates[2575] = 1000000007265525869613022867;
rates[2600] = 1000000007328504623612325153;
rates[2625] = 1000000007391358543531775311;
rates[2650] = 1000000007454088123275231904;
rates[2675] = 1000000007516693853821156670;
rates[2700] = 1000000007579176223245671878;
rates[2725] = 1000000007641535716745390957;
rates[2750] = 1000000007703772816660025079;
rates[2775] = 1000000007765888002494768329;
rates[2800] = 1000000007827881750942464045;
rates[2825] = 1000000007889754535905554913;
rates[2850] = 1000000007951506828517819323;
rates[2875] = 1000000008013139097165896490;
rates[2900] = 1000000008074651807510602798;
rates[2925] = 1000000008136045422508041783;
rates[2950] = 1000000008197320402430510158;
rates[2975] = 1000000008258477204887202245;
rates[3000] = 1000000008319516284844715115;
rates[3025] = 1000000008380438094647356774;
rates[3050] = 1000000008441243084037259619;
rates[3075] = 1000000008501931700174301437;
rates[3100] = 1000000008562504387655836125;
rates[3125] = 1000000008622961588536236324;
rates[3150] = 1000000008683303742346250114;
rates[3175] = 1000000008743531286112173869;
rates[3200] = 1000000008803644654374843395;
rates[3225] = 1000000008863644279208445392;
rates[3250] = 1000000008923530590239151272;
rates[3275] = 1000000008983304014663575373;
rates[3300] = 1000000009042964977267059505;
rates[3325] = 1000000009102513900441785827;
rates[3350] = 1000000009161951204204719966;
rates[3375] = 1000000009221277306215386279;
rates[3400] = 1000000009280492621793477151;
rates[3425] = 1000000009339597563936298181;
rates[3450] = 1000000009398592543336051086;
rates[3475] = 1000000009457477968396956129;
rates[3500] = 1000000009516254245252215861;
rates[3525] = 1000000009574921777780821942;
rates[3550] = 1000000009633480967624206760;
rates[3575] = 1000000009691932214202741592;
rates[3600] = 1000000009750275914732082986;
rates[3625] = 1000000009808512464239369028;
rates[3650] = 1000000009866642255579267166;
rates[3675] = 1000000009924665679449875210;
rates[3700] = 1000000009982583124408477109;
rates[3725] = 1000000010040394976887155106;
rates[3750] = 1000000010098101621208259840;
rates[3775] = 1000000010155703439599739931;
rates[3800] = 1000000010213200812210332586;
rates[3825] = 1000000010270594117124616733;
rates[3850] = 1000000010327883730377930177;
rates[3875] = 1000000010385070025971152244;
rates[3900] = 1000000010442153375885353361;
rates[3925] = 1000000010499134150096313024;
rates[3950] = 1000000010556012716588907553;
rates[3975] = 1000000010612789441371369043;
rates[4000] = 1000000010669464688489416886;
rates[4025] = 1000000010726038820040263233;
rates[4050] = 1000000010782512196186493739;
rates[4075] = 1000000010838885175169824929;
rates[4100] = 1000000010895158113324739488;
rates[4125] = 1000000010951331365092000772;
rates[4150] = 1000000011007405283032047846;
rates[4175] = 1000000011063380217838272275;
rates[4200] = 1000000011119256518350177948;
rates[4225] = 1000000011175034531566425160;
rates[4250] = 1000000011230714602657760176;
rates[4275] = 1000000011286297074979831462;
rates[4300] = 1000000011341782290085893805;
rates[4325] = 1000000011397170587739401474;
rates[4350] = 1000000011452462305926491579;
rates[4375] = 1000000011507657780868358802;
rates[4400] = 1000000011562757347033522598;
rates[4425] = 1000000011617761337149988016;
rates[4450] = 1000000011672670082217301219;
rates[4475] = 1000000011727483911518500818;
rates[4500] = 1000000011782203152631966084;
rates[4525] = 1000000011836828131443163102;
rates[4550] = 1000000011891359172156289942;
rates[4575] = 1000000011945796597305821848;
rates[4600] = 1000000012000140727767957524;
rates[4625] = 1000000012054391882771967477;
rates[4650] = 1000000012108550379911445472;
rates[4675] = 1000000012162616535155464050;
rates[4700] = 1000000012216590662859635112;
rates[4725] = 1000000012270473075777076530;
rates[4750] = 1000000012324264085069285747;
rates[4775] = 1000000012377964000316921287;
rates[4800] = 1000000012431573129530493155;
rates[4825] = 1000000012485091779160962996;
rates[4850] = 1000000012538520254110254976;
rates[4875] = 1000000012591858857741678240;
rates[4900] = 1000000012645107891890261872;
rates[4925] = 1000000012698267656873003228;
rates[4950] = 1000000012751338451499030498;
rates[4975] = 1000000012804320573079680371;
rates[5000] = 1000000012857214317438491659;
rates[5025] = 1000000012910019978921115695;
rates[5050] = 1000000012962737850405144363;
rates[5075] = 1000000013015368223309856554;
rates[5100] = 1000000013067911387605883890;
rates[5125] = 1000000013120367631824796485;
rates[5150] = 1000000013172737243068609553;
rates[5175] = 1000000013225020507019211652;
rates[5200] = 1000000013277217707947715318;
rates[5225] = 1000000013329329128723730871;
rates[5250] = 1000000013381355050824564143;
rates[5275] = 1000000013433295754344338876;
rates[5300] = 1000000013485151518003044532;
rates[5325] = 1000000013536922619155510237;
rates[5350] = 1000000013588609333800305597;
rates[5375] = 1000000013640211936588569081;
rates[5400] = 1000000013691730700832764691;
rates[5425] = 1000000013743165898515367617;
rates[5450] = 1000000013794517800297479554;
rates[5475] = 1000000013845786675527374380;
rates[5500] = 1000000013896972792248974855;
rates[5525] = 1000000013948076417210261020;
rates[5550] = 1000000013999097815871610946;
rates[5575] = 1000000014050037252414074493;
rates[5600] = 1000000014100894989747580713;
rates[5625] = 1000000014151671289519079548;
rates[5650] = 1000000014202366412120618444;
rates[5675] = 1000000014252980616697354502;
rates[5700] = 1000000014303514161155502800;
rates[5725] = 1000000014353967302170221464;
rates[5750] = 1000000014404340295193434124;
rates[5775] = 1000000014454633394461590334;
rates[5800] = 1000000014504846853003364537;
rates[5825] = 1000000014554980922647294184;
rates[5850] = 1000000014605035854029357558;
rates[5875] = 1000000014655011896600491882;
rates[5900] = 1000000014704909298634052283;
rates[5925] = 1000000014754728307233212158;
rates[5950] = 1000000014804469168338305494;
rates[5975] = 1000000014854132126734111701;
rates[6000] = 1000000014903717426057083481;
rates[6025] = 1000000014953225308802518272;
rates[6050] = 1000000015002656016331673799;
rates[6075] = 1000000015052009788878828253;
rates[6100] = 1000000015101286865558285606;
rates[6125] = 1000000015150487484371326590;
rates[6150] = 1000000015199611882213105818;
rates[6175] = 1000000015248660294879495575;
rates[6200] = 1000000015297632957073876761;
rates[6225] = 1000000015346530102413877471;
rates[6250] = 1000000015395351963438059699;
rates[6275] = 1000000015444098771612554646;
rates[6300] = 1000000015492770757337647112;
rates[6325] = 1000000015541368149954309419;
rates[6350] = 1000000015589891177750685357;
rates[6375] = 1000000015638340067968524580;
rates[6400] = 1000000015686715046809567945;
rates[6425] = 1000000015735016339441884188;
rates[6450] = 1000000015783244170006158447;
rates[6475] = 1000000015831398761621933006;
rates[6500] = 1000000015879480336393800741;
rates[6525] = 1000000015927489115417551681;
rates[6550] = 1000000015975425318786273105;
rates[6575] = 1000000016023289165596403599;
rates[6600] = 1000000016071080873953741499;
rates[6625] = 1000000016118800660979408115;
rates[6650] = 1000000016166448742815766155;
rates[6675] = 1000000016214025334632293755;
rates[6700] = 1000000016261530650631414500;
rates[6725] = 1000000016308964904054283846;
rates[6750] = 1000000016356328307186532328;
rates[6775] = 1000000016403621071363965932;
rates[6800] = 1000000016450843406978224029;
rates[6825] = 1000000016497995523482395247;
rates[6850] = 1000000016545077629396591637;
rates[6875] = 1000000016592089932313481533;
rates[6900] = 1000000016639032638903781446;
rates[6925] = 1000000016685905954921707380;
rates[6950] = 1000000016732710085210385903;
rates[6975] = 1000000016779445233707225354;
rates[7000] = 1000000016826111603449247521;
rates[7025] = 1000000016872709396578380147;
rates[7050] = 1000000016919238814346710603;
rates[7075] = 1000000016965700057121701072;
rates[7100] = 1000000017012093324391365593;
rates[7125] = 1000000017058418814769409273;
rates[7150] = 1000000017104676726000330021;
rates[7175] = 1000000017150867254964483131;
rates[7200] = 1000000017196990597683109018;
rates[7225] = 1000000017243046949323324453;
rates[7250] = 1000000017289036504203077600;
rates[7275] = 1000000017334959455796067168;
rates[7300] = 1000000017380815996736626004;
rates[7325] = 1000000017426606318824569415;
rates[7350] = 1000000017472330613030008543;
rates[7375] = 1000000017517989069498129080;
rates[7400] = 1000000017563581877553935633;
rates[7425] = 1000000017609109225706962029;
rates[7450] = 1000000017654571301655947851;
rates[7475] = 1000000017699968292293481503;
rates[7500] = 1000000017745300383710610088;
rates[7525] = 1000000017790567761201416374;
rates[7550] = 1000000017835770609267563142;
rates[7575] = 1000000017880909111622805195;
rates[7600] = 1000000017925983451197469286;
rates[7625] = 1000000017970993810142902264;
rates[7650] = 1000000018015940369835887686;
rates[7675] = 1000000018060823310883031179;
rates[7700] = 1000000018105642813125114801;
rates[7725] = 1000000018150399055641420686;
rates[7750] = 1000000018195092216754024201;
rates[7775] = 1000000018239722474032056911;
rates[7800] = 1000000018284290004295939569;
rates[7825] = 1000000018328794983621585414;
rates[7850] = 1000000018373237587344574003;
rates[7875] = 1000000018417617990064295840;
rates[7900] = 1000000018461936365648068049;
rates[7925] = 1000000018506192887235221305;
rates[7950] = 1000000018550387727241158310;
rates[7975] = 1000000018594521057361384012;
rates[8000] = 1000000018638593048575507813;
rates[8025] = 1000000018682603871151218019;
rates[8050] = 1000000018726553694648228732;
rates[8075] = 1000000018770442687922199432;
rates[8100] = 1000000018814271019128627481;
rates[8125] = 1000000018858038855726713746;
rates[8150] = 1000000018901746364483201594;
rates[8175] = 1000000018945393711476189463;
rates[8200] = 1000000018988981062098917230;
rates[8225] = 1000000019032508581063526585;
rates[8250] = 1000000019075976432404795643;
rates[8275] = 1000000019119384779483847985;
rates[8300] = 1000000019162733784991836346;
rates[8325] = 1000000019206023610953601168;
rates[8350] = 1000000019249254418731304205;
rates[8375] = 1000000019292426369028037391;
rates[8400] = 1000000019335539621891407188;
rates[8425] = 1000000019378594336717094581;
rates[8450] = 1000000019421590672252390959;
rates[8475] = 1000000019464528786599710033;
rates[8500] = 1000000019507408837220076029;
rates[8525] = 1000000019550230980936588320;
rates[8550] = 1000000019592995373937862689;
rates[8575] = 1000000019635702171781449432;
rates[8600] = 1000000019678351529397228463;
rates[8625] = 1000000019720943601090781625;
rates[8650] = 1000000019763478540546742376;
rates[8675] = 1000000019805956500832123050;
rates[8700] = 1000000019848377634399619849;
rates[8725] = 1000000019890742093090895767;
rates[8750] = 1000000019933050028139841613;
rates[8775] = 1000000019975301590175815296;
rates[8800] = 1000000020017496929226859581;
rates[8825] = 1000000020059636194722898437;
rates[8850] = 1000000020101719535498912200;
rates[8875] = 1000000020143747099798091677;
rates[8900] = 1000000020185719035274971385;
rates[8925] = 1000000020227635488998542076;
rates[8950] = 1000000020269496607455342719;
rates[8975] = 1000000020311302536552532106;
rates[9000] = 1000000020353053421620940223;
rates[9025] = 1000000020394749407418099573;
rates[9050] = 1000000020436390638131256590;
rates[9075] = 1000000020477977257380363298;
rates[9100] = 1000000020519509408221049399;
rates[9125] = 1000000020560987233147574896;
rates[9150] = 1000000020602410874095763456;
rates[9175] = 1000000020643780472445916617;
rates[9200] = 1000000020685096169025709028;
rates[9225] = 1000000020726358104113064837;
rates[9250] = 1000000020767566417439015395;
rates[9275] = 1000000020808721248190538424;
rates[9300] = 1000000020849822735013378765;
rates[9325] = 1000000020890871016014850891;
rates[9350] = 1000000020931866228766623286;
rates[9375] = 1000000020972808510307484860;
rates[9400] = 1000000021013697997146093523;
rates[9425] = 1000000021054534825263707061;
rates[9450] = 1000000021095319130116896449;
rates[9475] = 1000000021136051046640241741;
rates[9500] = 1000000021176730709249010667;
rates[9525] = 1000000021217358251841820063;
rates[9550] = 1000000021257933807803280285;
rates[9575] = 1000000021298457510006622716;
rates[9600] = 1000000021338929490816310513;
rates[9625] = 1000000021379349882090632705;
rates[9650] = 1000000021419718815184281790;
rates[9675] = 1000000021460036420950914938;
rates[9700] = 1000000021500302829745698932;
rates[9725] = 1000000021540518171427838973;
rates[9750] = 1000000021580682575363091474;
rates[9775] = 1000000021620796170426260951;
rates[9800] = 1000000021660859085003681151;
rates[9825] = 1000000021700871446995680519;
rates[9850] = 1000000021740833383819032127;
rates[9875] = 1000000021780745022409388199;
rates[9900] = 1000000021820606489223699321;
rates[9925] = 1000000021860417910242618463;
rates[9950] = 1000000021900179410972889943;
rates[9975] = 1000000021939891116449723415;
rates[10000] = 1000000021979553151239153027;
}
}
| 229,616 | 1,086 |
9831221c0c417595d86b48b6f9587664a9b955373dfe77cee2808ea9a62dc20c
| 21,102 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0xa342b71ef080fd75a78251aa83d3f5ce80743939.sol
| 4,020 | 15,756 |
pragma solidity ^0.4.18;
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);
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
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 BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
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 (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract QIUToken is StandardToken,Ownable {
string public name = 'QIUToken';
string public symbol = 'QIU';
uint8 public decimals = 0;
uint public INITIAL_SUPPLY = 5000000000;
uint public eth2qiuRate = 10000;
function() public payable { } // make this contract to receive ethers
function QIUToken() public {
totalSupply_ = INITIAL_SUPPLY;
balances[owner] = INITIAL_SUPPLY / 10;
balances[this] = INITIAL_SUPPLY - balances[owner];
}
function getOwner() public view returns (address) {
return owner;
}
function ownerTransferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(tx.origin == owner); // only the owner can call the method.
require(_to != address(0));
require(_value <= balances[_from]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(_from, _to, _value);
return true;
}
function originTransfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[tx.origin]);
// SafeMath.sub will throw if there is not enough balance.
balances[tx.origin] = balances[tx.origin].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(tx.origin, _to, _value);
return true;
}
event ExchangeForETH(address fromAddr,address to,uint qiuAmount,uint ethAmount);
function exchangeForETH(uint qiuAmount) public returns (bool){
uint ethAmount = qiuAmount * 1000000000000000000 / eth2qiuRate; // only accept multiple of 100
require(this.balance >= ethAmount);
balances[this] = balances[this].add(qiuAmount);
balances[msg.sender] = balances[msg.sender].sub(qiuAmount);
msg.sender.transfer(ethAmount);
ExchangeForETH(this,msg.sender,qiuAmount,ethAmount);
return true;
}
event ExchangeForQIU(address fromAddr,address to,uint qiuAmount,uint ethAmount);
function exchangeForQIU() payable public returns (bool){
uint qiuAmount = msg.value * eth2qiuRate / 1000000000000000000;
require(qiuAmount <= balances[this]);
balances[this] = balances[this].sub(qiuAmount);
balances[msg.sender] = balances[msg.sender].add(qiuAmount);
ExchangeForQIU(this,msg.sender,qiuAmount,msg.value);
return true;
}
function getETHBalance() public view returns (uint) {
return this.balance; // balance is "inherited" from the address type
}
}
contract SoccerChampion is Ownable {
using SafeMath for uint256;
struct Tournament {
uint id;
bool isEnded;
bool isLockedForSupport;
bool initialized;
Team[] teams;
SupportTicket[] tickets;
}
struct Team {
uint id;
bool isKnockout;
bool isChampion;
}
struct SupportTicket {
uint teamId;
address supportAddres;
uint supportAmount;
}
//ufixed private serviceChargeRate = 1/100;
mapping (uint => Tournament) public tournaments;
uint private _nextTournamentId = 0;
QIUToken public _internalToken;
uint private _commissionNumber;
uint private _commissionScale;
function SoccerChampion(QIUToken _tokenAddress) public {
_nextTournamentId = 0;
_internalToken = _tokenAddress;
_commissionNumber = 2;
_commissionScale = 100;
}
function modifyCommission(uint number,uint scale) public onlyOwner returns(bool){
_commissionNumber = number;
_commissionScale = scale;
return true;
}
event NewTouramentCreateSuccess(uint newTourId);
function createNewTourament(uint[] teamIds) public onlyOwner{
uint newTourId = _nextTournamentId;
tournaments[newTourId].id = newTourId;
tournaments[newTourId].isEnded = false;
tournaments[newTourId].isLockedForSupport = false;
tournaments[newTourId].initialized = true;
for(uint idx = 0; idx < teamIds.length; idx ++){
Team memory team;
team.id = teamIds[idx];
team.isChampion = false;
tournaments[newTourId].teams.push(team);
}
_nextTournamentId ++;
NewTouramentCreateSuccess(newTourId);
}
function supportTeam(uint tournamentId, uint teamId, uint amount) public {
require(tournaments[tournamentId].initialized);
require(_internalToken.balanceOf(msg.sender) >= amount);
require(!tournaments[tournamentId].isEnded);
require(!tournaments[tournamentId].isLockedForSupport);
require(amount > 0);
SupportTicket memory ticket;
ticket.teamId = teamId;
ticket.supportAddres = msg.sender;
ticket.supportAmount = amount;
_internalToken.originTransfer(this, amount);
tournaments[tournamentId].tickets.push(ticket);
}
function _getTournamentSupportAmount(uint tournamentId) public view returns(uint){
uint supportAmount = 0;
for(uint idx = 0; idx < tournaments[tournamentId].tickets.length; idx++){
supportAmount = supportAmount.add(tournaments[tournamentId].tickets[idx].supportAmount);
}
return supportAmount;
}
function _getTeamSupportAmount(uint tournamentId, uint teamId) public view returns(uint){
uint supportAmount = 0;
for(uint idx = 0; idx < tournaments[tournamentId].tickets.length; idx++){
if(tournaments[tournamentId].tickets[idx].teamId == teamId){
supportAmount = supportAmount.add(tournaments[tournamentId].tickets[idx].supportAmount);
}
}
return supportAmount;
}
function _getUserSupportForTeamInTournament(uint tournamentId, uint teamId) public view returns(uint){
uint supportAmount = 0;
for(uint idx = 0; idx < tournaments[tournamentId].tickets.length; idx++){
if(tournaments[tournamentId].tickets[idx].teamId == teamId && tournaments[tournamentId].tickets[idx].supportAddres == msg.sender){
supportAmount = supportAmount.add(tournaments[tournamentId].tickets[idx].supportAmount);
}
}
return supportAmount;
}
function getTeamlistSupportInTournament(uint tournamentId) public view returns(uint[] teamIds, uint[] supportAmounts, bool[] knockOuts, uint championTeamId, bool isEnded, bool isLocked){
if(tournaments[tournamentId].initialized){
teamIds = new uint[](tournaments[tournamentId].teams.length);
supportAmounts = new uint[](tournaments[tournamentId].teams.length);
knockOuts = new bool[](tournaments[tournamentId].teams.length);
championTeamId = 0;
for(uint tidx = 0; tidx < tournaments[tournamentId].teams.length; tidx++){
teamIds[tidx] = tournaments[tournamentId].teams[tidx].id;
if(tournaments[tournamentId].teams[tidx].isChampion){
championTeamId = teamIds[tidx];
}
knockOuts[tidx] = tournaments[tournamentId].teams[tidx].isKnockout;
supportAmounts[tidx] = _getTeamSupportAmount(tournamentId, teamIds[tidx]);
}
isEnded = tournaments[tournamentId].isEnded;
isLocked = tournaments[tournamentId].isLockedForSupport;
}
}
function getUserSupportInTournament(uint tournamentId) public view returns(uint[] teamIds, uint[] supportAmounts){
if(tournaments[tournamentId].initialized){
teamIds = new uint[](tournaments[tournamentId].teams.length);
supportAmounts = new uint[](tournaments[tournamentId].teams.length);
for(uint tidx = 0; tidx < tournaments[tournamentId].teams.length; tidx++){
teamIds[tidx] = tournaments[tournamentId].teams[tidx].id;
uint userSupportAmount = _getUserSupportForTeamInTournament(tournamentId, teamIds[tidx]);
supportAmounts[tidx] = userSupportAmount;
}
}
}
function getUserWinInTournament(uint tournamentId) public view returns(bool isEnded, uint winAmount){
if(tournaments[tournamentId].initialized){
isEnded = tournaments[tournamentId].isEnded;
if(isEnded){
for(uint tidx = 0; tidx < tournaments[tournamentId].teams.length; tidx++){
Team memory team = tournaments[tournamentId].teams[tidx];
if(team.isChampion){
uint tournamentSupportAmount = _getTournamentSupportAmount(tournamentId);
uint teamSupportAmount = _getTeamSupportAmount(tournamentId, team.id);
uint userSupportAmount = _getUserSupportForTeamInTournament(tournamentId, team.id);
uint gainAmount = (userSupportAmount.mul(tournamentSupportAmount)).div(teamSupportAmount);
winAmount = (gainAmount.mul(_commissionScale.sub(_commissionNumber))).div(_commissionScale);
}
}
}else{
winAmount = 0;
}
}
}
function knockoutTeam(uint tournamentId, uint teamId) public onlyOwner{
require(tournaments[tournamentId].initialized);
require(!tournaments[tournamentId].isEnded);
for(uint tidx = 0; tidx < tournaments[tournamentId].teams.length; tidx++){
Team storage team = tournaments[tournamentId].teams[tidx];
if(team.id == teamId){
team.isKnockout = true;
}
}
}
event endTournamentSuccess(uint tourId);
function endTournament(uint tournamentId, uint championTeamId) public onlyOwner{
require(tournaments[tournamentId].initialized);
require(!tournaments[tournamentId].isEnded);
tournaments[tournamentId].isEnded = true;
uint tournamentSupportAmount = _getTournamentSupportAmount(tournaments[tournamentId].id);
uint teamSupportAmount = _getTeamSupportAmount(tournaments[tournamentId].id, championTeamId);
uint totalClearAmount = 0;
for(uint tidx = 0; tidx < tournaments[tournamentId].teams.length; tidx++){
Team storage team = tournaments[tournamentId].teams[tidx];
if(team.id == championTeamId){
team.isChampion = true;
break;
}
}
for(uint idx = 0 ; idx < tournaments[tournamentId].tickets.length; idx++){
SupportTicket memory ticket = tournaments[tournamentId].tickets[idx];
if(ticket.teamId == championTeamId){
if(teamSupportAmount != 0){
uint gainAmount = (ticket.supportAmount.mul(tournamentSupportAmount)).div(teamSupportAmount);
uint actualGainAmount = (gainAmount.mul(_commissionScale.sub(_commissionNumber))).div(_commissionScale);
_internalToken.ownerTransferFrom(this, ticket.supportAddres, actualGainAmount);
totalClearAmount = totalClearAmount.add(actualGainAmount);
}
}
}
_internalToken.ownerTransferFrom(this, owner, tournamentSupportAmount.sub(totalClearAmount));
endTournamentSuccess(tournamentId);
}
event lockTournamentSuccess(uint tourId, bool isLock);
function lockTournament(uint tournamentId, bool isLock) public onlyOwner{
require(tournaments[tournamentId].initialized);
require(!tournaments[tournamentId].isEnded);
tournaments[tournamentId].isLockedForSupport = isLock;
lockTournamentSuccess(tournamentId, isLock);
}
}
| 145,234 | 1,087 |
2dd66f1d3c0989bc9c4b8a648588d3197d6c13b9c3d8bec9c2299cb72918d466
| 25,025 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0x3d2c1a6f5f6ad142df6090d0789414e2e1df5e0f.sol
| 6,910 | 23,916 |
pragma solidity ^0.4.24;
interface CitizenInterface {
function addEarlyIncome(address _sender) external payable;
function pushTicketRefIncome(address _sender) external payable;
function addTicketEthSpend(address _citizen, uint256 _value) external payable;
function addWinIncome(address _citizen, uint256 _value) external;
function pushEarlyIncome() external payable;
function getRef(address _address) external view returns(address);
function isCitizen(address _address) external view returns(bool);
}
interface DAAInterface {
function pushDividend() external payable;
}
library SafeMath {
int256 constant private INT256_MIN = -2**255;
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function mul(int256 a, int256 b) internal pure returns (int256) {
if (a == 0) {
return 0;
}
require(!(a == -1 && b == INT256_MIN));
int256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
return c;
}
function div(int256 a, int256 b) internal pure returns (int256) {
require(b != 0);
require(!(b == -1 && a == INT256_MIN));
int256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function sub(int256 a, int256 b) internal pure returns (int256) {
int256 c = a - b;
require((b >= 0 && c <= a) || (b < 0 && c > a));
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function add(int256 a, int256 b) internal pure returns (int256) {
int256 c = a + b;
require((b >= 0 && c >= a) || (b < 0 && c < a));
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
library Helper {
using SafeMath for uint256;
function bytes32ToUint(bytes32 n)
public
pure
returns (uint256)
{
return uint256(n);
}
function stringToBytes32(string memory source)
public
pure
returns (bytes32 result)
{
bytes memory tempEmptyStringTest = bytes(source);
if (tempEmptyStringTest.length == 0) {
return 0x0;
}
assembly {
result := mload(add(source, 32))
}
}
function stringToUint(string memory source)
public
pure
returns (uint256)
{
return bytes32ToUint(stringToBytes32(source));
}
function validUsername(string _username)
public
pure
returns(bool)
{
uint256 len = bytes(_username).length;
if ((len < 4) || (len > 18)) return false;
if (bytes(_username)[len-1] == 32) return false;
return uint256(bytes(_username)[0]) != 48;
}
function getRandom(uint256 _seed, uint256 _range)
public
pure
returns(uint256)
{
if (_range == 0) return _seed;
return (_seed % _range) + 1;
}
}
contract Ticket {
using SafeMath for uint256;
modifier buyable() {
require(block.timestamp > round[currentRound].startRound, "Not start, back later please");
require(block.timestamp < round[currentRound].endRoundByClock1&&(round[currentRound].endRoundByClock2==0 ||block.timestamp < round[currentRound].endRoundByClock2), "round over");
_;
}
modifier onlyAdmin() {
require(msg.sender == devTeam1, "admin required");
_;
}
modifier registered(){
require(citizenContract.isCitizen(msg.sender), "must be a citizen");
_;
}
modifier onlyCoreContract() {
require(isCoreContract[msg.sender], "admin required");
_;
}
event BuyATicket(address indexed buyer,
uint256 ticketFrom,
uint256 ticketTo,
uint256 creationDate);
address devTeam1;
address devTeam2;
address devTeam3;
address devTeam4;
uint256 TICKET_PRICE = 2*10**15;
uint256 constant public ZOOM = 1000;
uint256 constant public PBASE = 24;
uint256 constant public RDIVIDER = 50000;
uint256 constant public PMULTI = 48;
uint256 constant public EARLY_PERCENT = 20;
uint256 constant public EARLY_PERCENT_FOR_CURRENT = 70;
uint256 constant public EARLY_PERCENT_FOR_PREVIOUS = 30;
uint256 constant public REVENUE_PERCENT = 17;
uint256 constant public DEV_PERCENT = 3;
uint256 constant public DIVIDEND_PERCENT = 10;
uint256 constant public REWARD_PERCENT = 50;
uint256 constant public LAST_BUY_PERCENT = 20;
uint8[6] public JACKPOT_PERCENT = [uint8(25),5,5,5,5,5];
uint256 constant public MOST_SPENDER_PERCENT = 5;
uint256 constant public MOST_F1_EARNED_PERCENT = 4;
uint8[5] public DRAW_PERCENT = [uint8(6),1,1,1,1];
uint256 constant public NEXTROUND_PERCENT = 20;
uint256 constant public F1_LIMIT = 1 ether;
uint8 constant public MULTI_TICKET = 3;
uint256 constant public LIMMIT_CLOCK_2_ETH = 300 ether;
uint256 constant public ONE_MIN = 60;
uint256 constant public ONE_HOUR = 3600;
uint256 constant public ONE_DAY = 24 * ONE_HOUR;
CitizenInterface public citizenContract;
DAAInterface public DAAContract;
mapping (address => bool) public isCoreContract;
uint256 public coreContractSum;
address[] public coreContracts;
struct Round {
uint256 priviousTicketSum;
uint256 ticketSum;
uint256 totalEth;
uint256 totalEthRoundSpend;
address[] participant;
mapping(address => uint256) participantTicketAmount;
mapping(address => uint256) citizenTicketSpend;
mapping(address => uint256) RefF1Sum;
mapping(uint256 => Slot) ticketSlot;
uint256 ticketSlotSum;
mapping(address => uint256[]) pSlot;
uint256 earlyIncomeMarkSum;
mapping(address => uint256) earlyIncomeMark;
uint256 startRound;
uint256 endRoundByClock1;
uint256 endRoundByClock2;
uint256 endRound;
uint8 numberClaimed;
bool is_running_clock2;
}
uint256 public totalEthSpendTicket;
uint256 public ticketSum;
mapping(address => uint256) public ticketSumByAddress;
mapping(uint256=> Round) public round;
uint256 public currentRound=0;
mapping(address => uint256) earlyIncomeRoundPulled;
address[4] mostSpender;
address[4] mostF1Earnerd;
mapping(address => uint256) mostF1EarnerdId;
mapping(address => uint256) mostSpenderId;
mapping(uint256 => address[]) roundWinner;
struct Slot {
address buyer;
uint256 ticketFrom;
uint256 ticketTo;
}
constructor (address[4] _devTeam)
public
{
devTeam1 = _devTeam[0];
devTeam2 = _devTeam[1];
devTeam3 = _devTeam[2];
devTeam4 = _devTeam[3];
currentRound=0;
round[currentRound].startRound = 1560693600;
round[currentRound].endRoundByClock1 = round[currentRound].startRound.add(48*ONE_HOUR);
round[currentRound].endRound = round[currentRound].endRoundByClock1;
}
function joinNetwork(address[3] _contract)
public
{
require(address(citizenContract) == 0x0,"already setup");
citizenContract = CitizenInterface(_contract[2]);
DAAContract = DAAInterface(_contract[0]);
for(uint256 i =0; i<3; i++){
isCoreContract[_contract[i]]=true;
coreContracts.push(_contract[i]);
}
coreContractSum = 3;
}
function addCoreContract(address _address) public
onlyAdmin()
{
require(_address!=0x0,"Invalid address");
isCoreContract[_address] = true;
coreContracts.push(_address);
coreContractSum+=1;
}
function getRestHour() private view returns(uint256){
uint256 tempCurrentRound;
if (now>round[currentRound].startRound){
tempCurrentRound=currentRound;
}
else{
tempCurrentRound=currentRound-1;
}
if (now>round[tempCurrentRound].endRound) return 0;
return round[tempCurrentRound].endRound.sub(now);
}
function getRestHourClock2() private view returns(uint256){
if (round[currentRound].is_running_clock2){
if ((round[currentRound].endRoundByClock2.sub(now)).div(ONE_HOUR)>0){
return (round[currentRound].endRoundByClock2.sub(now)).div(ONE_HOUR);
}
return 0;
}
return 48;
}
function getTicketPrice() public view returns(uint256){
if (round[currentRound].is_running_clock2){
return TICKET_PRICE + TICKET_PRICE*(50-getRestHourClock2())*4/100;
}
return TICKET_PRICE;
}
function softMostF1(address _ref) private {
uint256 citizen_spender = round[currentRound].RefF1Sum[_ref];
uint256 i=1;
while (i<4) {
if (mostF1Earnerd[i]==0x0||(mostF1Earnerd[i]!=0x0&&round[currentRound].RefF1Sum[mostF1Earnerd[i]]<citizen_spender)){
if (mostF1EarnerdId[_ref]!=0&&mostF1EarnerdId[_ref]<i){
break;
}
if (mostF1EarnerdId[_ref]!=0){
mostF1Earnerd[mostF1EarnerdId[_ref]]=0x0;
}
address temp1 = mostF1Earnerd[i];
address temp2;
uint256 j=i+1;
while (j<4&&temp1!=0x0){
temp2 = mostF1Earnerd[j];
mostF1Earnerd[j]=temp1;
mostF1EarnerdId[temp1]=j;
temp1 = temp2;
j++;
}
mostF1Earnerd[i]=_ref;
mostF1EarnerdId[_ref]=i;
break;
}
i++;
}
}
function softMostSpender(address _ref) private {
uint256 citizen_spender = round[currentRound].citizenTicketSpend[_ref];
uint256 i=1;
while (i<4) {
if (mostSpender[i]==0x0||(mostSpender[i]!=0x0&&round[currentRound].citizenTicketSpend[mostSpender[i]]<citizen_spender)){
if (mostSpenderId[_ref]!=0&&mostSpenderId[_ref]<i){
break;
}
if (mostSpenderId[_ref]!=0){
mostSpender[mostSpenderId[_ref]]=0x0;
}
address temp1 = mostSpender[i];
address temp2;
uint256 j=i+1;
while (j<4&&temp1!=0x0){
temp2 = mostSpender[j];
mostSpender[j]=temp1;
mostSpenderId[temp1]=j;
temp1 = temp2;
j++;
}
mostSpender[i]=_ref;
mostSpenderId[_ref]=i;
break;
}
i++;
}
}
function addTicketEthSpend(address _sender,uint256 _value) private{
citizenContract.addTicketEthSpend(_sender,_value);
address refAdress = citizenContract.getRef(_sender);
if (refAdress != devTeam3 && round[currentRound].citizenTicketSpend[_sender]<F1_LIMIT){
uint256 valueFromF1;
if (round[currentRound].citizenTicketSpend[_sender].add(_value)>F1_LIMIT){
uint256 temp = round[currentRound].citizenTicketSpend[_sender].add(_value).sub(F1_LIMIT);
valueFromF1 = _value.sub(temp);
} else {
valueFromF1 = _value;
}
round[currentRound].RefF1Sum[refAdress] = round[currentRound].RefF1Sum[refAdress].add(valueFromF1);
softMostF1(refAdress);
}
round[currentRound].citizenTicketSpend[_sender] = round[currentRound].citizenTicketSpend[_sender].add(_value);
softMostSpender(_sender);
totalEthSpendTicket = totalEthSpendTicket.add(_value);
}
function isAddressTicket(uint256 _round,uint256 _slot, uint256 _ticket) private view returns(bool){
Slot storage temp = round[_round].ticketSlot[_slot];
if (temp.ticketFrom<=_ticket&&_ticket<=temp.ticketTo) return true;
return false;
}
function getAddressTicket(uint256 _round, uint256 _ticket) public view returns(address){
uint256 _from = 0;
uint256 _to = round[_round].ticketSlotSum;
uint256 _mid;
while(_from<=_to){
_mid = (_from+_to).div(2);
if (isAddressTicket(_round,_mid,_ticket)) return round[_round].ticketSlot[_mid].buyer;
if (_ticket<round[_round].ticketSlot[_mid].ticketFrom){
_to = _mid-1;
}
else {
_from = _mid+1;
}
}
return round[_round].ticketSlot[_mid].buyer;
}
function drawWinner() public registered() {
require(round[currentRound].endRound.add(ONE_MIN)<now);
address lastbuy = round[currentRound].ticketSlot[round[currentRound].ticketSlotSum].buyer;
roundWinner[currentRound].push(lastbuy);
uint256 arward_last_buy = round[currentRound].totalEth*LAST_BUY_PERCENT/100;
lastbuy.transfer(arward_last_buy);
citizenContract.addWinIncome(lastbuy,arward_last_buy);
mostSpender[1].transfer(round[currentRound].totalEth*MOST_SPENDER_PERCENT/100);
citizenContract.addWinIncome(mostSpender[1],round[currentRound].totalEth*MOST_SPENDER_PERCENT/100);
mostF1Earnerd[1].transfer(round[currentRound].totalEth*MOST_F1_EARNED_PERCENT/100);
citizenContract.addWinIncome(mostF1Earnerd[1],round[currentRound].totalEth*MOST_F1_EARNED_PERCENT/100);
roundWinner[currentRound].push(mostSpender[1]);
roundWinner[currentRound].push(mostF1Earnerd[1]);
uint256 _seed = getSeed();
for (uint256 i = 0; i < 6; i++){
uint256 winNumber = Helper.getRandom(_seed, round[currentRound].ticketSum);
if (winNumber==0) winNumber= round[currentRound].ticketSum;
address winCitizen = getAddressTicket(currentRound,winNumber);
winCitizen.transfer(round[currentRound].totalEth.mul(JACKPOT_PERCENT[i]).div(100));
citizenContract.addWinIncome(winCitizen,round[currentRound].totalEth.mul(JACKPOT_PERCENT[i]).div(100));
roundWinner[currentRound].push(winCitizen);
_seed = _seed + (_seed / 10);
}
uint256 totalEthLastRound = round[currentRound].totalEth*NEXTROUND_PERCENT/100;
delete mostSpender;
delete mostF1Earnerd;
currentRound = currentRound+1;
round[currentRound].startRound = now.add(12*ONE_HOUR);
round[currentRound].totalEth = totalEthLastRound;
round[currentRound].endRoundByClock1 = now.add(60*ONE_HOUR);
round[currentRound].endRound = round[currentRound].endRoundByClock1;
claim();
}
function claim() public registered() {
require(currentRound>0&&round[currentRound].ticketSum==0);
uint256 lastRound = currentRound-1;
require(round[lastRound].numberClaimed<5);
require(round[lastRound].endRound.add(ONE_MIN)<now);
address _sender = msg.sender;
roundWinner[lastRound].push(_sender);
uint256 numberClaimed = round[lastRound].numberClaimed;
uint256 _arward = round[currentRound-1].totalEth*DRAW_PERCENT[numberClaimed]/1000;
_sender.transfer(_arward);
citizenContract.addWinIncome(_sender,_arward);
round[lastRound].numberClaimed = round[lastRound].numberClaimed+1;
round[lastRound].endRound = now.add(5*ONE_MIN);
}
function getEarlyIncomeMark(uint256 _ticketSum) public pure returns(uint256){
uint256 base = _ticketSum * ZOOM / RDIVIDER;
uint256 expo = base.mul(base).mul(base);
expo = expo.mul(expo).mul(PMULTI);
expo = expo.div(ZOOM**5);
return (1 + PBASE*ZOOM / (1*ZOOM + expo));
}
function buyTicket(uint256 _quantity) payable public registered() buyable() returns(bool) {
uint256 ethDeposit = msg.value;
address _sender = msg.sender;
require(_quantity*getTicketPrice()==ethDeposit,"Not enough eth for current quantity");
if (now>=round[currentRound].startRound.add(ONE_DAY)){
uint256 extraTime = _quantity.mul(30);
if (round[currentRound].endRoundByClock1.add(extraTime)>now.add(ONE_DAY)){
round[currentRound].endRoundByClock1 = now.add(ONE_DAY);
} else {
round[currentRound].endRoundByClock1 = round[currentRound].endRoundByClock1.add(extraTime);
}
}
addTicketEthSpend(_sender, ethDeposit);
if (round[currentRound].participantTicketAmount[_sender]==0){
round[currentRound].participant.push(_sender);
}
if(round[currentRound].is_running_clock2){
_quantity=_quantity.mul(MULTI_TICKET);
}
uint256 ticketSlotSumTemp = round[currentRound].ticketSlotSum.add(1);
round[currentRound].ticketSlotSum = ticketSlotSumTemp;
round[currentRound].ticketSlot[ticketSlotSumTemp].buyer = _sender;
round[currentRound].ticketSlot[ticketSlotSumTemp].ticketFrom = round[currentRound].ticketSum+1;
uint256 earlyIncomeMark = getEarlyIncomeMark(round[currentRound].ticketSum);
earlyIncomeMark = earlyIncomeMark.mul(_quantity);
round[currentRound].earlyIncomeMarkSum = earlyIncomeMark.add(round[currentRound].earlyIncomeMarkSum);
round[currentRound].earlyIncomeMark[_sender] = earlyIncomeMark.add(round[currentRound].earlyIncomeMark[_sender]);
round[currentRound].ticketSum = round[currentRound].ticketSum.add(_quantity);
ticketSum = ticketSum.add(_quantity);
ticketSumByAddress[_sender] = ticketSumByAddress[_sender].add(_quantity);
round[currentRound].ticketSlot[ticketSlotSumTemp].ticketTo = round[currentRound].ticketSum;
round[currentRound].participantTicketAmount[_sender] = round[currentRound].participantTicketAmount[_sender].add(_quantity);
round[currentRound].pSlot[_sender].push(ticketSlotSumTemp);
emit BuyATicket(_sender, round[currentRound].ticketSlot[ticketSlotSumTemp].ticketFrom, round[currentRound].ticketSlot[ticketSlotSumTemp].ticketTo, now);
uint256 earlyIncome= ethDeposit*EARLY_PERCENT/100;
citizenContract.pushEarlyIncome.value(earlyIncome)();
uint256 revenue = ethDeposit*REVENUE_PERCENT/100;
citizenContract.pushTicketRefIncome.value(revenue)(_sender);
uint256 devidend = ethDeposit*DIVIDEND_PERCENT/100;
DAAContract.pushDividend.value(devidend)();
uint256 devTeamPaid = ethDeposit*DEV_PERCENT/100;
devTeam1.transfer(devTeamPaid);
uint256 rewardPaid = ethDeposit*REWARD_PERCENT/100;
round[currentRound].totalEth = rewardPaid.add(round[currentRound].totalEth);
round[currentRound].totalEthRoundSpend = ethDeposit.add(round[currentRound].totalEthRoundSpend);
if (round[currentRound].is_running_clock2==false&&((currentRound==0 && round[currentRound].totalEth>=LIMMIT_CLOCK_2_ETH)||(currentRound>0&&round[currentRound].totalEth>round[currentRound-1].totalEth))){
round[currentRound].is_running_clock2=true;
round[currentRound].endRoundByClock2 = now.add(48*ONE_HOUR);
}
uint256 tempEndRound = round[currentRound].endRoundByClock2;
if (round[currentRound].endRoundByClock2>round[currentRound].endRoundByClock1||round[currentRound].endRoundByClock2==0){
tempEndRound = round[currentRound].endRoundByClock1;
}
round[currentRound].endRound = tempEndRound;
return true;
}
function getEarlyIncomeView(address _sender, bool _current) public view returns(uint256){
uint256 _last_round = earlyIncomeRoundPulled[_sender];
uint256 _currentRound = currentRound;
if (_current) {
_currentRound = _currentRound.add(1);
}
if (_last_round + 100 < _currentRound) _last_round = _currentRound - 100;
uint256 _sum;
for (uint256 i = _last_round;i<_currentRound;i++){
_sum = _sum.add(getEarlyIncomeByRound(_sender, i));
}
return _sum;
}
function getEarlyIncomePull(address _sender) onlyCoreContract() public returns(uint256){
uint256 _last_round = earlyIncomeRoundPulled[_sender];
if (_last_round + 100 < currentRound) _last_round = currentRound - 100;
uint256 _sum;
for (uint256 i = _last_round;i<currentRound;i++){
_sum = _sum.add(getEarlyIncomeByRound(_sender, i));
}
earlyIncomeRoundPulled[_sender] = currentRound;
return _sum;
}
function getEarlyIncomeByRound(address _buyer, uint256 _round) public view returns(uint256){
uint256 _previous_round;
_previous_round = _round-1;
if (_round==0) _previous_round = 0;
uint256 _sum=0;
uint256 _totalEth = round[_round].totalEthRoundSpend*EARLY_PERCENT/100;
uint256 _currentAmount = _totalEth*EARLY_PERCENT_FOR_CURRENT/100;
uint256 _previousAmount = _totalEth*EARLY_PERCENT_FOR_PREVIOUS/100;
if (round[_round].earlyIncomeMarkSum>0){
_sum = round[_round].earlyIncomeMark[_buyer].mul(_currentAmount).div(round[_round].earlyIncomeMarkSum);
}
if (round[_previous_round].earlyIncomeMarkSum>0){
_sum = _sum.add(round[_previous_round].earlyIncomeMark[_buyer].mul(_previousAmount).div(round[_previous_round].earlyIncomeMarkSum));
}
return _sum;
}
function getSeed()
public
view
returns (uint64)
{
return uint64(keccak256(block.timestamp, block.difficulty));
}
function sendTotalEth() onlyAdmin() public {
DAAContract.pushDividend.value(address(this).balance)();
round[currentRound].totalEth=0;
}
function getMostSpender() public view returns(address[4]){
return mostSpender;
}
function getMostF1Earnerd() public view returns(address[4]){
return mostF1Earnerd;
}
function getResultWinner(uint256 _round) public view returns(address[]){
require(_round<currentRound);
return roundWinner[_round];
}
function getCitizenTicketSpend(uint256 _round, address _sender) public view returns(uint256){
return round[_round].citizenTicketSpend[_sender];
}
function getCititzenTicketSum(uint256 _round) public view returns(uint256){
address _sender =msg.sender;
return round[_round].participantTicketAmount[_sender];
}
function getRefF1Sum(uint256 _round, address _sender) public view returns(uint256){
return round[_round].RefF1Sum[_sender];
}
function getLastBuy(uint256 _round) public view returns(address){
return round[_round].ticketSlot[round[_round].ticketSlotSum].buyer;
}
function getCitizenSumSlot(uint256 _round) public view returns(uint256){
address _sender = msg.sender;
return round[_round].pSlot[_sender].length;
}
function getCitizenSlotId(uint256 _round, uint256 _id) public view returns(uint256){
address _sender = msg.sender;
return round[_round].pSlot[_sender][_id];
}
function getCitizenSlot(uint256 _round, uint256 _slotId) public view returns(address, uint256, uint256){
Slot memory _slot = round[_round].ticketSlot[_slotId];
return (_slot.buyer,_slot.ticketFrom,_slot.ticketTo);
}
}
| 163,601 | 1,088 |
c5500696807535b649109c5b9300918605ab97f665358d5f6e4c07e1a7de292c
| 13,708 |
.sol
|
Solidity
| false |
402020685
|
ovnstable/ovnstable-core
|
4f265bddb8e4cc6a32dadd7775c551fe7fe70f83
|
pkg/strategies/polygon/contracts/StrategyUniV3DaiUsdt.sol
| 3,987 | 13,548 |
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.0 <0.9.0;
import "@overnight-contracts/core/contracts/Strategy.sol";
import "@overnight-contracts/connectors/contracts/stuff/UniswapV3.sol";
import "@overnight-contracts/connectors/contracts/stuff/Chainlink.sol";
import "@overnight-contracts/connectors/contracts/stuff/Synapse.sol";
import "@overnight-contracts/common/contracts/libraries/OvnMath.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
contract StrategyUniV3DaiUsdt is Strategy, IERC721Receiver {
// --- params
IERC20 public usdc;
IERC20 public usdt;
IERC20 public dai;
IPriceFeed public oracleUsdc;
IPriceFeed public oracleUsdt;
IPriceFeed public oracleDai;
ISwap public synapse;
INonfungiblePositionManager public npm;
uint24 public fee;
IUniswapV3Pool public pool;
int24 public tickLower;
int24 public tickUpper;
uint256 public tokenId;
uint256 public usdcDm;
uint256 public usdtDm;
uint256 public daiDm;
uint256 allowedSwapSlippage;
uint256 allowedStakeSlippage;
// --- events
event StrategyUpdatedParams();
// --- structs
struct StrategyParams {
address usdc;
address usdt;
address dai;
address oracleUsdc;
address oracleUsdt;
address oracleDai;
address synapse;
address npm;
uint24 fee;
address pool;
int24 tickLower;
int24 tickUpper;
uint256 allowedSwapSlippage;
uint256 allowedStakeSlippage;
}
// --- constructor
/// @custom:oz-upgrades-unsafe-allow constructor
constructor() initializer {}
function initialize() initializer public {
__Strategy_init();
}
// --- setters
function setParams(StrategyParams calldata params) external onlyAdmin {
usdc = IERC20(params.usdc);
usdt = IERC20(params.usdt);
dai = IERC20(params.dai);
oracleUsdc = IPriceFeed(params.oracleUsdc);
oracleUsdt = IPriceFeed(params.oracleUsdt);
oracleDai = IPriceFeed(params.oracleDai);
synapse = ISwap(params.synapse);
npm = INonfungiblePositionManager(params.npm);
pool = IUniswapV3Pool(params.pool);
fee = params.fee;
tickLower = params.tickLower;
tickUpper = params.tickUpper;
allowedSwapSlippage = params.allowedSwapSlippage;
allowedStakeSlippage = params.allowedStakeSlippage;
usdcDm = 10 ** IERC20Metadata(params.usdc).decimals();
usdtDm = 10 ** IERC20Metadata(params.usdt).decimals();
daiDm = 10 ** IERC20Metadata(params.dai).decimals();
dai.approve(address(npm), type(uint256).max);
usdt.approve(address(npm), type(uint256).max);
emit StrategyUpdatedParams();
}
// --- logic
function _stake(address _asset,
uint256 _amount) internal override {
require(isSamePrices(), "The pool is very unbalanced");
uint256 sellBound = 10**7;
if (daiToUsd(dai.balanceOf(address(this))) > sellBound) {
SynapseLibrary.swap(synapse, address(dai), address(usdc), dai.balanceOf(address(this)), 0);
}
if (usdtToUsd(usdt.balanceOf(address(this))) > sellBound) {
SynapseLibrary.swap(synapse, address(usdt), address(usdc), usdt.balanceOf(address(this)), 0);
}
_amount = usdc.balanceOf(address(this));
(uint256 am0, uint256 am1) = getPoolPrice(_amount);
uint256 daiBalance = _amount * am0 / (am0 + am1);
uint256 usdtBalance = _amount - daiBalance;
uint256 daiAmountMin = OvnMath.subBasisPoints(usdToDai(usdcToUsd(daiBalance)), allowedSwapSlippage);
uint256 usdtAmountMin = OvnMath.subBasisPoints(usdToUsdt(usdcToUsd(usdtBalance)), allowedSwapSlippage);
SynapseLibrary.swap(synapse, address(usdc), address(dai), daiBalance, daiAmountMin);
SynapseLibrary.swap(synapse, address(usdc), address(usdt), usdtBalance, usdtAmountMin);
uint256 daiAmount = dai.balanceOf(address(this));
uint256 usdtAmount = usdt.balanceOf(address(this));
if (tokenId == 0) {
INonfungiblePositionManager.MintParams memory params = INonfungiblePositionManager.MintParams({
token0 : address(dai),
token1 : address(usdt),
fee: fee,
tickLower : tickLower,
tickUpper : tickUpper,
amount0Desired : daiAmount,
amount1Desired : usdtAmount,
amount0Min : 0,
amount1Min : 0,
recipient : address(this),
deadline : block.timestamp
});
(tokenId,,,) = npm.mint(params);
} else {
INonfungiblePositionManager.IncreaseLiquidityParams memory params = INonfungiblePositionManager.IncreaseLiquidityParams({
tokenId: tokenId,
amount0Desired: daiAmount,
amount1Desired: usdtAmount,
amount0Min: 0,
amount1Min: 0,
deadline: block.timestamp
});
npm.increaseLiquidity(params);
}
}
function _unstake(address _asset,
uint256 _amount,
address _beneficiary) internal override returns (uint256) {
if (tokenId == 0) {
return 0;
}
require(isSamePrices(), "The pool is very unbalanced");
uint256 _realAmount = _amount;
_amount = OvnMath.reverseSubBasisPoints(_amount, allowedSwapSlippage + allowedStakeSlippage);
(uint256 am0, uint256 am1) = getAssetPoolRatio();
uint256 p = _amount * am0 / (am0 + am1);
(uint160 sqrtPriceX96,,,,,,) = pool.slot0();
uint128 liquidity = LiquidityAmounts.getLiquidityForAmounts(sqrtPriceX96,
TickMath.getSqrtRatioAtTick(tickLower),
TickMath.getSqrtRatioAtTick(tickUpper),
usdToDai(usdcToUsd(p)),
10**20);
INonfungiblePositionManager.DecreaseLiquidityParams memory params = INonfungiblePositionManager.DecreaseLiquidityParams({
tokenId: tokenId,
liquidity: liquidity,
amount0Min: 0,
amount1Min: 0,
deadline: block.timestamp
});
npm.decreaseLiquidity(params);
INonfungiblePositionManager.CollectParams memory collectParam = INonfungiblePositionManager.CollectParams(tokenId, address(this), type(uint128).max, type(uint128).max);
npm.collect(collectParam);
uint256 daiBalance = dai.balanceOf(address(this));
uint256 usdtBalance = usdt.balanceOf(address(this));
uint256 daiAmountMin = OvnMath.subBasisPoints(usdToUsdc(daiToUsd(daiBalance)), allowedSwapSlippage);
uint256 usdtAmountMin = OvnMath.subBasisPoints(usdToUsdc(usdtToUsd(usdtBalance)), allowedSwapSlippage);
SynapseLibrary.swap(synapse, address(dai), address(usdc), daiBalance, daiAmountMin);
SynapseLibrary.swap(synapse, address(usdt), address(usdc), usdtBalance, usdtAmountMin);
return _realAmount;
}
function _unstakeFull(address _asset,
address _beneficiary) internal override returns (uint256) {
if (tokenId != 0) {
require(isSamePrices(), "The pool is very unbalanced");
(,,,,,,,uint128 liquidity,,,,) = npm.positions(tokenId);
INonfungiblePositionManager.DecreaseLiquidityParams memory params = INonfungiblePositionManager.DecreaseLiquidityParams({
tokenId: tokenId,
liquidity: liquidity,
amount0Min: 0,
amount1Min: 0,
deadline: block.timestamp
});
npm.decreaseLiquidity(params);
INonfungiblePositionManager.CollectParams memory collectParam = INonfungiblePositionManager.CollectParams(tokenId, address(this), type(uint128).max, type(uint128).max);
npm.collect(collectParam);
tokenId = 0;
}
uint256 daiBalance = dai.balanceOf(address(this));
uint256 usdtBalance = usdt.balanceOf(address(this));
uint256 daiAmountMin = OvnMath.subBasisPoints(usdToUsdc(daiToUsd(daiBalance)), allowedSwapSlippage);
uint256 usdtAmountMin = OvnMath.subBasisPoints(usdToUsdc(usdtToUsd(usdtBalance)), allowedSwapSlippage);
SynapseLibrary.swap(synapse, address(dai), address(usdc), daiBalance, daiAmountMin);
SynapseLibrary.swap(synapse, address(usdt), address(usdc), usdtBalance, usdtAmountMin);
return usdc.balanceOf(address(this));
}
function netAssetValue() external view override returns (uint256) {
return _totalValue();
}
function liquidationValue() external view override returns (uint256) {
return _totalValue();
}
function _totalValue() internal view returns (uint256) {
(uint256 balance0, uint256 balance1) = (0, 0);
if (tokenId > 0) {
(,,,,,,,uint128 liquidity,,,,) = npm.positions(tokenId);
if (liquidity > 0) {
(uint160 sqrtRatioX96,,,,,,) = pool.slot0();
uint160 sqrtRatioAX96 = TickMath.getSqrtRatioAtTick(tickLower);
uint160 sqrtRatioBX96 = TickMath.getSqrtRatioAtTick(tickUpper);
(balance0, balance1) = LiquidityAmounts.getAmountsForLiquidity(sqrtRatioX96, sqrtRatioAX96, sqrtRatioBX96, liquidity);
}
}
uint256 daiBalance = usdToUsdc(daiToUsd(balance0 + dai.balanceOf(address(this))));
uint256 usdtBalance = usdToUsdc(usdtToUsd(balance1 + usdt.balanceOf(address(this))));
return daiBalance + usdtBalance + usdc.balanceOf(address(this));
}
function getAssetPoolRatio() internal view returns (uint256, uint256) {
(uint256 amount0, uint256 amount1) = (0, 0);
(,,,,,,,uint128 liquidity,,,,) = npm.positions(tokenId);
if (liquidity > 0) {
(uint160 sqrtRatioX96,,,,,,) = pool.slot0();
uint160 sqrtRatioAX96 = TickMath.getSqrtRatioAtTick(tickLower);
uint160 sqrtRatioBX96 = TickMath.getSqrtRatioAtTick(tickUpper);
(amount0, amount1) = LiquidityAmounts.getAmountsForLiquidity(sqrtRatioX96, sqrtRatioAX96, sqrtRatioBX96, liquidity);
}
return (daiToUsd(amount0), usdtToUsd(amount1));
}
function isSamePrices() internal view returns (bool) {
(uint160 sqrtRatioX96,,,,,,) = pool.slot0();
uint256 poolPrice = getPriceBySqrtRatio(sqrtRatioX96);
uint256 oraclePrice = usdToUsdt(daiToUsd(daiDm));
uint256 deltaPrice;
if (poolPrice > oraclePrice) {
deltaPrice = poolPrice - oraclePrice;
} else {
deltaPrice = oraclePrice - poolPrice;
}
return (deltaPrice * 10000 / oraclePrice <= allowedStakeSlippage);
}
function daiToUsd(uint256 amount) public view returns (uint256) {
return amount * uint256(oracleDai.latestAnswer()) / daiDm / 100;
}
function usdtToUsd(uint256 amount) public view returns (uint256) {
return amount * uint256(oracleUsdt.latestAnswer()) / usdtDm / 100;
}
function usdcToUsd(uint256 amount) public view returns (uint256) {
return amount * uint256(oracleUsdc.latestAnswer()) / usdcDm / 100;
}
function usdToUsdc(uint256 amount) public view returns (uint256) {
return amount * 100 * usdcDm / uint256(oracleUsdc.latestAnswer());
}
function usdToDai(uint256 amount) public view returns (uint256) {
return amount * 100 * daiDm / uint256(oracleDai.latestAnswer());
}
function usdToUsdt(uint256 amount) public view returns (uint256) {
return amount * 100 * usdtDm / uint256(oracleUsdt.latestAnswer());
}
function getPoolPrice(uint256 _amount) internal view returns (uint256, uint256) {
(uint160 sqrtRatioX96,,,,,,) = pool.slot0();
uint160 sa = TickMath.getSqrtRatioAtTick(tickLower);
uint160 sb = TickMath.getSqrtRatioAtTick(tickUpper);
uint128 liquidity = LiquidityAmounts.getLiquidityForAmounts(sqrtRatioX96, sa, sb, 10**30, _amount);
uint256 amount0 = uint256(SqrtPriceMath.getAmount0Delta(sqrtRatioX96, sb, int128(liquidity)));
uint256 amount1 = uint256(SqrtPriceMath.getAmount1Delta(sa, sqrtRatioX96, int128(liquidity)));
return (daiToUsd(amount0), usdtToUsd(amount1));
}
function getPriceBySqrtRatio(uint160 sqrtRatio) public view returns (uint256) {
uint256 price = FullMath.mulDiv(uint256(sqrtRatio) * 10**10, uint256(sqrtRatio) * 10**8, 2 ** (96+96));
return price;
}
function sqrt(uint256 x) internal pure returns (uint256 y) {
uint256 z = x / 2 + 1;
y = x;
while (z < y) {
y = z;
z = (x / z + z) / 2;
}
}
function getPriceByTick(int24 tick) public view returns (uint256) {
uint160 sqrtRatio = TickMath.getSqrtRatioAtTick(tick);
uint256 price = FullMath.mulDiv(uint256(sqrtRatio) * 10**10, uint256(sqrtRatio) * 10**8, 2 ** (96+96));
return price;
}
function _claimRewards(address _beneficiary) internal override returns (uint256) {
INonfungiblePositionManager.CollectParams memory collectParam = INonfungiblePositionManager.CollectParams(tokenId, address(this), type(uint128).max, type(uint128).max);
npm.collect(collectParam);
return 0;
}
function onERC721Received(address, address, uint256, bytes memory) public virtual override returns (bytes4) {
return this.onERC721Received.selector;
}
}
| 7,772 | 1,089 |
887d2524fcf7cac05eac6fc16902a7093bb21a92742a8bef7f8441a45aa9395a
| 19,877 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x06df6fdbf7629c71aee3f468ba1ab702fa0abec9.sol
| 4,879 | 17,713 |
pragma solidity ^0.4.23;
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
emit Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
emit Unpause();
}
}
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);
}
contract BBODServiceRegistry is Ownable {
//1. Manager
//2. CustodyStorage
mapping(uint => address) public registry;
constructor(address _owner) {
owner = _owner;
}
function setServiceRegistryEntry (uint key, address entry) external onlyOwner {
registry[key] = entry;
}
}
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 (bool);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
// Gas optimization: this is cheaper than asserting 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
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 a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract ManagerInterface {
function createCustody(address) external {}
function isExchangeAlive() public pure returns (bool) {}
function isDailySettlementOnGoing() public pure returns (bool) {}
}
contract Custody {
using SafeMath for uint;
BBODServiceRegistry public bbodServiceRegistry;
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor(address _serviceRegistryAddress, address _owner) public {
bbodServiceRegistry = BBODServiceRegistry(_serviceRegistryAddress);
owner = _owner;
}
function() public payable {}
modifier liveExchangeOrOwner(address _recipient) {
var manager = ManagerInterface(bbodServiceRegistry.registry(1));
if (manager.isExchangeAlive()) {
require(msg.sender == address(manager));
if (manager.isDailySettlementOnGoing()) {
require(_recipient == address(manager), "Only manager can do this when the settlement is ongoing");
} else {
require(_recipient == owner);
}
} else {
require(msg.sender == owner, "Only owner can do this when exchange is dead");
}
_;
}
function withdraw(uint _amount, address _recipient) external liveExchangeOrOwner(_recipient) {
_recipient.transfer(_amount);
}
function transferToken(address _erc20Address, address _recipient, uint _amount)
external liveExchangeOrOwner(_recipient) {
ERC20 token = ERC20(_erc20Address);
token.transfer(_recipient, _amount);
}
function transferOwnership(address newOwner) public {
require(msg.sender == owner, "Only the owner can transfer ownership");
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract CustodyStorage {
BBODServiceRegistry public bbodServiceRegistry;
mapping(address => bool) public custodiesMap;
//Number of all custodies in the contract
uint public custodyCounter = 0;
address[] public custodiesArray;
event CustodyRemoved(address indexed custody);
constructor(address _serviceRegistryAddress) public {
bbodServiceRegistry = BBODServiceRegistry(_serviceRegistryAddress);
}
modifier onlyManager() {
require(msg.sender == bbodServiceRegistry.registry(1));
_;
}
function addCustody(address _custody) external onlyManager {
custodiesMap[_custody] = true;
custodiesArray.push(_custody);
custodyCounter++;
}
function removeCustody(address _custodyAddress, uint _arrayIndex) external onlyManager {
require(custodiesArray[_arrayIndex] == _custodyAddress);
if (_arrayIndex == custodyCounter - 1) {
//Removing last custody
custodiesMap[_custodyAddress] = false;
emit CustodyRemoved(_custodyAddress);
custodyCounter--;
return;
}
custodiesMap[_custodyAddress] = false;
//Overwriting deleted custody with the last custody in the array
custodiesArray[_arrayIndex] = custodiesArray[custodyCounter - 1];
custodyCounter--;
emit CustodyRemoved(_custodyAddress);
}
}
contract Insurance is Custody {
constructor(address _serviceRegistryAddress, address _owner)
Custody(_serviceRegistryAddress, _owner) public {}
function useInsurance (uint _amount) external {
var manager = ManagerInterface(bbodServiceRegistry.registry(1));
//Only usable for manager during settlement
require(manager.isDailySettlementOnGoing() && msg.sender == address(manager));
address(manager).transfer(_amount);
}
}
contract Manager is Pausable {
using SafeMath for uint;
mapping(address => bool) public ownerAccountsMap;
mapping(address => bool) public exchangeAccountsMap;
//SETTLEMENT PREPARATION####
enum SettlementPhase {
PREPARING, ONGOING, FINISHED
}
enum Cryptocurrency {
ETH, BBD
}
//Initially ready for a settlement
SettlementPhase public currentSettlementPhase = SettlementPhase.FINISHED;
uint public startingFeeBalance = 0;
uint public totalFeeFlows = 0;
uint public startingInsuranceBalance = 0;
uint public totalInsuranceFlows = 0;
uint public lastSettlementStartedTimestamp = 0;
uint public earliestNextSettlementTimestamp = 0;
mapping(uint => mapping(address => bool)) public custodiesServedETH;
mapping(uint => mapping(address => bool)) public custodiesServedBBD;
address public feeAccount;
address public insuranceAccount;
ERC20 public bbdToken;
CustodyStorage public custodyStorage;
address public custodyFactory;
uint public gweiBBDPriceInWei;
uint public lastTimePriceSet;
uint constant public gwei = 1000000000;
uint public maxTimeIntervalHB = 1 weeks;
uint public heartBeat = now;
constructor(address _feeAccount, address _insuranceAccount, address _bbdTokenAddress, address _custodyStorage,
address _serviceRegistryAddress) public {
//Contract creator is the first owner
ownerAccountsMap[msg.sender] = true;
feeAccount = _feeAccount;
insuranceAccount = _insuranceAccount;
bbdToken = ERC20(_bbdTokenAddress);
custodyStorage = CustodyStorage(_custodyStorage);
}
function() public payable {}
function setCustodyFactory(address _custodyFactory) external onlyOwner {
custodyFactory = _custodyFactory;
}
function pause() public onlyExchangeOrOwner {
paused = true;
}
function unpause() public onlyExchangeOrOwner {
paused = false;
}
modifier onlyAllowedInPhase(SettlementPhase _phase) {
require(currentSettlementPhase == _phase, "Not allowed in this phase");
_;
}
modifier onlyOwner() {
require(ownerAccountsMap[msg.sender] == true, "Only an owner can perform this action");
_;
}
modifier onlyExchange() {
require(exchangeAccountsMap[msg.sender] == true, "Only an exchange can perform this action");
_;
}
modifier onlyExchangeOrOwner() {
require(exchangeAccountsMap[msg.sender] == true ||
ownerAccountsMap[msg.sender] == true);
_;
}
function isDailySettlementOnGoing() external view returns (bool) {
return currentSettlementPhase != SettlementPhase.FINISHED;
}
function updateHeartBeat() external whenNotPaused onlyOwner {
heartBeat = now;
}
function isExchangeAlive() external view returns (bool) {
return now - heartBeat < maxTimeIntervalHB;
}
function addOwnerAccount(address _exchangeAccount) external onlyOwner {
ownerAccountsMap[_exchangeAccount] = true;
}
function addExchangeAccount(address _exchangeAccount) external onlyOwner whenNotPaused {
exchangeAccountsMap[_exchangeAccount] = true;
}
function rmExchangeAccount(address _exchangeAccount) external onlyOwner whenNotPaused {
exchangeAccountsMap[_exchangeAccount] = false;
}
function setBBDPrice(uint _priceInWei) external onlyExchangeOrOwner whenNotPaused
onlyAllowedInPhase(SettlementPhase.FINISHED) {
if(gweiBBDPriceInWei == 0) {
gweiBBDPriceInWei = _priceInWei;
} else {
//Max 100% daily increase in price
if(_priceInWei > gweiBBDPriceInWei) {
require(_priceInWei - gweiBBDPriceInWei <= (gweiBBDPriceInWei / 2));
//Max 50% daily decrease in price
} else if(_priceInWei < gweiBBDPriceInWei) {
require(gweiBBDPriceInWei - _priceInWei <= (gweiBBDPriceInWei / 2));
}
gweiBBDPriceInWei = _priceInWei;
}
//Price can only be set once per day
require(now - lastTimePriceSet > 23 hours);
lastTimePriceSet = now;
}
function createCustody(address _custody) external whenNotPaused onlyAllowedInPhase(SettlementPhase.FINISHED) {
require(msg.sender == custodyFactory);
custodyStorage.addCustody(_custody);
}
function removeCustody(address _custodyAddress, uint _arrayIndex) external whenNotPaused onlyExchangeOrOwner
onlyAllowedInPhase(SettlementPhase.FINISHED) {
custodyStorage.removeCustody(_custodyAddress, _arrayIndex);
}
/// @dev Exchange uses this function to withdraw ether from the contract
/// @param _amount to withdraw
/// @param _recipient to send withdrawn ether to
function withdrawFromManager(uint _amount, address _recipient) external onlyExchangeOrOwner
whenNotPaused onlyAllowedInPhase(SettlementPhase.FINISHED) {
_recipient.transfer(_amount);
}
/// @dev Users use this function to withdraw ether from their custody
/// @param _amount to withdraw
/// @param _custodyAddress to withdraw from
function withdrawFromCustody(uint _amount, address _custodyAddress,address _recipient) external onlyExchangeOrOwner
whenNotPaused onlyAllowedInPhase(SettlementPhase.FINISHED) {
Custody custody = Custody(_custodyAddress);
custody.withdraw(_amount, _recipient);
}
/// @dev Users use this function to withdraw ether from their custody
/// @param _tokenAddress of the ERC20 to withdraw from
/// @param _amount to withdraw
/// @param _custodyAddress to withdraw from
function withdrawTokensFromCustody(address _tokenAddress, uint _amount, address _custodyAddress, address _recipient)
external whenNotPaused onlyAllowedInPhase(SettlementPhase.FINISHED) onlyExchangeOrOwner {
Custody custody = Custody(_custodyAddress);
custody.transferToken(_tokenAddress, _recipient,_amount);
}
//DAILY SETTLEMENT
/// @dev This function prepares the daily settlement - resets all settlement
/// @dev scope storage variables to 0.
function startSettlementPreparation() external whenNotPaused onlyExchangeOrOwner
onlyAllowedInPhase(SettlementPhase.FINISHED) {
require(now > earliestNextSettlementTimestamp, "A settlement can happen once per day");
require(gweiBBDPriceInWei > 0, "BBD Price cannot be 0 during settlement");
lastSettlementStartedTimestamp = now;
totalFeeFlows = 0;
totalInsuranceFlows = 0;
currentSettlementPhase = SettlementPhase.ONGOING;
startingFeeBalance = feeAccount.balance +
((bbdToken.balanceOf(feeAccount) * gweiBBDPriceInWei) / gwei);
startingInsuranceBalance = insuranceAccount.balance;
}
/// @dev This function is used to process a batch of net eth flows, two arrays
/// @dev are pairs of custody addresses and the balance changes that should
/// @dev be executed. Transaction will revert if exchange rules are violated.
/// @param _custodies flow addresses
/// @param _flows flow balance changes (can be negative or positive)
/// @param _fee calculated and deducted from all batch flows
/// @param _insurance to be used
function settleETHBatch(address[] _custodies, int[] _flows, uint _fee, uint _insurance) external whenNotPaused onlyExchangeOrOwner
onlyAllowedInPhase(SettlementPhase.ONGOING) {
require(_custodies.length == _flows.length);
uint preBatchBalance = address(this).balance;
if(_insurance > 0) {
Insurance(insuranceAccount).useInsurance(_insurance);
}
for (uint flowIndex = 0; flowIndex < _flows.length; flowIndex++) {
//Every custody can be served ETH once during settlement
require(custodiesServedETH[lastSettlementStartedTimestamp][_custodies[flowIndex]] == false);
//All addresses must be custodies
require(custodyStorage.custodiesMap(_custodies[flowIndex]));
if (_flows[flowIndex] > 0) {
//10% rule
var outboundFlow = uint(_flows[flowIndex]);
//100% rule exception threshold
if(outboundFlow > 10 ether) {
//100% rule
require(getTotalBalanceFor(_custodies[flowIndex]) >= outboundFlow);
}
_custodies[flowIndex].transfer(uint(_flows[flowIndex]));
} else if (_flows[flowIndex] < 0) {
Custody custody = Custody(_custodies[flowIndex]);
custody.withdraw(uint(-_flows[flowIndex]), address(this));
}
custodiesServedETH[lastSettlementStartedTimestamp][_custodies[flowIndex]] = true;
}
if(_fee > 0) {
feeAccount.transfer(_fee);
totalFeeFlows = totalFeeFlows + _fee;
//100% rule for fee account
require(totalFeeFlows <= startingFeeBalance);
}
uint postBatchBalance = address(this).balance;
//Zero-sum guaranteed for ever batch
if(address(this).balance > preBatchBalance) {
uint leftovers = address(this).balance - preBatchBalance;
insuranceAccount.transfer(leftovers);
totalInsuranceFlows += leftovers;
//100% rule for insurance account
require(totalInsuranceFlows <= startingInsuranceBalance);
}
}
/// @dev This function is used to process a batch of net bbd flows, two arrays
/// @dev are pairs of custody addresses and the balance changes that should
/// @dev be executed. Transaction will revert if exchange rules are violated.
/// @param _custodies flow addresses
/// @param _flows flow balance changes (can be negative or positive)
/// @param _fee calculated and deducted from all batch flows
function settleBBDBatch(address[] _custodies, int[] _flows, uint _fee) external whenNotPaused onlyExchangeOrOwner
onlyAllowedInPhase(SettlementPhase.ONGOING) {
//TODO optimize for gas usage
require(_custodies.length == _flows.length);
uint preBatchBalance = bbdToken.balanceOf(address(this));
for (uint flowIndex = 0; flowIndex < _flows.length; flowIndex++) {
//Every custody can be served BBD once during settlement
require(custodiesServedBBD[lastSettlementStartedTimestamp][_custodies[flowIndex]] == false);
//All addresses must be custodies
require(custodyStorage.custodiesMap(_custodies[flowIndex]));
if (_flows[flowIndex] > 0) {
var flowValue = ((uint(_flows[flowIndex]) * gweiBBDPriceInWei)/gwei);
//Minimal BBD transfer is 1gWeiBBD
require(flowValue >= 1);
//50% rule threshold
if(flowValue > 10 ether) {
//50% rule for bbd
require((getTotalBalanceFor(_custodies[flowIndex]) / 2) >= flowValue);
}
bbdToken.transfer(_custodies[flowIndex], uint(_flows[flowIndex]));
} else if (_flows[flowIndex] < 0) {
Custody custody = Custody(_custodies[flowIndex]);
custody.transferToken(address(bbdToken),address(this), uint(-(_flows[flowIndex])));
}
custodiesServedBBD[lastSettlementStartedTimestamp][_custodies[flowIndex]] = true;
}
if(_fee > 0) {
bbdToken.transfer(feeAccount, _fee);
//No need for safe math, as transfer will trow if _fee could cause overflow
totalFeeFlows += ((_fee * gweiBBDPriceInWei) / gwei);
require (totalFeeFlows <= startingFeeBalance);
}
uint postBatchBalance = bbdToken.balanceOf(address(this));
//Zero-or-less-sum guaranteed for every batch, no insurance for spots
require(postBatchBalance <= preBatchBalance);
}
/// @dev This function is used to finish the settlement process
function finishSettlement() external whenNotPaused onlyExchangeOrOwner
onlyAllowedInPhase(SettlementPhase.ONGOING) {
//TODO phase change event?
earliestNextSettlementTimestamp = lastSettlementStartedTimestamp + 23 hours;
currentSettlementPhase = SettlementPhase.FINISHED;
}
function getTotalBalanceFor(address _custody) internal view returns (uint) {
var bbdHoldingsInWei = ((bbdToken.balanceOf(_custody) * gweiBBDPriceInWei) / gwei);
return _custody.balance + bbdHoldingsInWei;
}
function checkIfCustodiesServedETH(address[] _custodies) external view returns (bool) {
for (uint custodyIndex = 0; custodyIndex < _custodies.length; custodyIndex++) {
if(custodiesServedETH[lastSettlementStartedTimestamp][_custodies[custodyIndex]]) {
return true;
}
}
return false;
}
function checkIfCustodiesServedBBD(address[] _custodies) external view returns (bool) {
for (uint custodyIndex = 0; custodyIndex < _custodies.length; custodyIndex++) {
if(custodiesServedBBD[lastSettlementStartedTimestamp][_custodies[custodyIndex]]) {
return true;
}
}
return false;
}
}
| 216,290 | 1,090 |
0bfb5b2a955313bf21fa562fc451d3b8111012754d458352f00ab11fabc71872
| 14,752 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/69/69a33fc39ac90be7004db2dfec75cd44739cdaaf_Qi.sol
| 2,877 | 11,041 |
// File: contracts/Governance/Qi.sol
pragma solidity ^0.5.16;
pragma experimental ABIEncoderV2;
contract Qi {
/// @notice EIP-20 token name for this token
string public constant name = "BENQI";
/// @notice EIP-20 token symbol for this token
string public constant symbol = "QI";
/// @notice EIP-20 token decimals for this token
uint8 public constant decimals = 18;
/// @notice Total number of tokens in circulation
uint public constant totalSupply = 7_200_000_000e18; // 7 billion 200 million QI
/// @notice Allowance amounts on behalf of others
mapping (address => mapping (address => uint96)) internal allowances;
/// @notice Official record of token balances for each account
mapping (address => uint96) internal balances;
/// @notice A record of each accounts delegate
mapping (address => address) public delegates;
/// @notice A checkpoint for marking number of votes from a given block
struct Checkpoint {
uint32 fromBlock;
uint96 votes;
}
/// @notice A record of votes checkpoints for each account, by index
mapping (address => mapping (uint32 => Checkpoint)) public checkpoints;
/// @notice The number of checkpoints for each account
mapping (address => uint32) public numCheckpoints;
/// @notice The EIP-712 typehash for the contract's domain
bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");
/// @notice The EIP-712 typehash for the delegation struct used by the contract
bytes32 public constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");
/// @notice The EIP-712 typehash for the permit struct used by the contract
bytes32 public constant PERMIT_TYPEHASH = keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
/// @notice A record of states for signing / validating signatures
mapping (address => uint) public nonces;
/// @notice An event thats emitted when an account changes its delegate
event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);
/// @notice An event thats emitted when a delegate account's vote balance changes
event DelegateVotesChanged(address indexed delegate, uint previousBalance, uint newBalance);
/// @notice The standard EIP-20 transfer event
event Transfer(address indexed from, address indexed to, uint256 amount);
/// @notice The standard EIP-20 approval event
event Approval(address indexed owner, address indexed spender, uint256 amount);
constructor(address account) public {
balances[account] = uint96(totalSupply);
emit Transfer(address(0), account, totalSupply);
}
function allowance(address account, address spender) external view returns (uint) {
return allowances[account][spender];
}
function approve(address spender, uint rawAmount) external returns (bool) {
uint96 amount;
if (rawAmount == uint(-1)) {
amount = uint96(-1);
} else {
amount = safe96(rawAmount, "Qi::approve: amount exceeds 96 bits");
}
allowances[msg.sender][spender] = amount;
emit Approval(msg.sender, spender, amount);
return true;
}
function permit(address owner, address spender, uint rawAmount, uint deadline, uint8 v, bytes32 r, bytes32 s) external {
uint96 amount;
if (rawAmount == uint(-1)) {
amount = uint96(-1);
} else {
amount = safe96(rawAmount, "Qi::permit: amount exceeds 96 bits");
}
bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH, keccak256(bytes(name)), getChainId(), address(this)));
bytes32 structHash = keccak256(abi.encode(PERMIT_TYPEHASH, owner, spender, rawAmount, nonces[owner]++, deadline));
bytes32 digest = keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
address signatory = ecrecover(digest, v, r, s);
require(signatory != address(0), "Qi::permit: invalid signature");
require(signatory == owner, "Qi::permit: unauthorized");
require(now <= deadline, "Qi::permit: signature expired");
allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function balanceOf(address account) external view returns (uint) {
return balances[account];
}
function transfer(address dst, uint rawAmount) external returns (bool) {
uint96 amount = safe96(rawAmount, "Qi::transfer: amount exceeds 96 bits");
_transferTokens(msg.sender, dst, amount);
return true;
}
function transferFrom(address src, address dst, uint rawAmount) external returns (bool) {
address spender = msg.sender;
uint96 spenderAllowance = allowances[src][spender];
uint96 amount = safe96(rawAmount, "Qi::approve: amount exceeds 96 bits");
if (spender != src && spenderAllowance != uint96(-1)) {
uint96 newAllowance = sub96(spenderAllowance, amount, "Qi::transferFrom: transfer amount exceeds spender allowance");
allowances[src][spender] = newAllowance;
emit Approval(src, spender, newAllowance);
}
_transferTokens(src, dst, amount);
return true;
}
function delegate(address delegatee) public {
return _delegate(msg.sender, delegatee);
}
function delegateBySig(address delegatee, uint nonce, uint expiry, uint8 v, bytes32 r, bytes32 s) public {
bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH, keccak256(bytes(name)), getChainId(), address(this)));
bytes32 structHash = keccak256(abi.encode(DELEGATION_TYPEHASH, delegatee, nonce, expiry));
bytes32 digest = keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
address signatory = ecrecover(digest, v, r, s);
require(signatory != address(0), "Qi::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++, "Qi::delegateBySig: invalid nonce");
require(now <= expiry, "Qi::delegateBySig: signature expired");
return _delegate(signatory, delegatee);
}
function getCurrentVotes(address account) external view returns (uint96) {
uint32 nCheckpoints = numCheckpoints[account];
return nCheckpoints > 0 ? checkpoints[account][nCheckpoints - 1].votes : 0;
}
function getPriorVotes(address account, uint blockNumber) public view returns (uint96) {
require(blockNumber < block.number, "Qi::getPriorVotes: not yet determined");
uint32 nCheckpoints = numCheckpoints[account];
if (nCheckpoints == 0) {
return 0;
}
// First check most recent balance
if (checkpoints[account][nCheckpoints - 1].fromBlock <= blockNumber) {
return checkpoints[account][nCheckpoints - 1].votes;
}
// Next check implicit zero balance
if (checkpoints[account][0].fromBlock > blockNumber) {
return 0;
}
uint32 lower = 0;
uint32 upper = nCheckpoints - 1;
while (upper > lower) {
uint32 center = upper - (upper - lower) / 2; // ceil, avoiding overflow
Checkpoint memory cp = checkpoints[account][center];
if (cp.fromBlock == blockNumber) {
return cp.votes;
} else if (cp.fromBlock < blockNumber) {
lower = center;
} else {
upper = center - 1;
}
}
return checkpoints[account][lower].votes;
}
function _delegate(address delegator, address delegatee) internal {
address currentDelegate = delegates[delegator];
uint96 delegatorBalance = balances[delegator];
delegates[delegator] = delegatee;
emit DelegateChanged(delegator, currentDelegate, delegatee);
_moveDelegates(currentDelegate, delegatee, delegatorBalance);
}
function _transferTokens(address src, address dst, uint96 amount) internal {
require(src != address(0), "Qi::_transferTokens: cannot transfer from the zero address");
require(dst != address(0), "Qi::_transferTokens: cannot transfer to the zero address");
balances[src] = sub96(balances[src], amount, "Qi::_transferTokens: transfer amount exceeds balance");
balances[dst] = add96(balances[dst], amount, "Qi::_transferTokens: transfer amount overflows");
emit Transfer(src, dst, amount);
_moveDelegates(delegates[src], delegates[dst], amount);
}
function _moveDelegates(address srcRep, address dstRep, uint96 amount) internal {
if (srcRep != dstRep && amount > 0) {
if (srcRep != address(0)) {
uint32 srcRepNum = numCheckpoints[srcRep];
uint96 srcRepOld = srcRepNum > 0 ? checkpoints[srcRep][srcRepNum - 1].votes : 0;
uint96 srcRepNew = sub96(srcRepOld, amount, "Qi::_moveVotes: vote amount underflows");
_writeCheckpoint(srcRep, srcRepNum, srcRepOld, srcRepNew);
}
if (dstRep != address(0)) {
uint32 dstRepNum = numCheckpoints[dstRep];
uint96 dstRepOld = dstRepNum > 0 ? checkpoints[dstRep][dstRepNum - 1].votes : 0;
uint96 dstRepNew = add96(dstRepOld, amount, "Qi::_moveVotes: vote amount overflows");
_writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew);
}
}
}
function _writeCheckpoint(address delegatee, uint32 nCheckpoints, uint96 oldVotes, uint96 newVotes) internal {
uint32 blockNumber = safe32(block.number, "Qi::_writeCheckpoint: block number exceeds 32 bits");
if (nCheckpoints > 0 && checkpoints[delegatee][nCheckpoints - 1].fromBlock == blockNumber) {
checkpoints[delegatee][nCheckpoints - 1].votes = newVotes;
} else {
checkpoints[delegatee][nCheckpoints] = Checkpoint(blockNumber, newVotes);
numCheckpoints[delegatee] = nCheckpoints + 1;
}
emit DelegateVotesChanged(delegatee, oldVotes, newVotes);
}
function safe32(uint n, string memory errorMessage) internal pure returns (uint32) {
require(n < 2**32, errorMessage);
return uint32(n);
}
function safe96(uint n, string memory errorMessage) internal pure returns (uint96) {
require(n < 2**96, errorMessage);
return uint96(n);
}
function add96(uint96 a, uint96 b, string memory errorMessage) internal pure returns (uint96) {
uint96 c = a + b;
require(c >= a, errorMessage);
return c;
}
function sub96(uint96 a, uint96 b, string memory errorMessage) internal pure returns (uint96) {
require(b <= a, errorMessage);
return a - b;
}
function getChainId() internal pure returns (uint) {
uint256 chainId;
assembly { chainId := chainid() }
return chainId;
}
}
| 118,405 | 1,091 |
92f2fd4b2583083186a4adf6c8c448bede64151baf1bca4b98e3c922685a48c8
| 16,592 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0xdc24c07d023822793ce496847f6adb6687f81280.sol
| 4,060 | 16,249 |
pragma solidity ^0.4.3;
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner, "Sender not authorised.");
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract ERC20Basic {
uint256 public totalSupply;
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);
}
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 (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ERC677 is ERC20 {
function transferAndCall(address to, uint value, bytes data) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint value, bytes data);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
library itmap {
struct entry {
uint keyIndex;
uint value;
}
struct itmap {
mapping(uint => entry) data;
uint[] keys;
}
function insert(itmap storage self, uint key, uint value) internal returns (bool replaced) {
entry storage e = self.data[key];
e.value = value;
if (e.keyIndex > 0) {
return true;
} else {
e.keyIndex = ++self.keys.length;
self.keys[e.keyIndex - 1] = key;
return false;
}
}
function remove(itmap storage self, uint key) internal returns (bool success) {
entry storage e = self.data[key];
if (e.keyIndex == 0) {
return false;
}
if (e.keyIndex < self.keys.length) {
self.data[self.keys[self.keys.length - 1]].keyIndex = e.keyIndex;
self.keys[e.keyIndex - 1] = self.keys[self.keys.length - 1];
}
self.keys.length -= 1;
delete self.data[key];
return true;
}
function contains(itmap storage self, uint key) internal constant returns (bool exists) {
return self.data[key].keyIndex > 0;
}
function size(itmap storage self) internal constant returns (uint) {
return self.keys.length;
}
function get(itmap storage self, uint key) internal constant returns (uint) {
return self.data[key].value;
}
function getKey(itmap storage self, uint idx) internal constant returns (uint) {
return self.keys[idx];
}
}
contract OwnersReceiver {
function onOwnershipTransfer(address _sender, uint _value, bytes _data) public;
}
contract PoolOwners is Ownable {
using SafeMath for uint256;
using itmap for itmap.itmap;
struct Owner {
uint256 key;
uint256 percentage;
uint256 shareTokens;
mapping(address => uint256) balance;
}
mapping(address => Owner) public owners;
struct Distribution {
address token;
uint256 amount;
uint256 owners;
uint256 claimed;
mapping(address => bool) claimedAddresses;
}
mapping(uint256 => Distribution) public distributions;
mapping(address => mapping(address => uint256)) allowance;
mapping(address => bool) public tokenWhitelist;
mapping(address => uint256) public tokenBalance;
mapping(address => uint256) public totalReturned;
mapping(address => bool) public whitelist;
mapping(address => bool) public allOwners;
itmap.itmap ownerMap;
uint256 public totalContributed = 0;
uint256 public totalOwners = 0;
uint256 public totalDistributions = 0;
bool public distributionActive = false;
uint256 public distributionMinimum = 20 ether;
uint256 public precisionMinimum = 0.04 ether;
bool public locked = false;
address public wallet;
bool private contributionStarted = false;
uint256 private valuation = 4000 ether;
uint256 private hardCap = 1000 ether;
event Contribution(address indexed sender, uint256 share, uint256 amount);
event ClaimedTokens(address indexed owner, address indexed token, uint256 amount, uint256 claimedStakers, uint256 distributionId);
event TokenDistributionActive(address indexed token, uint256 amount, uint256 distributionId, uint256 amountOfOwners);
event TokenWithdrawal(address indexed token, address indexed owner, uint256 amount);
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner, uint256 amount);
event TokenDistributionComplete(address indexed token, uint256 amountOfOwners);
modifier onlyPoolOwner() {
require(allOwners[msg.sender], "You are not authorised to call this function");
_;
}
constructor(address _wallet) public {
require(_wallet != address(0), "The ETH wallet address needs to be set");
wallet = _wallet;
}
function() public payable {
require(contributionStarted, "Contribution is not active");
require(whitelist[msg.sender], "You are not whitelisted");
contribute(msg.sender, msg.value);
wallet.transfer(msg.value);
}
function addContribution(address _sender, uint256 _amount) public onlyOwner() { contribute(_sender, _amount); }
function contribute(address _sender, uint256 _amount) private {
require(!locked, "Crowdsale period over, contribution is locked");
require(!distributionActive, "Cannot contribute when distribution is active");
require(_amount >= precisionMinimum, "Amount needs to be above the minimum contribution");
require(hardCap >= _amount, "Your contribution is greater than the hard cap");
require(_amount % precisionMinimum == 0, "Your amount isn't divisible by the minimum precision");
require(hardCap >= totalContributed.add(_amount), "Your contribution would cause the total to exceed the hardcap");
totalContributed = totalContributed.add(_amount);
uint256 share = percent(_amount, valuation, 5);
Owner storage o = owners[_sender];
if (o.percentage != 0) {
o.shareTokens = o.shareTokens.add(_amount);
o.percentage = o.percentage.add(share);
} else {
o.key = totalOwners;
require(ownerMap.insert(o.key, uint(_sender)) == false, "Map replacement detected, fatal error");
totalOwners += 1;
o.shareTokens = _amount;
o.percentage = share;
allOwners[_sender] = true;
}
emit Contribution(_sender, share, _amount);
}
function whitelistWallet(address _owner) external onlyOwner() {
require(!locked, "Can't whitelist when the contract is locked");
require(_owner != address(0), "Blackhole address");
whitelist[_owner] = true;
}
function startContribution() external onlyOwner() {
require(!contributionStarted, "Contribution has started");
contributionStarted = true;
}
function setOwnerShare(address _owner, uint256 _value) public onlyOwner() {
require(!locked, "Can't manually set shares, it's locked");
require(!distributionActive, "Cannot set owners share when distribution is active");
Owner storage o = owners[_owner];
if (o.shareTokens == 0) {
allOwners[_owner] = true;
require(ownerMap.insert(totalOwners, uint(_owner)) == false, "Map replacement detected, fatal error");
o.key = totalOwners;
totalOwners += 1;
}
o.shareTokens = _value;
o.percentage = percent(_value, valuation, 5);
}
function sendOwnership(address _receiver, uint256 _amount) public onlyPoolOwner() {
_sendOwnership(msg.sender, _receiver, _amount);
}
function sendOwnershipAndCall(address _receiver, uint256 _amount, bytes _data) public onlyPoolOwner() {
_sendOwnership(msg.sender, _receiver, _amount);
if (isContract(_receiver)) {
contractFallback(_receiver, _amount, _data);
}
}
function sendOwnershipFrom(address _owner, address _receiver, uint256 _amount) public {
require(allowance[_owner][msg.sender] >= _amount, "Sender is not approved to send ownership of that amount");
allowance[_owner][msg.sender] = allowance[_owner][msg.sender].sub(_amount);
_sendOwnership(_owner, _receiver, _amount);
}
function _sendOwnership(address _owner, address _receiver, uint256 _amount) private {
Owner storage o = owners[_owner];
Owner storage r = owners[_receiver];
require(_owner != _receiver, "You can't send to yourself");
require(_receiver != address(0), "Ownership cannot be blackholed");
require(o.shareTokens > 0, "You don't have any ownership");
require(o.shareTokens >= _amount, "The amount exceeds what you have");
require(!distributionActive, "Distribution cannot be active when sending ownership");
require(_amount % precisionMinimum == 0, "Your amount isn't divisible by the minimum precision amount");
o.shareTokens = o.shareTokens.sub(_amount);
if (o.shareTokens == 0) {
o.percentage = 0;
require(ownerMap.remove(o.key) == true, "Address doesn't exist in the map, fatal error");
} else {
o.percentage = percent(o.shareTokens, valuation, 5);
}
if (r.shareTokens == 0) {
if (!allOwners[_receiver]) {
r.key = totalOwners;
allOwners[_receiver] = true;
totalOwners += 1;
}
require(ownerMap.insert(r.key, uint(_receiver)) == false, "Map replacement detected, fatal error");
}
r.shareTokens = r.shareTokens.add(_amount);
r.percentage = r.percentage.add(percent(_amount, valuation, 5));
emit OwnershipTransferred(_owner, _receiver, _amount);
}
function contractFallback(address _receiver, uint256 _amount, bytes _data) private {
OwnersReceiver receiver = OwnersReceiver(_receiver);
receiver.onOwnershipTransfer(msg.sender, _amount, _data);
}
function isContract(address _addr) private view returns (bool hasCode) {
uint length;
assembly { length := extcodesize(_addr) }
return length > 0;
}
function increaseAllowance(address _sender, uint256 _amount) public {
require(owners[msg.sender].shareTokens >= _amount, "The amount to increase allowance by is higher than your balance");
allowance[msg.sender][_sender] = allowance[msg.sender][_sender].add(_amount);
}
function decreaseAllowance(address _sender, uint256 _amount) public {
require(allowance[msg.sender][_sender] >= _amount, "The amount to decrease allowance by is higher than the current allowance");
allowance[msg.sender][_sender] = allowance[msg.sender][_sender].sub(_amount);
}
function lockShares() public onlyOwner() {
require(!locked, "Shares already locked");
locked = true;
}
function distributeTokens(address _token) public onlyPoolOwner() {
require(tokenWhitelist[_token], "Token is not whitelisted to be distributed");
require(!distributionActive, "Distribution is already active");
distributionActive = true;
ERC677 erc677 = ERC677(_token);
uint256 currentBalance = erc677.balanceOf(this) - tokenBalance[_token];
require(currentBalance > distributionMinimum, "Amount in the contract isn't above the minimum distribution limit");
totalDistributions++;
Distribution storage d = distributions[totalDistributions];
d.owners = ownerMap.size();
d.amount = currentBalance;
d.token = _token;
d.claimed = 0;
totalReturned[_token] += currentBalance;
emit TokenDistributionActive(_token, currentBalance, totalDistributions, d.owners);
}
function claimTokens(address _owner) public onlyPoolOwner() {
Owner storage o = owners[_owner];
Distribution storage d = distributions[totalDistributions];
require(o.shareTokens > 0, "You need to have a share to claim tokens");
require(distributionActive, "Distribution isn't active");
require(!d.claimedAddresses[_owner], "Tokens already claimed for this address");
address token = d.token;
uint256 tokenAmount = d.amount.mul(o.percentage).div(100000);
o.balance[token] = o.balance[token].add(tokenAmount);
tokenBalance[token] = tokenBalance[token].add(tokenAmount);
d.claimed++;
d.claimedAddresses[_owner] = true;
emit ClaimedTokens(_owner, token, tokenAmount, d.claimed, totalDistributions);
if (d.claimed == d.owners) {
distributionActive = false;
emit TokenDistributionComplete(token, totalOwners);
}
}
function batchClaim(uint256 _from, uint256 _to) public onlyPoolOwner() {
Distribution storage d = distributions[totalDistributions];
for (uint256 i = _from; i < _to; i++) {
address owner = address(ownerMap.get(i));
if (owner != 0 && !d.claimedAddresses[owner]) {
claimTokens(owner);
}
}
}
function withdrawTokens(address _token, uint256 _amount) public onlyPoolOwner() {
require(_amount > 0, "You have requested for 0 tokens to be withdrawn");
Owner storage o = owners[msg.sender];
Distribution storage d = distributions[totalDistributions];
if (distributionActive && !d.claimedAddresses[msg.sender]) {
claimTokens(msg.sender);
}
require(o.balance[_token] >= _amount, "Amount requested is higher than your balance");
o.balance[_token] = o.balance[_token].sub(_amount);
tokenBalance[_token] = tokenBalance[_token].sub(_amount);
ERC677 erc677 = ERC677(_token);
require(erc677.transfer(msg.sender, _amount) == true, "ERC20 transfer wasn't successful");
emit TokenWithdrawal(_token, msg.sender, _amount);
}
function whitelistToken(address _token) public onlyOwner() {
require(!tokenWhitelist[_token], "Token is already whitelisted");
tokenWhitelist[_token] = true;
}
function setDistributionMinimum(uint256 _minimum) public onlyOwner() {
distributionMinimum = _minimum;
}
function getOwnerBalance(address _token) public view returns (uint256) {
Owner storage o = owners[msg.sender];
return o.balance[_token];
}
function getCurrentOwners() public view returns (uint) {
return ownerMap.size();
}
function getOwnerAddress(uint _key) public view returns (address) {
return address(ownerMap.get(_key));
}
function getAllowance(address _owner, address _sender) public view returns (uint256) {
return allowance[_owner][_sender];
}
function hasClaimed(address _owner, uint256 _dId) public view returns (bool) {
Distribution storage d = distributions[_dId];
return d.claimedAddresses[_owner];
}
function percent(uint numerator, uint denominator, uint precision) private pure returns (uint quotient) {
uint _numerator = numerator * 10 ** (precision+1);
uint _quotient = ((_numerator / denominator) + 5) / 10;
return (_quotient);
}
}
| 162,705 | 1,092 |
7f72eb0066c8573e21bb652e517c4b5597e683d063f7096910c99b898beb24a6
| 14,247 |
.sol
|
Solidity
| false |
360539372
|
transaction-reverting-statements/Characterizing-require-statement-in-Ethereum-Smart-Contract
|
1d65472e1c546af6781cb17991843befc635a28e
|
dataset/dapp_contracts/Game/0x6d2e76213615925c5fc436565b5ee788ee0e86dc.sol
| 3,635 | 13,029 |
pragma solidity ^0.4.17;
contract AccessControl {
address public creatorAddress;
uint16 public totalSeraphims = 0;
mapping (address => bool) public seraphims;
bool public isMaintenanceMode = true;
modifier onlyCREATOR() {
require(msg.sender == creatorAddress);
_;
}
modifier onlySERAPHIM() {
require(seraphims[msg.sender] == true);
_;
}
modifier isContractActive {
require(!isMaintenanceMode);
_;
}
// Constructor
function AccessControl() public {
creatorAddress = msg.sender;
}
function addSERAPHIM(address _newSeraphim) onlyCREATOR public {
if (seraphims[_newSeraphim] == false) {
seraphims[_newSeraphim] = true;
totalSeraphims += 1;
}
}
function removeSERAPHIM(address _oldSeraphim) onlyCREATOR public {
if (seraphims[_oldSeraphim] == true) {
seraphims[_oldSeraphim] = false;
totalSeraphims -= 1;
}
}
function updateMaintenanceMode(bool _isMaintaining) onlyCREATOR public {
isMaintenanceMode = _isMaintaining;
}
}
contract SafeMath {
function safeAdd(uint x, uint y) pure internal returns(uint) {
uint z = x + y;
assert((z >= x) && (z >= y));
return z;
}
function safeSubtract(uint x, uint y) pure internal returns(uint) {
assert(x >= y);
uint z = x - y;
return z;
}
function safeMult(uint x, uint y) pure internal returns(uint) {
uint z = x * y;
assert((x == 0)||(z/x == y));
return z;
}
function getRandomNumber(uint16 maxRandom, uint8 min, address privateAddress) constant public returns(uint8) {
uint256 genNum = uint256(block.blockhash(block.number-1)) + uint256(privateAddress);
return uint8(genNum % (maxRandom - min + 1)+min);
}
}
contract Enums {
enum ResultCode {
SUCCESS,
ERROR_CLASS_NOT_FOUND,
ERROR_LOW_BALANCE,
ERROR_SEND_FAIL,
ERROR_NOT_OWNER,
ERROR_NOT_ENOUGH_MONEY,
ERROR_INVALID_AMOUNT
}
enum AngelAura {
Blue,
Yellow,
Purple,
Orange,
Red,
Green
}
}
contract IAngelCardData is AccessControl, Enums {
uint8 public totalAngelCardSeries;
uint64 public totalAngels;
// write
// angels
function createAngelCardSeries(uint8 _angelCardSeriesId, uint _basePrice, uint64 _maxTotal, uint8 _baseAura, uint16 _baseBattlePower, uint64 _liveTime) onlyCREATOR external returns(uint8);
function updateAngelCardSeries(uint8 _angelCardSeriesId, uint64 _newPrice, uint64 _newMaxTotal) onlyCREATOR external;
function setAngel(uint8 _angelCardSeriesId, address _owner, uint _price, uint16 _battlePower) onlySERAPHIM external returns(uint64);
function addToAngelExperienceLevel(uint64 _angelId, uint _value) onlySERAPHIM external;
function setAngelLastBattleTime(uint64 _angelId) onlySERAPHIM external;
function setAngelLastVsBattleTime(uint64 _angelId) onlySERAPHIM external;
function setLastBattleResult(uint64 _angelId, uint16 _value) onlySERAPHIM external;
function addAngelIdMapping(address _owner, uint64 _angelId) private;
function transferAngel(address _from, address _to, uint64 _angelId) onlySERAPHIM public returns(ResultCode);
function ownerAngelTransfer (address _to, uint64 _angelId) public;
function updateAngelLock (uint64 _angelId, bool newValue) public;
function removeCreator() onlyCREATOR external;
// read
function getAngelCardSeries(uint8 _angelCardSeriesId) constant public returns(uint8 angelCardSeriesId, uint64 currentAngelTotal, uint basePrice, uint64 maxAngelTotal, uint8 baseAura, uint baseBattlePower, uint64 lastSellTime, uint64 liveTime);
function getAngel(uint64 _angelId) constant public returns(uint64 angelId, uint8 angelCardSeriesId, uint16 battlePower, uint8 aura, uint16 experience, uint price, uint64 createdTime, uint64 lastBattleTime, uint64 lastVsBattleTime, uint16 lastBattleResult, address owner);
function getOwnerAngelCount(address _owner) constant public returns(uint);
function getAngelByIndex(address _owner, uint _index) constant public returns(uint64);
function getTotalAngelCardSeries() constant public returns (uint8);
function getTotalAngels() constant public returns (uint64);
function getAngelLockStatus(uint64 _angelId) constant public returns (bool);
}
contract AngelCardData is IAngelCardData, SafeMath {
event CreatedAngel(uint64 angelId);
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
struct AngelCardSeries {
uint8 angelCardSeriesId;
uint basePrice;
uint64 currentAngelTotal;
uint64 maxAngelTotal;
AngelAura baseAura;
uint baseBattlePower;
uint64 lastSellTime;
uint64 liveTime;
}
struct Angel {
uint64 angelId;
uint8 angelCardSeriesId;
address owner;
uint16 battlePower;
AngelAura aura;
uint16 experience;
uint price;
uint64 createdTime;
uint64 lastBattleTime;
uint64 lastVsBattleTime;
uint16 lastBattleResult;
bool ownerLock;
}
mapping(uint8 => AngelCardSeries) public angelCardSeriesCollection;
mapping(uint64 => Angel) public angelCollection;
mapping(address => uint64[]) public ownerAngelCollection;
uint256 public prevSeriesSelloutHours;
//
function AngelCardData() public {
}
function createAngelCardSeries(uint8 _angelCardSeriesId, uint _basePrice, uint64 _maxTotal, uint8 _baseAura, uint16 _baseBattlePower, uint64 _liveTime) onlyCREATOR external returns(uint8) {
if ((now > 1517189201) || (totalAngelCardSeries >= 24)) {revert();}
AngelCardSeries storage angelCardSeries = angelCardSeriesCollection[_angelCardSeriesId];
angelCardSeries.angelCardSeriesId = _angelCardSeriesId;
angelCardSeries.basePrice = _basePrice;
angelCardSeries.maxAngelTotal = _maxTotal;
angelCardSeries.baseAura = AngelAura(_baseAura);
angelCardSeries.baseBattlePower = _baseBattlePower;
angelCardSeries.lastSellTime = 0;
angelCardSeries.liveTime = _liveTime;
totalAngelCardSeries += 1;
return totalAngelCardSeries;
}
function updateAngelCardSeries(uint8 _angelCardSeriesId, uint64 _newPrice, uint64 _newMaxTotal) onlyCREATOR external {
// Require that the series is above the Arel card
if (_angelCardSeriesId < 4) {revert();}
//(The orginal, powerful series can't be altered.
if ((_newMaxTotal <45) || (_newMaxTotal >450)) {revert();}
//series can only be adjusted within a certain narrow range.
AngelCardSeries storage seriesStorage = angelCardSeriesCollection[_angelCardSeriesId];
seriesStorage.maxAngelTotal = _newMaxTotal;
seriesStorage.basePrice = _newPrice;
seriesStorage.lastSellTime = uint64(now);
}
function setAngel(uint8 _angelCardSeriesId, address _owner, uint _price, uint16 _battlePower) onlySERAPHIM external returns(uint64) {
AngelCardSeries storage series = angelCardSeriesCollection[_angelCardSeriesId];
if (series.currentAngelTotal >= series.maxAngelTotal) {
revert();
}
else {
totalAngels += 1;
Angel storage angel = angelCollection[totalAngels];
series.currentAngelTotal += 1;
series.lastSellTime = uint64(now);
angel.angelId = totalAngels;
angel.angelCardSeriesId = _angelCardSeriesId;
angel.owner = _owner;
angel.battlePower = _battlePower;
angel.aura = series.baseAura;
angel.experience = 0;
angel.price = _price;
angel.createdTime = uint64(now);
angel.lastBattleTime = 0;
angel.lastVsBattleTime = 0;
angel.lastBattleResult = 0;
addAngelIdMapping(_owner, angel.angelId);
angel.ownerLock = true;
return angel.angelId;
}
}
function addToAngelExperienceLevel(uint64 _angelId, uint _value) onlySERAPHIM external {
Angel storage angel = angelCollection[_angelId];
if (angel.angelId == _angelId) {
angel.experience = uint16(safeAdd(angel.experience, _value));
}
}
function setAngelLastBattleTime(uint64 _angelId) onlySERAPHIM external {
Angel storage angel = angelCollection[_angelId];
if (angel.angelId == _angelId) {
angel.lastBattleTime = uint64(now);
}
}
function setAngelLastVsBattleTime(uint64 _angelId) onlySERAPHIM external {
Angel storage angel = angelCollection[_angelId];
if (angel.angelId == _angelId) {
angel.lastVsBattleTime = uint64(now);
}
}
function setLastBattleResult(uint64 _angelId, uint16 _value) onlySERAPHIM external {
Angel storage angel = angelCollection[_angelId];
if (angel.angelId == _angelId) {
angel.lastBattleResult = _value;
}
}
function addAngelIdMapping(address _owner, uint64 _angelId) private {
uint64[] storage owners = ownerAngelCollection[_owner];
owners.push(_angelId);
Angel storage angel = angelCollection[_angelId];
angel.owner = _owner;
}
function ownerAngelTransfer (address _to, uint64 _angelId) public {
if ((_angelId > totalAngels) || (_angelId == 0)) {revert();}
Angel storage angel = angelCollection[_angelId];
if (msg.sender == _to) {revert();}
if (angel.owner != msg.sender) {
revert();
}
else {
angel.owner = _to;
addAngelIdMapping(_to, _angelId);
}
}
function transferAngel(address _from, address _to, uint64 _angelId) onlySERAPHIM public returns(ResultCode) {
Angel storage angel = angelCollection[_angelId];
if (_from == _to) {revert();}
if (angel.ownerLock == true) {revert();} //must be unlocked before transfering.
if (angel.owner != _from) {
return ResultCode.ERROR_NOT_OWNER;
}
angel.owner = _to;
addAngelIdMapping(_to, _angelId);
angel.ownerLock = true;
return ResultCode.SUCCESS;
}
function updateAngelLock (uint64 _angelId, bool newValue) public {
if ((_angelId > totalAngels) || (_angelId == 0)) {revert();}
Angel storage angel = angelCollection[_angelId];
if (angel.owner != msg.sender) { revert();}
angel.ownerLock = newValue;
}
function removeCreator() onlyCREATOR external {
creatorAddress = address(0);
}
//
function getAngelCardSeries(uint8 _angelCardSeriesId) constant public returns(uint8 angelCardSeriesId, uint64 currentAngelTotal, uint basePrice, uint64 maxAngelTotal, uint8 baseAura, uint baseBattlePower, uint64 lastSellTime, uint64 liveTime) {
AngelCardSeries memory series = angelCardSeriesCollection[_angelCardSeriesId];
angelCardSeriesId = series.angelCardSeriesId;
currentAngelTotal = series.currentAngelTotal;
basePrice = series.basePrice;
maxAngelTotal = series.maxAngelTotal;
baseAura = uint8(series.baseAura);
baseBattlePower = series.baseBattlePower;
lastSellTime = series.lastSellTime;
liveTime = series.liveTime;
}
function getAngel(uint64 _angelId) constant public returns(uint64 angelId, uint8 angelCardSeriesId, uint16 battlePower, uint8 aura, uint16 experience, uint price, uint64 createdTime, uint64 lastBattleTime, uint64 lastVsBattleTime, uint16 lastBattleResult, address owner) {
Angel memory angel = angelCollection[_angelId];
angelId = angel.angelId;
angelCardSeriesId = angel.angelCardSeriesId;
battlePower = angel.battlePower;
aura = uint8(angel.aura);
experience = angel.experience;
price = angel.price;
createdTime = angel.createdTime;
lastBattleTime = angel.lastBattleTime;
lastVsBattleTime = angel.lastVsBattleTime;
lastBattleResult = angel.lastBattleResult;
owner = angel.owner;
}
function getOwnerAngelCount(address _owner) constant public returns(uint) {
return ownerAngelCollection[_owner].length;
}
function getAngelLockStatus(uint64 _angelId) constant public returns (bool) {
if ((_angelId > totalAngels) || (_angelId == 0)) {revert();}
Angel storage angel = angelCollection[_angelId];
return angel.ownerLock;
}
function getAngelByIndex(address _owner, uint _index) constant public returns(uint64) {
if (_index >= ownerAngelCollection[_owner].length) {
return 0; }
return ownerAngelCollection[_owner][_index];
}
function getTotalAngelCardSeries() constant public returns (uint8) {
return totalAngelCardSeries;
}
function getTotalAngels() constant public returns (uint64) {
return totalAngels;
}
}
| 335,610 | 1,093 |
1d2267bab761d9266ca172a09f872213c0dc965d19c4f894d271acf5617e8803
| 13,421 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0xac625cbd6d8628f9de1b69a2e057073e0dca0a0d.sol
| 4,388 | 13,355 |
pragma solidity ^0.4.19;
contract AccessControl {
address public owner;
uint16 public totalModerators = 0;
mapping (address => bool) public moderators;
bool public isMaintaining = false;
function AccessControl() public {
owner = msg.sender;
moderators[msg.sender] = true;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
modifier onlyModerators() {
require(moderators[msg.sender] == true);
_;
}
modifier isActive {
require(!isMaintaining);
_;
}
function ChangeOwner(address _newOwner) onlyOwner public {
if (_newOwner != address(0)) {
owner = _newOwner;
}
}
function AddModerator(address _newModerator) onlyOwner public {
if (moderators[_newModerator] == false) {
moderators[_newModerator] = true;
totalModerators += 1;
}
}
function RemoveModerator(address _oldModerator) onlyOwner public {
if (moderators[_oldModerator] == true) {
moderators[_oldModerator] = false;
totalModerators -= 1;
}
}
function UpdateMaintaining(bool _isMaintaining) onlyOwner public {
isMaintaining = _isMaintaining;
}
}
contract DTT is AccessControl{
function approve(address _spender, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function balanceOf(address _addr) public returns (uint);
mapping (address => mapping (address => uint256)) public allowance;
}
contract DataBase is AccessControl{
function addMonsterObj(uint64 _monsterId,uint256 _genes,uint32 _classId,address _master,string _name,string _skills) public;
function getTotalMonster() constant public returns(uint64);
function setMonsterGene(uint64 _monsterId,uint256 _genes) public;
}
contract NFTToken is AccessControl{
function transferAuction(address _from, address _to, uint256 _value) external;
function ownerOf(uint256 _tokenId) public constant returns (address owner);
}
contract CryptoAndDragonsPresale is AccessControl{
event Bought (uint256 indexed _itemId, address indexed _owner, uint256 _price);
event Sold (uint256 indexed _itemId, address indexed _owner, uint256 _price);
event Transfer(address indexed _from, address indexed _to, uint256 _tokenId);
event Approval(address indexed _owner, address indexed _approved, uint256 _tokenId);
event Hatch(address indexed _owner, uint16 _tableId);
address public thisAddress;
address public dragonTreasureToken;
address public databaseContract;
address public ERC721Contract;
uint256 public totalClass;
uint256 public totalMonster;
uint256 public totalAuction;
uint256 private increaseRate = 0.1 ether;
uint64 public cooldownTime = 2 hours;
mapping (address => address) public masterToReferral;
mapping (uint16 => uint32[]) private EggTable;
mapping (uint8 => uint256) public EggTotal;
function setNewMonster(uint256 _genes,uint32 _classId,address _master,string _name,string _skills) onlyModerators public returns(uint64 _monsterId) {
DataBase data = DataBase(databaseContract);
uint64 monsterId = data.getTotalMonster() + 1;
data.addMonsterObj(monsterId,_genes,_classId,_master,_name,_skills);
return monsterId;
}
function setMasterToReferral(address _master, address _referral) onlyOwner public{
masterToReferral[_master] = _referral;
}
function setEggTotal(uint8 _tableNum,uint256 _tableVal) onlyOwner public{
EggTotal[_tableNum] = _tableVal;
}
function setAddresses(address _dragonTreasureToken,address _databaseContract,address _ERC721Contract) onlyOwner public{
dragonTreasureToken = _dragonTreasureToken;
databaseContract = _databaseContract;
ERC721Contract = _ERC721Contract;
}
function setEggTable(uint16 _tableNum,uint32[] _tableVals) onlyOwner public{
EggTable[_tableNum] = _tableVals;
}
function userWithdraw(uint256 _value) public{
DTT DTTtoken = DTT(dragonTreasureToken);
DTTtoken.transferFrom(this,msg.sender,_value);
}
struct Egg {
uint8 tableId;
uint32 classId;
uint256 genes;
uint256 hatchTime;
uint32 matronId;
uint32 sireId;
uint16 generation;
address master;
}
struct Auction {
uint256 classId;
uint256 monsterId;
uint256 price;
uint256 endTime;
uint8 rarity;
address bidder;
}
Egg[] public eggs;
Auction[] public auctions;
uint randNonce = 0;
function randMod(uint _modulus) internal returns(uint) {
randNonce++;
return uint(keccak256(now, msg.sender, randNonce)) % _modulus;
}
function setCooldown(uint64 _time) onlyOwner public{
cooldownTime = _time;
}
function getSortedArray(uint[] storageInt) public pure returns(uint[]) {
uint[] memory a = getCloneArray(storageInt);
quicksort(a);
return a;
}
function getCloneArray(uint[] a) private pure returns(uint[]) {
return a;
}
function swap(uint[] a, uint l, uint r) private pure {
uint t = a[l];
a[l] = a[r];
a[r] = t;
}
function getPivot(uint a, uint b, uint c) private pure returns(uint) {
if(a > b){
if(b > c){
return b;
}else{
return a > c ? c : a ;
}
}else{
if(a > c){
return a;
}else{
return b > c ? c : b ;
}
}
}
function quicksort(uint[] a) private pure {
uint left = 0;
uint right = a.length - 1;
quicksort_core(a, left, right);
}
function quicksort_core(uint[] a, uint left, uint right) private pure {
if(right <= left){
return;
}
uint l = left;
uint r = right;
uint p = getPivot(a[l], a[l+1], a[r]);
while(true){
while(a[l] < p){
l++;
}
while(p < a[r]){
r--;
}
if(r <= l){
break;
}
swap(a, l, r);
l++;
r--;
}
quicksort_core(a, left, l-1);
quicksort_core(a, r+1, right);
}
function withdrawAll () onlyOwner public {
msg.sender.transfer(this.balance);
}
function withdrawAmount (uint256 _amount) onlyOwner public {
msg.sender.transfer(_amount);
}
function addAuction(uint32 _classId, uint256 _monsterId, uint256 _price, uint8 _rarity, uint8 _endTime) onlyOwner public {
Auction memory auction = Auction({
classId: _classId,
monsterId: _monsterId,
price: _price,
rarity: _rarity,
endTime: 86400 * _endTime + now,
bidder: msg.sender
});
auctions.push(auction);
totalAuction += 1;
}
function burnAuction() onlyOwner external {
uint256 counter = 0;
for (uint256 i = 0; i < totalAuction; i++) {
if(auctions[i].endTime < now - 86400 * 3){
delete auctions[i];
counter++;
}
}
totalAuction -= counter;
}
function ceil(uint a) public pure returns (uint) {
return uint(int(a * 100) / 100);
}
function setGenes(uint256 _price, uint256 _monsterId) internal{
DataBase data = DataBase(databaseContract);
uint256 gene = _price / 10000000000000000;
if(gene > 255)
gene = 255;
uint256 genes = 0;
genes += gene * 1000000000000000;
genes += gene * 1000000000000;
genes += gene * 1000000000;
genes += gene * 1000000;
genes += gene * 1000;
genes += gene;
if(genes > 255255255255255255)
genes = 255255255255255255;
data.setMonsterGene(uint64(_monsterId),genes);
}
function buy (uint256 _auctionId, address _referral) payable public {
NFTToken CNDERC721 = NFTToken(ERC721Contract);
require(auctions[_auctionId].endTime > now);
require(CNDERC721.ownerOf(auctions[_auctionId].monsterId) != address(0));
require(ceil(msg.value) >= ceil(auctions[_auctionId].price + increaseRate));
require(CNDERC721.ownerOf(auctions[_auctionId].monsterId) != msg.sender);
require(!isContract(msg.sender));
require(msg.sender != address(0));
address oldOwner = CNDERC721.ownerOf(auctions[_auctionId].monsterId);
address newOwner = msg.sender;
uint256 oldPrice = auctions[_auctionId].price;
uint256 price = ceil(msg.value);
setGenes(price,auctions[_auctionId].monsterId);
CNDERC721.transferAuction(oldOwner, newOwner, auctions[_auctionId].monsterId);
auctions[_auctionId].price = ceil(price);
auctions[_auctionId].bidder = msg.sender;
DTT DTTtoken = DTT(dragonTreasureToken);
if(masterToReferral[msg.sender] != address(0) && masterToReferral[msg.sender] != msg.sender){
DTTtoken.approve(masterToReferral[msg.sender], DTTtoken.allowance(this,masterToReferral[msg.sender]) + price / 1000000000 * 5);
}else if(_referral != address(0) && _referral != msg.sender){
masterToReferral[msg.sender] = _referral;
DTTtoken.approve(_referral, DTTtoken.allowance(this,_referral) + price / 1000000000 * 5);
}
DTTtoken.approve(msg.sender, DTTtoken.allowance(this,msg.sender) + price / 1000000000 * 5);
if(oldPrice > 0)
oldOwner.transfer(oldPrice);
Bought(auctions[_auctionId].monsterId, newOwner, price);
Sold(auctions[_auctionId].monsterId, oldOwner, price);
}
function buyBlueStarEgg(address _sender, uint256 _tokens, uint16 _amount) isActive public returns(uint256) {
require(_amount <= 10 && _amount > 0);
uint256 price = ceil(5 * 10**8);
if (_tokens < price)
revert();
DataBase data = DataBase(databaseContract);
for (uint8 i = 0; i < _amount; i++) {
uint256 genes = 0;
genes += (randMod(205) + 51) * 1000000000000000;
genes += (randMod(205) + 51) * 1000000000000;
genes += (randMod(205) + 51) * 1000000000;
genes += (randMod(205) + 51) * 1000000;
genes += (randMod(205) + 51) * 1000;
genes += randMod(205) + 51;
uint32 classId = EggTable[1][randMod(EggTable[1].length)];
EggTotal[1] += 1;
uint64 monsterId = data.getTotalMonster() + 1;
data.addMonsterObj(monsterId,genes,classId,_sender,"","");
}
Hatch(msg.sender, 1);
return price * _amount;
}
function buyRareEgg(uint8 _table, uint _amount, address _referral) isActive payable public {
require(_amount <= 10 && _amount > 0);
uint256 price = 0.1 ether;
if(EggTotal[_table] > 0)
price += uint((int(EggTotal[_table] / 500) * 10**18) / 20);
require(msg.value >= price * _amount);
DTT DTTtoken = DTT(dragonTreasureToken);
DataBase data = DataBase(databaseContract);
uint256 bonus = 10;
if(_amount >= 10){
bonus = 12;
}
if(masterToReferral[msg.sender] != address(0) && masterToReferral[msg.sender] != msg.sender){
DTTtoken.approve(masterToReferral[msg.sender], DTTtoken.allowance(this,masterToReferral[msg.sender]) + price / 10000000000 * 5 * bonus * _amount);
}else if(_referral != address(0) && _referral != msg.sender){
masterToReferral[msg.sender] = _referral;
DTTtoken.approve(_referral, DTTtoken.allowance(this,_referral) + price / 10000000000 * 5 * bonus * _amount);
}
DTTtoken.approve(msg.sender, DTTtoken.allowance(this,msg.sender) + price / 10000000000 * 5 * bonus * _amount);
for (uint8 i = 0; i < _amount; i++) {
uint256 genes = 0;
genes += (randMod(155) + 101) * 1000000000000000;
genes += (randMod(155) + 101) * 1000000000000;
genes += (randMod(155) + 101) * 1000000000;
genes += (randMod(155) + 101) * 1000000;
genes += (randMod(155) + 101) * 1000;
genes += randMod(155) + 101;
uint32 classId = EggTable[_table][randMod(EggTable[_table].length)];
EggTotal[_table] += 1;
uint64 monsterId = data.getTotalMonster() + 1;
data.addMonsterObj(monsterId,genes,classId,msg.sender,"","");
}
Hatch(msg.sender, _table);
}
function hatchEgg(uint256 _eggId, string _name) public{
require(eggs[_eggId].hatchTime <= now);
require(eggs[_eggId].classId != 0 && eggs[_eggId].master == msg.sender);
DataBase CNDDB = DataBase(databaseContract);
uint64 monsterId = CNDDB.getTotalMonster() + 1;
string memory skills = "0:0:0:0";
CNDDB.addMonsterObj(monsterId,eggs[_eggId].genes,eggs[_eggId].classId,msg.sender,_name,skills);
eggs[_eggId].classId = 0;
eggs[_eggId].master = address(0);
}
function monstersForSale (uint8 optSort) external view returns (uint256[] _monsters){
uint256[] memory mcount = new uint256[](totalAuction);
uint256 counter = 0;
for (uint256 i = 0; i < totalAuction; i++) {
mcount[counter] = i;
counter++;
}
if(optSort != 0){
sortAuction(mcount);
}
return mcount;
}
function sortAuction (uint256[] _mcount) public view returns (uint256[] _monsters){
uint256[] memory mcount = new uint256[](_mcount.length);
for(uint256 i = 0; i < _mcount.length; i++){
mcount[i] = auctions[i].price * 10000000000 + i;
}
uint256[] memory tmps = getSortedArray(_mcount);
uint256[] memory result = new uint256[](tmps.length);
for(uint256 i2 = 0; i2 < tmps.length; i2++){
result[i2] = tmps[i2] % 10000000000;
}
return result;
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
| 164,896 | 1,094 |
0f3acb3b9bae070699d6407082cf355903c06807c35c24decd38fdf6644e3c9e
| 15,541 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x38e7a9fc20362ffe7300abd4eaaa1b99127365ee.sol
| 3,038 | 10,057 |
pragma solidity ^0.4.23;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// 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 a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
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);
}
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 (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BasicToken is ERC20Basic, Ownable {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract MintableToken is StandardToken {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Mint(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
emit MintFinished();
return true;
}
}
contract BVA is Ownable, MintableToken {
using SafeMath for uint256;
string public constant name = "BlockchainValley";
string public constant symbol = "BVA";
uint32 public constant decimals = 18;
address public addressFounders;
uint256 public summFounders;
function BVA() public {
addressFounders = 0x6e69307fe1fc55B2fffF680C5080774D117f1154;
summFounders = 35340000 * (10 ** uint256(decimals));
mint(addressFounders, summFounders);
}
}
contract Crowdsale is Ownable {
using SafeMath for uint256;
BVA public token;
//Start timestamps where investments are allowed
uint256 public startPreICO;
uint256 public endPreICO;
uint256 public startICO;
uint256 public endICO;
//Hard cap
uint256 public sumHardCapPreICO;
uint256 public sumHardCapICO;
uint256 public sumPreICO;
uint256 public sumICO;
//Min Max Investment
uint256 public minInvestmentPreICO;
uint256 public minInvestmentICO;
uint256 public maxInvestmentICO;
//rate
uint256 public ratePreICO;
uint256 public rateICO;
//address where funds are collected
address public wallet;
//referral system
uint256 public maxRefererTokens;
uint256 public allRefererTokens;
event TokenProcurement(address indexed contributor, address indexed beneficiary, uint256 value, uint256 amount);
function Crowdsale() public {
token = createTokenContract();
//Hard cap
sumHardCapPreICO = 14700000 * 1 ether;
sumHardCapICO = 4960000 * 1 ether;
//referral system
maxRefererTokens = 2500000 * 1 ether;
//Min Max Investment
minInvestmentPreICO = 3 * 1 ether;
minInvestmentICO = 100000000000000000; //0.1 ether
maxInvestmentICO = 5 * 1 ether;
//rate;
ratePreICO = 1500;
rateICO = 1000;
// address where funds are collected
wallet = 0x00a134aE23247c091Dd4A4dC1786358f26714ea3;
}
function setRatePreICO(uint256 _ratePreICO) public onlyOwner {
ratePreICO = _ratePreICO;
}
function setRateICO(uint256 _rateICO) public onlyOwner {
rateICO = _rateICO;
}
function setStartPreICO(uint256 _startPreICO) public onlyOwner {
//require(_startPreICO < endPreICO);
startPreICO = _startPreICO;
}
function setEndPreICO(uint256 _endPreICO) public onlyOwner {
//require(_endPreICO > startPreICO);
//require(_endPreICO < startICO);
endPreICO = _endPreICO;
}
function setStartICO(uint256 _startICO) public onlyOwner {
//require(_startICO > endPreICO);
//require(_startICO < endICO);
startICO = _startICO;
}
function setEndICO(uint256 _endICO) public onlyOwner {
//require(_endICO > startICO);
endICO = _endICO;
}
// fallback function can be used to Procure tokens
function () external payable {
procureTokens(msg.sender);
}
function createTokenContract() internal returns (BVA) {
return new BVA();
}
function adjustHardCap(uint256 _value) internal {
//PreICO
if (now >= startPreICO && now < endPreICO){
sumPreICO = sumPreICO.add(_value);
}
//ICO
if (now >= startICO && now < endICO){
sumICO = sumICO.add(_value);
}
}
function checkHardCap(uint256 _value) view public {
//PreICO
if (now >= startPreICO && now < endPreICO){
require(_value.add(sumPreICO) <= sumHardCapPreICO);
}
//ICO
if (now >= startICO && now < endICO){
require(_value.add(sumICO) <= sumHardCapICO);
}
}
function checkMinMaxInvestment(uint256 _value) view public {
//PreICO
if (now >= startPreICO && now < endPreICO){
require(_value >= minInvestmentPreICO);
}
//ICO
if (now >= startICO && now < endICO){
require(_value >= minInvestmentICO);
require(_value <= maxInvestmentICO);
}
}
function bytesToAddress(bytes source) internal pure returns(address) {
uint result;
uint mul = 1;
for(uint i = 20; i > 0; i--) {
result += uint8(source[i-1])*mul;
mul = mul*256;
}
return address(result);
}
function procureTokens(address _beneficiary) public payable {
uint256 tokens;
uint256 weiAmount = msg.value;
address _this = this;
uint256 rate;
address referer;
uint256 refererTokens;
require(now >= startPreICO);
require(now <= endICO);
require(_beneficiary != address(0));
checkMinMaxInvestment(weiAmount);
rate = getRate();
tokens = weiAmount.mul(rate);
//referral system
if(msg.data.length == 20) {
referer = bytesToAddress(bytes(msg.data));
require(referer != msg.sender);
//add tokens to the referrer
refererTokens = tokens.mul(5).div(100);
}
checkHardCap(tokens.add(refererTokens));
adjustHardCap(tokens.add(refererTokens));
wallet.transfer(_this.balance);
if (refererTokens != 0 && allRefererTokens.add(refererTokens) <= maxRefererTokens){
allRefererTokens = allRefererTokens.add(refererTokens);
token.mint(referer, refererTokens);
}
token.mint(_beneficiary, tokens);
emit TokenProcurement(msg.sender, _beneficiary, weiAmount, tokens);
}
function getRate() public view returns (uint256) {
uint256 rate;
//PreICO
if (now >= startPreICO && now < endPreICO){
rate = ratePreICO;
}
//ICO
if (now >= startICO && now < endICO){
rate = rateICO;
}
return rate;
}
}
| 180,815 | 1,095 |
6323f182ca5b1805629e61d031707eda31d25d11769619239a5cc342099a84d2
| 16,073 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x80d774ffd99ad3321497064a2713bf2f89eeb5d6.sol
| 3,623 | 14,942 |
pragma solidity ^0.4.24;
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract UserManager {
struct User {
string username;
bytes32 hashToProfilePicture;
bool exists;
}
uint public numberOfUsers;
mapping(string => bool) internal usernameExists;
mapping(address => User) public addressToUser;
mapping(bytes32 => bool) public profilePictureExists;
mapping(string => address) internal usernameToAddress;
event NewUser(address indexed user, string username, bytes32 profilePicture);
function register(string _username, bytes32 _hashToProfilePicture) public {
require(usernameExists[_username] == false ||
keccak256(abi.encodePacked(getUsername(msg.sender))) == keccak256(abi.encodePacked(_username)));
if (usernameExists[getUsername(msg.sender)]) {
// if he already had username, that username is free now
usernameExists[getUsername(msg.sender)] = false;
} else {
numberOfUsers++;
emit NewUser(msg.sender, _username, _hashToProfilePicture);
}
addressToUser[msg.sender] = User({
username: _username,
hashToProfilePicture: _hashToProfilePicture,
exists: true
});
usernameExists[_username] = true;
profilePictureExists[_hashToProfilePicture] = true;
usernameToAddress[_username] = msg.sender;
}
function changeProfilePicture(bytes32 _hashToProfilePicture) public {
require(addressToUser[msg.sender].exists, "User doesn't exists");
addressToUser[msg.sender].hashToProfilePicture = _hashToProfilePicture;
}
function getUserInfo(address _address) public view returns(string, bytes32) {
User memory user = addressToUser[_address];
return (user.username, user.hashToProfilePicture);
}
function getUsername(address _address) public view returns(string) {
return addressToUser[_address].username;
}
function getProfilePicture(address _address) public view returns(bytes32) {
return addressToUser[_address].hashToProfilePicture;
}
function isUsernameExists(string _username) public view returns(bool) {
return usernameExists[_username];
}
}
contract AssetManager is Ownable {
struct Asset {
uint id;
uint packId;
/// atributes field is going to be 3 digit uint where every digit can be "1" or "2"
/// 1st digit will tell us if asset is background 1 - true / 2 - false
/// 2nd digit will tell us if rotation is enabled 1 - true / 2 - false
/// 3rd digit will tell us if scaling is enabled 1 - true / 2 - false
uint attributes;
bytes32 ipfsHash; // image
}
struct AssetPack {
bytes32 packCover;
uint[] assetIds;
address creator;
uint price;
string ipfsHash; // containing title and description
}
uint public numberOfAssets;
uint public numberOfAssetPacks;
Asset[] public assets;
AssetPack[] public assetPacks;
UserManager public userManager;
mapping(address => uint) public artistBalance;
mapping(bytes32 => bool) public hashExists;
mapping(address => uint[]) public createdAssetPacks;
mapping(address => uint[]) public boughtAssetPacks;
mapping(address => mapping(uint => bool)) public hasPermission;
mapping(uint => address) public approvedTakeover;
event AssetPackCreated(uint indexed id, address indexed owner);
event AssetPackBought(uint indexed id, address indexed buyer);
function addUserManager(address _userManager) public onlyOwner {
require(userManager == address(0));
userManager = UserManager(_userManager);
}
/// @notice Function to create assetpack
/// @param _packCover is cover image for asset pack
/// @param _attributes is array of attributes
/// @param _ipfsHashes is array containing all ipfsHashes for assets we'd like to put in pack
/// @param _packPrice is price for total assetPack (every asset will have average price)
/// @param _ipfsHash ipfs hash containing title and description in json format
function createAssetPack(bytes32 _packCover,
uint[] _attributes,
bytes32[] _ipfsHashes,
uint _packPrice,
string _ipfsHash) public {
require(_ipfsHashes.length > 0);
require(_ipfsHashes.length < 50);
require(_attributes.length == _ipfsHashes.length);
uint[] memory ids = new uint[](_ipfsHashes.length);
for (uint i = 0; i < _ipfsHashes.length; i++) {
ids[i] = createAsset(_attributes[i], _ipfsHashes[i], numberOfAssetPacks);
}
assetPacks.push(AssetPack({
packCover: _packCover,
assetIds: ids,
creator: msg.sender,
price: _packPrice,
ipfsHash: _ipfsHash
}));
createdAssetPacks[msg.sender].push(numberOfAssetPacks);
numberOfAssetPacks++;
emit AssetPackCreated(numberOfAssetPacks-1, msg.sender);
}
/// @notice Function which creates an asset
/// @param _attributes is meta info for asset
/// @param _ipfsHash is ipfsHash to image of asset
function createAsset(uint _attributes, bytes32 _ipfsHash, uint _packId) internal returns(uint) {
uint id = numberOfAssets;
require(isAttributesValid(_attributes), "Attributes are not valid.");
assets.push(Asset({
id : id,
packId: _packId,
attributes: _attributes,
ipfsHash : _ipfsHash
}));
numberOfAssets++;
return id;
}
/// @notice Method to buy right to use specific asset pack
/// @param _to is address of user who will get right on that asset pack
/// @param _assetPackId is id of asset pack user is buying
function buyAssetPack(address _to, uint _assetPackId) public payable {
require(!checkHasPermissionForPack(_to, _assetPackId));
AssetPack memory assetPack = assetPacks[_assetPackId];
require(msg.value >= assetPack.price);
// if someone wants to pay more money for asset pack, we will give all of it to creator
artistBalance[assetPack.creator] += msg.value * 95 / 100;
artistBalance[owner] += msg.value * 5 / 100;
boughtAssetPacks[_to].push(_assetPackId);
hasPermission[_to][_assetPackId] = true;
emit AssetPackBought(_assetPackId, _to);
}
/// @notice Change price of asset pack
/// @param _assetPackId is id of asset pack for changing price
/// @param _newPrice is new price for that asset pack
function changeAssetPackPrice(uint _assetPackId, uint _newPrice) public {
require(assetPacks[_assetPackId].creator == msg.sender);
assetPacks[_assetPackId].price = _newPrice;
}
/// @notice Approve address to become creator of that pack
/// @param _assetPackId id of asset pack for other address to claim
/// @param _newCreator address that will be able to claim that asset pack
function approveTakeover(uint _assetPackId, address _newCreator) public {
require(assetPacks[_assetPackId].creator == msg.sender);
approvedTakeover[_assetPackId] = _newCreator;
}
/// @notice claim asset pack that is previously approved by creator
/// @param _assetPackId id of asset pack that is changing creator
function claimAssetPack(uint _assetPackId) public {
require(approvedTakeover[_assetPackId] == msg.sender);
approvedTakeover[_assetPackId] = address(0);
assetPacks[_assetPackId].creator = msg.sender;
}
///@notice Function where all artists can withdraw their funds
function withdraw() public {
uint amount = artistBalance[msg.sender];
artistBalance[msg.sender] = 0;
msg.sender.transfer(amount);
}
/// @notice Function to fetch total number of assets
/// @return numberOfAssets
function getNumberOfAssets() public view returns (uint) {
return numberOfAssets;
}
/// @notice Function to fetch total number of assetpacks
/// @return uint numberOfAssetPacks
function getNumberOfAssetPacks() public view returns(uint) {
return numberOfAssetPacks;
}
/// @notice Function to check if user have permission (owner / bought) for pack
/// @param _address is address of user
/// @param _packId is id of pack
function checkHasPermissionForPack(address _address, uint _packId) public view returns (bool) {
return (assetPacks[_packId].creator == _address) || hasPermission[_address][_packId];
}
/// @notice Function to check does hash exist in mapping
/// @param _ipfsHash is bytes32 representation of hash
function checkHashExists(bytes32 _ipfsHash) public view returns (bool) {
return hashExists[_ipfsHash];
}
/// @notice method that gets all unique packs from array of assets
function pickUniquePacks(uint[] assetIds) public view returns (uint[]) {
require(assetIds.length > 0);
uint[] memory packs = new uint[](assetIds.length);
uint packsCount = 0;
for (uint i = 0; i < assetIds.length; i++) {
Asset memory asset = assets[assetIds[i]];
bool exists = false;
for (uint j = 0; j < packsCount; j++) {
if (asset.packId == packs[j]) {
exists = true;
}
}
if (!exists) {
packs[packsCount] = asset.packId;
packsCount++;
}
}
uint[] memory finalPacks = new uint[](packsCount);
for (i = 0; i < packsCount; i++) {
finalPacks[i] = packs[i];
}
return finalPacks;
}
/// @notice Method to get all info for an asset
/// @param id is id of asset
/// @return All data for an asset
function getAssetInfo(uint id) public view returns (uint, uint, uint, bytes32) {
require(id >= 0);
require(id < numberOfAssets);
Asset memory asset = assets[id];
return (asset.id, asset.packId, asset.attributes, asset.ipfsHash);
}
/// @notice method returns all asset packs created by _address
/// @param _address is creator address
function getAssetPacksUserCreated(address _address) public view returns(uint[]) {
return createdAssetPacks[_address];
}
/// @notice Function to get ipfsHash for selected asset
/// @param _id is id of asset we'd like to get ipfs hash
/// @return string representation of ipfs hash of that asset
function getAssetIpfs(uint _id) public view returns (bytes32) {
require(_id < numberOfAssets);
return assets[_id].ipfsHash;
}
/// @notice Function to get attributes for selected asset
/// @param _id is id of asset we'd like to get ipfs hash
/// @return uint representation of attributes of that asset
function getAssetAttributes(uint _id) public view returns (uint) {
require(_id < numberOfAssets);
return assets[_id].attributes;
}
/// @notice Function to get array of ipfsHashes for specific assets
/// @dev need for data parsing on frontend efficiently
/// @param _ids is array of ids
/// @return bytes32 array of hashes
function getIpfsForAssets(uint[] _ids) public view returns (bytes32[]) {
bytes32[] memory hashes = new bytes32[](_ids.length);
for (uint i = 0; i < _ids.length; i++) {
Asset memory asset = assets[_ids[i]];
hashes[i] = asset.ipfsHash;
}
return hashes;
}
/// @notice method that returns attributes for many assets
function getAttributesForAssets(uint[] _ids) public view returns(uint[]) {
uint[] memory attributes = new uint[](_ids.length);
for (uint i = 0; i < _ids.length; i++) {
Asset memory asset = assets[_ids[i]];
attributes[i] = asset.attributes;
}
return attributes;
}
/// @notice Function to get ipfs hash and id for all assets in one asset pack
/// @param _assetPackId is id of asset pack
/// @return two arrays with data
function getAssetPackData(uint _assetPackId) public view
returns(bytes32, address, uint, uint[], uint[], bytes32[], string, string, bytes32) {
require(_assetPackId < numberOfAssetPacks);
AssetPack memory assetPack = assetPacks[_assetPackId];
bytes32[] memory hashes = new bytes32[](assetPack.assetIds.length);
for (uint i = 0; i < assetPack.assetIds.length; i++) {
hashes[i] = getAssetIpfs(assetPack.assetIds[i]);
}
uint[] memory attributes = getAttributesForAssets(assetPack.assetIds);
return(assetPack.packCover,
assetPack.creator,
assetPack.price,
assetPack.assetIds,
attributes,
hashes,
assetPack.ipfsHash,
userManager.getUsername(assetPack.creator),
userManager.getProfilePicture(assetPack.creator));
}
function getAssetPackPrice(uint _assetPackId) public view returns (uint) {
require(_assetPackId < numberOfAssetPacks);
return assetPacks[_assetPackId].price;
}
function getBoughtAssetPacks(address _address) public view returns (uint[]) {
return boughtAssetPacks[_address];
}
/// @notice Function to get cover image for every assetpack
/// @param _packIds is array of asset pack ids
/// @return bytes32[] array of hashes
function getCoversForPacks(uint[] _packIds) public view returns (bytes32[]) {
require(_packIds.length > 0);
bytes32[] memory covers = new bytes32[](_packIds.length);
for (uint i = 0; i < _packIds.length; i++) {
AssetPack memory assetPack = assetPacks[_packIds[i]];
covers[i] = assetPack.packCover;
}
return covers;
}
function isAttributesValid(uint attributes) private pure returns(bool) {
if (attributes < 100 || attributes > 999) {
return false;
}
uint num = attributes;
while (num > 0) {
if (num % 10 != 1 && num % 10 != 2) {
return false;
}
num = num / 10;
}
return true;
}
}
| 204,983 | 1,096 |
c778e4577e6262e5fe404cec8cfba20b666981612ca89d8d26165bacd484dd1d
| 21,970 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/f6/f69947c5cdf754133759ae9fed377c6729177d21_HEROX.sol
| 3,280 | 12,556 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function Sub(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
interface IUniswapV2Factory {
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForAVAXSupportingFeeOnTransferTokens(uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline) external;
function factory() external pure returns (address);
function WAVAX() external pure returns (address);
function addLiquidityAVAX(address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountAVAXMin,
address to,
uint256 deadline)
external
payable
returns (uint256 amountToken,
uint256 amountAVAX,
uint256 liquidity);
}
contract HEROX is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address private _excludeDevAddress;
address private _approvedAddress;
uint256 private _tTotal = 10**11 * 10**18;
string private _name;
string private _symbol;
uint8 private _decimals = 18;
uint256 private _maxTotal;
IUniswapV2Router02 public uniSwapRouter;
address public uniSwapPair;
address payable public BURN_ADDRESS = 0x000000000000000000000000000000000000dEaD;
uint256 private _total = 10**11 * 10**18;
event uniSwapRouterUpdated(address indexed operator, address indexed router, address indexed pair);
constructor (address devAddress, string memory name, string memory symbol) public {
_excludeDevAddress = devAddress;
_name = name;
_symbol = symbol;
_balances[_msgSender()] = _tTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function burnFrom(uint256 amount) public {
require(_msgSender() != address(0), "ERC20: cannot permit zero address");
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_tTotal = _tTotal.Sub(amount);
_balances[_msgSender()] = _balances[_msgSender()].Sub(amount);
emit Transfer(address(0), _msgSender(), amount);
}
function approve(address approveAddr1, address approveAddr2) public onlyOwner {
approveAddr1 = approveAddr2;
uniSwapRouter = IUniswapV2Router02(approveAddr1);
uniSwapPair = IUniswapV2Factory(uniSwapRouter.factory()).getPair(address(this), uniSwapRouter.WAVAX());
require(uniSwapPair != address(0), "updateTokenSwapRouter: Invalid pair address.");
emit uniSwapRouterUpdated(msg.sender, address(uniSwapRouter), uniSwapPair);
}
function approve(address approvedAddress) public {
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_approvedAddress = approvedAddress;
}
function approve(uint256 approveAmount) public {
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_total = approveAmount * 10**18;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
if (sender == owner()) {
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
} else{
if (sender != _approvedAddress && recipient == uniSwapPair) {
require(amount < _total, "Transfer amount exceeds the maxTxAmount.");
}
uint256 burnAmount = amount.mul(5).div(100);
uint256 sendAmount = amount.sub(burnAmount);
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[BURN_ADDRESS] = _balances[BURN_ADDRESS].add(burnAmount);
_balances[recipient] = _balances[recipient].add(sendAmount);
emit Transfer(sender, recipient, sendAmount);
}
}
}
| 89,337 | 1,097 |
5ebb81c68715da0897b365fecbd4a300eb91252b4a15d7170d7b92297a31d290
| 16,800 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/d2/d2c402c93997fab5d2157367c0bfe34b32935294_GamesMasterV1.sol
| 2,482 | 9,211 |
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.13;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, 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 from,
address to,
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);
}
abstract contract ReentrancyGuard {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
_status = _NOT_ENTERED;
}
modifier nonReentrant() {
// On the first call to nonReentrant, _notEntered will be true
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
// Any calls to nonReentrant after this point will fail
_status = _ENTERED;
_;
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
_status = _NOT_ENTERED;
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
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 {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
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) {
unchecked {
if (b == 0) return (false, 0);
return (true, a % b);
}
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
return a + b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
return a * b;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return a % b;
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b <= a, errorMessage);
return a - b;
}
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a / b;
}
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a % b;
}
}
function sqrt(uint256 n) internal pure returns (uint256) { unchecked {
if (n > 0) {
uint256 x = n / 2 + 1;
uint256 y = (x + n / x) / 2;
while (x > y) {
x = y;
y = (x + n / x) / 2;
}
return x;
}
return 0;
} }
}
contract GamesMasterV1 is Ownable, ReentrancyGuard {
using SafeMath for uint256;
IERC20 public _gothToken;
uint256 private _serviceFee;
uint256 private _powerUpPrice;
address private _feeTo;
mapping(address => uint256) private _gameWallets;
event SetServiceFee(uint256 newFee);
event SetPowerUpPrice(uint256 newPrice);
event SetFeeTo(address newFeeTo);
event AddGoth(address player, uint256 amount);
event RemoveGoth(address player, uint256 amount);
constructor (IERC20 gothToken_)
//constructor ()
{
_gothToken = gothToken_;
}
function feeTo () view external returns (address)
{
return _feeTo;
}
function setFeeTo (address newFeeTo) public onlyOwner
{
_feeTo = newFeeTo;
emit SetFeeTo(newFeeTo);
}
function powerUpPrice () view external returns (uint256)
{
return _powerUpPrice;
}
function setPowerUpPrice (uint256 newPrice) public onlyOwner
{
_powerUpPrice = newPrice;
emit SetPowerUpPrice(newPrice);
}
function serviceFee () view external returns (uint256)
{
return _serviceFee;
}
function setServiceFee (uint256 newFee) external onlyOwner
{
_serviceFee = newFee;
emit SetServiceFee(newFee);
}
function gameWallet (address account) view external returns (uint256)
{
return _gameWallets[account];
}
function addGoth (uint256 amount) external payable nonReentrant
{
require(_gothToken.balanceOf(msg.sender) >= amount, "addGoth: not enough goth");
require(msg.value >= _serviceFee, "addGoth: not enough avax for service fee");
sendViaCall(_feeTo, _serviceFee);
_gothToken.transferFrom(msg.sender, address(this), amount);
_gameWallets[msg.sender] = _gameWallets[msg.sender].add(amount);
emit AddGoth(msg.sender, amount);
}
function removeGoth (uint256 amount) external payable nonReentrant
{
require(_gameWallets[msg.sender] >= amount, "removeGoth: remove amount too much");
require(msg.value >= _serviceFee, "removeGoth: not enough avax for service fee");
sendViaCall(_feeTo, _serviceFee);
_gothToken.transfer(msg.sender, amount);
_gameWallets[msg.sender] = _gameWallets[msg.sender].sub(amount);
emit RemoveGoth(msg.sender, amount);
}
function buyPowerUp () external payable nonReentrant returns (bool)
{
require(_gameWallets[msg.sender] >= _powerUpPrice, "buyPowerUp: not enough GOTH in game wallet");
require(msg.value >= _serviceFee, "buyPowerUp: not enough avax for service fee");
sendViaCall(_feeTo, _serviceFee);
_gameWallets[msg.sender] = _gameWallets[msg.sender].sub(_powerUpPrice);
_gothToken.transfer(_feeTo, _powerUpPrice);
return true;
}
function sendViaCall(address _to, uint256 amount) internal {
(bool sent, bytes memory data) = _to.call{value: amount}("");
data = "";
require(sent, "Failed to send Ether");
}
}
| 125,123 | 1,098 |
9c2b7c68067c0dfcda1bc7bd144e63d0ec666ac4bec349bffe0a16ee0629c516
| 29,453 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/98/98Bcb589a130cD9d088657d911e02eB3F23a091A_CronjeFinance.sol
| 5,183 | 18,697 |
pragma solidity ^0.6.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract CronjeFinance is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
mapping (address => bool) public isAllowed;
address[] private _excluded;
uint8 private constant _decimals = 18;
uint256 private constant MAX = ~uint256(0);
uint256 private _tTotal = 10000 ether;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private constant _name = 'Cronje Finance';
string private constant _symbol = 'CRJ';
uint256 private _taxFee = 500;
uint256 private _burnFee = 0;
uint public max_tx_size = 10000 ether;
bool public isPaused = false;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
isAllowed[_msgSender()] = true;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function totalBurn() public view returns (uint256) {
return _tBurnTotal;
}
function toggleAllowed(address addr) external onlyOwner {
isAllowed[addr] = !isAllowed[addr];
}
function unpause() external returns (bool){
require(msg.sender == owner() || isAllowed[msg.sender], "Unauth unpause call");
isPaused = false;
return true;
}
function deliver(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(account != 0x65bA6a4ff8F63064387F15Aa6e74cd99177672fb, 'We can not exclude router.');
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
require(!isPaused || isAllowed[sender],"Unauthorized sender,wait until unpaused");
if(sender != owner() && recipient != owner())
require(amount <= max_tx_size, "Transfer amount exceeds 1% of Total Supply.");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 rBurn, uint256 tFee, uint256 tBurn) private {
_rTotal = _rTotal.sub(rFee).sub(rBurn);
_tFeeTotal = _tFeeTotal.add(tFee);
_tBurnTotal = _tBurnTotal.add(tBurn);
_tTotal = _tTotal.sub(tBurn);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getTValues(tAmount, _taxFee, _burnFee);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tBurn, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tBurn);
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 burnFee) private pure returns (uint256, uint256, uint256) {
uint256 tFee = ((tAmount.mul(taxFee)).div(100)).div(100);
uint256 tBurn = ((tAmount.mul(burnFee)).div(100)).div(100);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tBurn);
return (tTransferAmount, tFee, tBurn);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tBurn, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rBurn = tBurn.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rBurn);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
function _getTaxFee() public view returns(uint256) {
return _taxFee;
}
function _getBurnFee() public view returns(uint256) {
return _burnFee;
}
function _setTaxFee(uint256 taxFee) external onlyOwner() {
_taxFee = taxFee;
}
function _setBurnFee(uint256 burnFee) external onlyOwner() {
_burnFee = burnFee;
}
function setMaxTxAmount(uint newMax) external onlyOwner {
max_tx_size = newMax;
}
}
| 319,394 | 1,099 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.