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
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
02891bdec7bc634ba64b9ac820294b6901f7a28fc6b5d54c749a458626532c57
| 25,813 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/ae/aece16e5064d573456bad930ffab0cbb522dc105_YATMarket.sol
| 5,032 | 19,656 |
// SPDX-License-Identifier: Unlicense
pragma solidity 0.8.13;
/// @notice Modern, minimalist, and gas efficient ERC-721 implementation.
/// @author Solmate (https://github.com/Rari-Capital/solmate/blob/main/src/tokens/ERC721.sol)
/// @dev Note that balanceOf does not revert if passed the zero address, in defiance of the ERC.
abstract contract ERC721 {
event Transfer(address indexed from, address indexed to, uint256 indexed id);
event Approval(address indexed owner, address indexed spender, uint256 indexed id);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
string public name;
string public symbol;
function tokenURI(uint256 id) public view virtual returns (string memory);
mapping(address => uint256) public balanceOf;
mapping(uint256 => address) public ownerOf;
mapping(uint256 => address) public getApproved;
mapping(address => mapping(address => bool)) public isApprovedForAll;
constructor(string memory _name, string memory _symbol) {
name = _name;
symbol = _symbol;
}
function approve(address spender, uint256 id) public virtual {
address owner = ownerOf[id];
require(msg.sender == owner || isApprovedForAll[owner][msg.sender], "NOT_AUTHORIZED");
getApproved[id] = spender;
emit Approval(owner, spender, id);
}
function setApprovalForAll(address operator, bool approved) public virtual {
isApprovedForAll[msg.sender][operator] = approved;
emit ApprovalForAll(msg.sender, operator, approved);
}
function transferFrom(address from,
address to,
uint256 id) public virtual {
require(from == ownerOf[id], "WRONG_FROM");
require(to != address(0), "INVALID_RECIPIENT");
require(msg.sender == from || msg.sender == getApproved[id] || isApprovedForAll[from][msg.sender],
"NOT_AUTHORIZED");
// Underflow of the sender's balance is impossible because we check for
// ownership above and the recipient's balance can't realistically overflow.
unchecked {
balanceOf[from]--;
balanceOf[to]++;
}
ownerOf[id] = to;
delete getApproved[id];
emit Transfer(from, to, id);
}
function safeTransferFrom(address from,
address to,
uint256 id) public virtual {
transferFrom(from, to, id);
require(to.code.length == 0 ||
ERC721TokenReceiver(to).onERC721Received(msg.sender, from, id, "") ==
ERC721TokenReceiver.onERC721Received.selector,
"UNSAFE_RECIPIENT");
}
function safeTransferFrom(address from,
address to,
uint256 id,
bytes memory data) public virtual {
transferFrom(from, to, id);
require(to.code.length == 0 ||
ERC721TokenReceiver(to).onERC721Received(msg.sender, from, id, data) ==
ERC721TokenReceiver.onERC721Received.selector,
"UNSAFE_RECIPIENT");
}
function supportsInterface(bytes4 interfaceId) public pure virtual returns (bool) {
return
interfaceId == 0x01ffc9a7 || // ERC165 Interface ID for ERC165
interfaceId == 0x80ac58cd || // ERC165 Interface ID for ERC721
interfaceId == 0x5b5e139f; // ERC165 Interface ID for ERC721Metadata
}
function _mint(address to, uint256 id) internal virtual {
require(to != address(0), "INVALID_RECIPIENT");
require(ownerOf[id] == address(0), "ALREADY_MINTED");
// Counter overflow is incredibly unrealistic.
unchecked {
balanceOf[to]++;
}
ownerOf[id] = to;
emit Transfer(address(0), to, id);
}
function _burn(uint256 id) internal virtual {
address owner = ownerOf[id];
require(ownerOf[id] != address(0), "NOT_MINTED");
// Ownership check above ensures no underflow.
unchecked {
balanceOf[owner]--;
}
delete ownerOf[id];
delete getApproved[id];
emit Transfer(owner, address(0), id);
}
function _safeMint(address to, uint256 id) internal virtual {
_mint(to, id);
require(to.code.length == 0 ||
ERC721TokenReceiver(to).onERC721Received(msg.sender, address(0), id, "") ==
ERC721TokenReceiver.onERC721Received.selector,
"UNSAFE_RECIPIENT");
}
function _safeMint(address to,
uint256 id,
bytes memory data) internal virtual {
_mint(to, id);
require(to.code.length == 0 ||
ERC721TokenReceiver(to).onERC721Received(msg.sender, address(0), id, data) ==
ERC721TokenReceiver.onERC721Received.selector,
"UNSAFE_RECIPIENT");
}
}
/// @notice A generic interface for a contract which properly accepts ERC721 tokens.
/// @author Solmate (https://github.com/Rari-Capital/solmate/blob/main/src/tokens/ERC721.sol)
interface ERC721TokenReceiver {
function onERC721Received(address operator,
address from,
uint256 id,
bytes calldata data) external returns (bytes4);
}
/// @notice Modern and gas efficient ERC20 + EIP-2612 implementation.
/// @author Solmate (https://github.com/Rari-Capital/solmate/blob/main/src/tokens/ERC20.sol)
abstract contract ERC20 {
event Transfer(address indexed from, address indexed to, uint256 amount);
event Approval(address indexed owner, address indexed spender, uint256 amount);
string public name;
string public symbol;
uint8 public immutable decimals;
uint256 public totalSupply;
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
bytes32 public constant PERMIT_TYPEHASH =
keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
uint256 internal immutable INITIAL_CHAIN_ID;
bytes32 internal immutable INITIAL_DOMAIN_SEPARATOR;
mapping(address => uint256) public nonces;
constructor(string memory _name,
string memory _symbol,
uint8 _decimals) {
name = _name;
symbol = _symbol;
decimals = _decimals;
INITIAL_CHAIN_ID = block.chainid;
INITIAL_DOMAIN_SEPARATOR = computeDomainSeparator();
}
function approve(address spender, uint256 amount) public virtual returns (bool) {
allowance[msg.sender][spender] = amount;
emit Approval(msg.sender, spender, amount);
return true;
}
function transfer(address to, uint256 amount) public virtual returns (bool) {
balanceOf[msg.sender] -= amount;
// Cannot overflow because the sum of all user
// balances can't exceed the max uint256 value.
unchecked {
balanceOf[to] += amount;
}
emit Transfer(msg.sender, to, amount);
return true;
}
function transferFrom(address from,
address to,
uint256 amount) public virtual returns (bool) {
uint256 allowed = allowance[from][msg.sender]; // Saves gas for limited approvals.
if (allowed != type(uint256).max) allowance[from][msg.sender] = allowed - amount;
balanceOf[from] -= amount;
// Cannot overflow because the sum of all user
// balances can't exceed the max uint256 value.
unchecked {
balanceOf[to] += amount;
}
emit Transfer(from, to, amount);
return true;
}
function permit(address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) public virtual {
require(deadline >= block.timestamp, "PERMIT_DEADLINE_EXPIRED");
// Unchecked because the only math done is incrementing
// the owner's nonce which cannot realistically overflow.
unchecked {
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, "INVALID_SIGNER");
allowance[recoveredAddress][spender] = value;
}
emit Approval(owner, spender, value);
}
function DOMAIN_SEPARATOR() public view virtual returns (bytes32) {
return block.chainid == INITIAL_CHAIN_ID ? INITIAL_DOMAIN_SEPARATOR : computeDomainSeparator();
}
function computeDomainSeparator() internal view virtual returns (bytes32) {
return
keccak256(abi.encode(keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
keccak256(bytes(name)),
keccak256("1"),
block.chainid,
address(this)));
}
function _mint(address to, uint256 amount) internal virtual {
totalSupply += amount;
// Cannot overflow because the sum of all user
// balances can't exceed the max uint256 value.
unchecked {
balanceOf[to] += amount;
}
emit Transfer(address(0), to, amount);
}
function _burn(address from, uint256 amount) internal virtual {
balanceOf[from] -= amount;
// Cannot underflow because a user's balance
// will never be larger than the total supply.
unchecked {
totalSupply -= amount;
}
emit Transfer(from, address(0), amount);
}
}
contract YATMarket {
struct Bid {
uint bidPrice;
address bidder;
bool active;
}
struct Listing {
address owner;
bool active;
uint256 price;
}
address nftContract;
address immutable wETH;
mapping(uint => mapping(address => Bid)) public bids;
uint256 public marketFeePercent = 0;
bool public isMarketOpen = false;
bool public emergencyDelisting = false;
uint256 public marketCut = 0;
mapping(uint256 => Listing) public listings;
address public owner;
event OwnerUpdated(address indexed newOwner);
event AddListingEv(uint256 indexed tokenId, uint256 price);
event UpdateListingEv(uint256 indexed tokenId, uint256 price);
event CancelListingEv(uint256 indexed tokenId);
event FulfillListingEv(uint256 indexed tokenId, uint price);
event UpdateBidEv(uint256 tokenId, uint256 bidPrice);
event CancelBidEv(uint256 tokenId);
event CreateBidEv(uint256 tokenId, uint256 bidPrice, address owner);
event AcceptBidEv(uint256 tokenId, address buyer);
error Percentage0to100();
error ClosedMarket();
error InactiveListing();
error InsufficientValue();
error InvalidOwner();
error OnlyEmergency();
error Unauthorized();
error BidAlreadyExist();
error BidDoesntExist();
constructor(address nft_address,
address wETH_,
uint256 market_fee) {
if (market_fee > 100 || market_fee < 0) revert Percentage0to100();
owner = msg.sender;
nftContract = nft_address;
marketFeePercent = market_fee;
wETH = wETH_;
}
modifier onlyOwner() {
if (msg.sender != owner) revert Unauthorized();
_;
}
function setOwner(address _newOwner) external onlyOwner {
owner = _newOwner;
emit OwnerUpdated(_newOwner);
}
function setNFTContract(address _newNFTcontract) external onlyOwner {
nftContract = _newNFTcontract;
}
function withdrawableBalance() public view returns (uint256 value) {
return marketCut;
}
function withdraw() external onlyOwner {
uint balance = marketCut;
marketCut = 0;
ERC20(wETH).transfer(msg.sender,balance);
}
function openMarket() external onlyOwner {
isMarketOpen = true;
}
function closeMarket() external onlyOwner {
isMarketOpen = false;
}
function allowEmergencyDelisting() external onlyOwner {
emergencyDelisting = true;
}
function adjustFees(uint256 newMarketFee) external onlyOwner {
if (newMarketFee > 100 || newMarketFee < 0) revert Percentage0to100();
marketFeePercent = newMarketFee;
}
function emergencyDelist(uint256 _tokenId) external {
require(emergencyDelisting && !isMarketOpen, "Only in emergency.");
Listing memory listing = listings[_tokenId];
delete listings[_tokenId];
ERC721(nftContract).transferFrom(address(this), listing.owner, _tokenId);
emit CancelListingEv(_tokenId);
}
function addListing(uint256 _tokenId,
uint256 _price) external {
if (!isMarketOpen) revert ClosedMarket();
//@dev no other checks since transferFrom will fail
listings[_tokenId] = Listing(msg.sender, true,_price);
ERC721(nftContract).transferFrom(msg.sender,
address(this),
_tokenId);
emit AddListingEv(_tokenId, _price);
}
function updateListing(uint256 _tokenId, uint256 _price) external {
if (!isMarketOpen) revert ClosedMarket();
if (!listings[_tokenId].active) revert InactiveListing();
if (listings[_tokenId].owner != msg.sender) revert InvalidOwner();
listings[_tokenId].price = _price;
emit UpdateListingEv(_tokenId, _price);
}
function cancelListing(uint256 _tokenId) external {
if (!isMarketOpen) revert ClosedMarket();
Listing memory listing = listings[_tokenId];
if (!listing.active) revert InactiveListing();
if (listing.owner != msg.sender) revert InvalidOwner();
delete listings[_tokenId];
ERC721(nftContract).transferFrom(address(this),
listing.owner,
_tokenId);
emit CancelListingEv(_tokenId);
}
function fulfillListing(uint256 _tokenId) external {
if (!isMarketOpen) revert ClosedMarket();
Listing memory listing = listings[_tokenId];
if (!listing.active) revert InactiveListing();
if (msg.sender == listing.owner) revert InvalidOwner(); // can not fulfill your own listing
delete listings[_tokenId];
marketCut += (listing.price * marketFeePercent) / 100;
ERC20(wETH).transferFrom(msg.sender, listing.owner, listing.price - (listing.price * marketFeePercent) / 100);
ERC20(wETH).transferFrom(msg.sender, address(this), (listing.price * marketFeePercent) / 100);
ERC721(nftContract).transferFrom(address(this),
msg.sender,
_tokenId);
emit FulfillListingEv(_tokenId, listing.price);
}
function fullfillMultipleListings(uint256[] calldata _tokenIds) external {
if (!isMarketOpen) revert ClosedMarket();
for (uint256 index = 0; index < _tokenIds.length; ++index) {
uint tokenId = _tokenIds[index];
Listing memory listing = listings[tokenId];
if (msg.sender == listing.owner) revert InvalidOwner();
if (!listing.active) revert InactiveListing();
delete listings[tokenId];
marketCut += (listing.price * marketFeePercent) / 100;
ERC20(wETH).transferFrom(msg.sender, listing.owner, listing.price - (listing.price * marketFeePercent) / 100);
ERC20(wETH).transferFrom(msg.sender, address(this), (listing.price * marketFeePercent) / 100);
ERC721(nftContract).transferFrom(address(this),msg.sender,tokenId);
emit FulfillListingEv(tokenId,listing.price);
}
}
function placeBid(uint256 tokenId, uint amount) external {
if (!isMarketOpen) revert ClosedMarket();
address tokenOwner = getTokenOwner(tokenId);
require(msg.sender != tokenOwner, "Can't place bid for own blueprint");
if(bids[tokenId][msg.sender].active) revert BidAlreadyExist();
ERC20(wETH).transferFrom(msg.sender, address(this), amount);
bids[tokenId][msg.sender]= Bid(amount, msg.sender, true); // 1 is index wont exist, msg sender will also not exist
emit CreateBidEv(tokenId,amount,tokenOwner);
}
function cancelBid(uint tokenId) external {
if (!isMarketOpen) revert ClosedMarket();
if (!bids[tokenId][msg.sender].active) revert BidDoesntExist();
uint256 bidAmount = bids[tokenId][msg.sender].bidPrice;
delete bids[tokenId][msg.sender];
ERC20(wETH).transfer(msg.sender, bidAmount);
emit CancelBidEv(tokenId);
}
function updateBid(uint tokenId, uint newPrice) external {
if (!isMarketOpen) revert ClosedMarket();
if(!bids[tokenId][msg.sender].active) revert BidDoesntExist(); // owner can never place a bid on its own bids so no need to check here again
uint currentPrice = bids[tokenId][msg.sender].bidPrice;
if(currentPrice > newPrice){
uint diff = currentPrice - newPrice;
ERC20(wETH).transfer(msg.sender, diff);
bids[tokenId][msg.sender].bidPrice = newPrice;
}
else if (newPrice > currentPrice){
uint diff = newPrice - currentPrice;
ERC20(wETH).transferFrom(msg.sender, address(this), diff);
bids[tokenId][msg.sender].bidPrice = newPrice;
}
emit UpdateBidEv(tokenId,newPrice);
}
function acceptBid(uint tokenId, address buyer) external {
if (!isMarketOpen) revert ClosedMarket();
address tokenOwner = getTokenOwner(tokenId);
if(msg.sender != tokenOwner) revert InvalidOwner();
if(!bids[tokenId][buyer].active) revert BidDoesntExist();
uint256 bidAmount = bids[tokenId][buyer].bidPrice;
delete bids[tokenId][buyer];
uint256 market_cut = (bidAmount * marketFeePercent) / 100;
uint256 seller_cut = bidAmount - market_cut;
marketCut += market_cut;
if(listings[tokenId].active){
delete listings[tokenId];
ERC721(nftContract).transferFrom(address(this), buyer, tokenId);
emit CancelListingEv(tokenId);
}
else {
ERC721(nftContract).transferFrom(tokenOwner, buyer, tokenId);
}
ERC20(wETH).transfer(tokenOwner, seller_cut); //remaining is left here
emit AcceptBidEv(tokenId,buyer);
}
function cancelBidsOnBurnedTokenIds(address[] calldata bidders, uint tokenId) external{
if(ERC721(nftContract).ownerOf(tokenId) == address(0)){
for (uint256 index = 0; index < bidders.length; ++index) {
if(bids[tokenId][bidders[index]].active){
uint repay = bids[tokenId][bidders[index]].bidPrice;
delete bids[tokenId][bidders[index]];
ERC20(wETH).transfer(bidders[index],repay);
emit CancelBidEv(tokenId);
}
}
}
}
function getListings(uint256 from, uint256 length)
external
view
returns (Listing[] memory listing)
{
unchecked {
Listing[] memory _listings = new Listing[](length);
//slither-disable-next-line uninitialized-local
for (uint256 i; i < length; ++i) {
_listings[i] = listings[from + i];
}
return _listings;
}
}
function getTokenOwner(uint256 _tokenId) public view returns (address){
if (listings[_tokenId].active){
return listings[_tokenId].owner;
} else {
return ERC721(nftContract).ownerOf(_tokenId);
}
}
}
| 103,972 | 12,500 |
570de63aa7d10f05e9e936d9a466e449c0a703502c9f0cf7ccc81e3ad1e86ba6
| 18,387 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TJ/TJ9RTmt7WuDRCjWmCAzhZafUzkPZFoteYJ_TronHeroOfficial.sol
| 4,836 | 17,558 |
//SourceUnit: tronhero.sol
pragma solidity 0.5.10;
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;
}
}
library Objects {
struct Investment {
uint256 investmentDate;
uint256 investment;
uint256 lastWithdrawalDate;
uint256 currentDividends;
bool isExpired;
}
struct Investor {
address addr;
uint256 checkpoint;
uint256 referrerEarnings;
uint256 availableReferrerEarnings;
uint256 reinvestWallet;
uint256 referrer;
uint256 planCount;
mapping(uint256 => Investment) plans;
uint256 level1RefCount;
uint256 level2RefCount;
uint256 level3RefCount;
}
}
contract Ownable {
address public owner;
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
}
contract TronHeroOfficial is Ownable {
using SafeMath for uint256;
uint256 public constant DEVELOPER_RATE = 60; // 6% Team, Operation & Development
uint256 public constant MARKETING_RATE = 60; // 6% Marketing
uint256 public constant REFERENCE_RATE = 180; // 18% Total Refer Income
uint256 public constant REFERENCE_LEVEL1_RATE = 100; // 10% Level 1 Income
uint256 public constant REFERENCE_LEVEL2_RATE = 50; // 5% Level 2 Income
uint256 public constant REFERENCE_LEVEL3_RATE = 30; // 3% Level 3 Income
uint256 public constant MINIMUM = 100e6; // Minimum investment : 100 TRX
uint256 public constant REFERRER_CODE = 1000; // Root ID : 1000
uint256 public constant PLAN_INTEREST = 250; // 25% Daily Roi
uint256 public constant PLAN_TERM = 8 days; // 8 Days
uint256 public constant CONTRACT_LIMIT = 800; // 20% Unlocked for Withdrawal Daily
uint256 public contract_balance;
uint256 private contract_checkpoint;
uint256 public latestReferrerCode;
uint256 public totalInvestments_;
uint256 public totalReinvestments_;
address payable private developerAccount_;
address payable private marketingAccount_;
mapping(address => uint256) public address2UID;
mapping(uint256 => Objects.Investor) public uid2Investor;
event onInvest(address investor, uint256 amount);
event onReinvest(address investor, uint256 amount);
event onWithdraw(address investor, uint256 amount);
constructor() public {
developerAccount_ = msg.sender;
marketingAccount_ = msg.sender;
_init();
}
function _init() private {
latestReferrerCode = REFERRER_CODE;
address2UID[msg.sender] = latestReferrerCode;
uid2Investor[latestReferrerCode].addr = msg.sender;
uid2Investor[latestReferrerCode].referrer = 0;
uid2Investor[latestReferrerCode].planCount = 0;
}
function setMarketingAccount(address payable _newMarketingAccount) public onlyOwner {
require(_newMarketingAccount != address(0));
marketingAccount_ = _newMarketingAccount;
}
function getMarketingAccount() public view onlyOwner returns (address) {
return marketingAccount_;
}
function setDeveloperAccount(address payable _newDeveloperAccount) public onlyOwner {
require(_newDeveloperAccount != address(0));
developerAccount_ = _newDeveloperAccount;
}
function getDeveloperAccount() public view onlyOwner returns (address) {
return developerAccount_;
}
function getBalance() public view returns (uint256) {
return address(this).balance;
}
function getUIDByAddress(address _addr) public view returns (uint256) {
return address2UID[_addr];
}
function getInvestorInfoByUID(uint256 _uid) public view returns (uint256,uint256, uint256, uint256, uint256, uint256, uint256, uint256, uint256, uint256[] memory) {
if (msg.sender != owner) {
require(address2UID[msg.sender] == _uid, "only owner or self can check the investor info.");
}
Objects.Investor storage investor = uid2Investor[_uid];
uint256[] memory newDividends = new uint256[](investor.planCount);
for (uint256 i = 0; i < investor.planCount; i++) {
require(investor.plans[i].investmentDate != 0, "wrong investment date");
if (investor.plans[i].isExpired) {
newDividends[i] = 0;
} else {
if (block.timestamp >= investor.plans[i].investmentDate.add(PLAN_TERM)) {
newDividends[i] = _calculateDividends(investor.plans[i].investment, PLAN_INTEREST, investor.plans[i].investmentDate.add(PLAN_TERM), investor.plans[i].lastWithdrawalDate);
} else {
newDividends[i] = _calculateDividends(investor.plans[i].investment, PLAN_INTEREST, block.timestamp, investor.plans[i].lastWithdrawalDate);
}
}
}
return
(investor.referrerEarnings,
investor.availableReferrerEarnings,
investor.reinvestWallet,
investor.referrer,
investor.level1RefCount,
investor.level2RefCount,
investor.level3RefCount,
investor.planCount,
investor.checkpoint,
newDividends);
}
function getInvestmentPlanByUID(uint256 _uid) public view returns (uint256[] memory, uint256[] memory, uint256[] memory, bool[] memory) {
if (msg.sender != owner) {
require(address2UID[msg.sender] == _uid, "only owner or self can check the investment plan info.");
}
Objects.Investor storage investor = uid2Investor[_uid];
uint256[] memory investmentDates = new uint256[](investor.planCount);
uint256[] memory investments = new uint256[](investor.planCount);
uint256[] memory currentDividends = new uint256[](investor.planCount);
bool[] memory isExpireds = new bool[](investor.planCount);
for (uint256 i = 0; i < investor.planCount; i++) {
require(investor.plans[i].investmentDate!=0,"wrong investment date");
currentDividends[i] = investor.plans[i].currentDividends;
investmentDates[i] = investor.plans[i].investmentDate;
investments[i] = investor.plans[i].investment;
if (investor.plans[i].isExpired) {
isExpireds[i] = true;
} else {
isExpireds[i] = false;
if (PLAN_TERM > 0) {
if (block.timestamp >= investor.plans[i].investmentDate.add(PLAN_TERM)) {
isExpireds[i] = true;
}
}
}
}
return
(investmentDates,
investments,
currentDividends,
isExpireds);
}
function _addInvestor(address _addr, uint256 _referrerCode) private returns (uint256) {
if (_referrerCode >= REFERRER_CODE) {
if (uid2Investor[_referrerCode].addr == address(0)) {
_referrerCode = 0;
}
} else {
_referrerCode = 0;
}
address addr = _addr;
latestReferrerCode = latestReferrerCode.add(1);
address2UID[addr] = latestReferrerCode;
uid2Investor[latestReferrerCode].addr = addr;
uid2Investor[latestReferrerCode].referrer = _referrerCode;
uid2Investor[latestReferrerCode].planCount = 0;
if (_referrerCode >= REFERRER_CODE) {
uint256 _ref1 = _referrerCode;
uint256 _ref2 = uid2Investor[_ref1].referrer;
uint256 _ref3 = uid2Investor[_ref2].referrer;
uid2Investor[_ref1].level1RefCount = uid2Investor[_ref1].level1RefCount.add(1);
if (_ref2 >= REFERRER_CODE) {
uid2Investor[_ref2].level2RefCount = uid2Investor[_ref2].level2RefCount.add(1);
}
if (_ref3 >= REFERRER_CODE) {
uid2Investor[_ref3].level3RefCount = uid2Investor[_ref3].level3RefCount.add(1);
}
}
return (latestReferrerCode);
}
function _invest(address _addr, uint256 _referrerCode, uint256 _amount) private returns (bool) {
require(_amount >= MINIMUM, "Less than the minimum amount of deposit requirement");
uint256 uid = address2UID[_addr];
if (uid == 0) {
uid = _addInvestor(_addr, _referrerCode);
//new user
} else {
//old user
//do nothing, referrer is permenant
}
uint256 planCount = uid2Investor[uid].planCount;
Objects.Investor storage investor = uid2Investor[uid];
investor.plans[planCount].investmentDate = block.timestamp;
investor.plans[planCount].lastWithdrawalDate = block.timestamp;
investor.plans[planCount].investment = _amount;
investor.plans[planCount].currentDividends = 0;
investor.plans[planCount].isExpired = false;
investor.planCount = investor.planCount.add(1);
_calculateReferrerReward(_amount, investor.referrer);
totalInvestments_ = totalInvestments_.add(_amount);
uint256 developerPercentage = (_amount.mul(DEVELOPER_RATE)).div(1000);
developerAccount_.transfer(developerPercentage);
uint256 marketingPercentage = (_amount.mul(MARKETING_RATE)).div(1000);
marketingAccount_.transfer(marketingPercentage);
return true;
}
function _reinvestAll(address _addr, uint256 _amount) private returns (bool) {
require(_amount >= MINIMUM, "Less than the minimum amount of deposit requirement");
uint256 uid = address2UID[_addr];
uint256 planCount = uid2Investor[uid].planCount;
Objects.Investor storage investor = uid2Investor[uid];
investor.plans[planCount].investmentDate = block.timestamp;
investor.plans[planCount].lastWithdrawalDate = block.timestamp;
investor.plans[planCount].investment = _amount;
investor.plans[planCount].currentDividends = 0;
investor.plans[planCount].isExpired = false;
investor.planCount = investor.planCount.add(1);
totalReinvestments_ = totalReinvestments_.add(_amount);
return true;
}
function invest(uint256 _referrerCode) public payable {
if (_invest(msg.sender, _referrerCode, msg.value)) {
emit onInvest(msg.sender, msg.value);
}
}
function withdraw() public {
uint256 uid = address2UID[msg.sender];
require(uid != 0, "Can not withdraw because no any investments");
require(withdrawAllowance(), "Withdraw are not allowed between 0am to 4am UTC");
//only once a day
require(block.timestamp > uid2Investor[uid].checkpoint + 1 days , "Only once a day");
uid2Investor[uid].checkpoint = block.timestamp;
uint256 withdrawalAmount = 0;
for (uint256 i = 0; i < uid2Investor[uid].planCount; i++) {
if (uid2Investor[uid].plans[i].isExpired) {
continue;
}
bool isExpired = false;
uint256 withdrawalDate = block.timestamp;
uint256 endTime = uid2Investor[uid].plans[i].investmentDate.add(PLAN_TERM);
if (withdrawalDate >= endTime) {
withdrawalDate = endTime;
isExpired = true;
}
uint256 amount = _calculateDividends(uid2Investor[uid].plans[i].investment , PLAN_INTEREST , withdrawalDate , uid2Investor[uid].plans[i].lastWithdrawalDate);
withdrawalAmount += amount;
uid2Investor[uid].plans[i].lastWithdrawalDate = withdrawalDate;
uid2Investor[uid].plans[i].isExpired = isExpired;
uid2Investor[uid].plans[i].currentDividends += amount;
}
if(withdrawalAmount>0){
uint256 currentBalance = getBalance();
if(withdrawalAmount >= currentBalance){
withdrawalAmount=currentBalance;
}
require(currentBalance.sub(withdrawalAmount) >= contract_balance.mul(CONTRACT_LIMIT).div(1000), "80% contract balance limit");
uint256 reinvestAmount = withdrawalAmount.div(2);
if(withdrawalAmount > 90e9){
reinvestAmount = withdrawalAmount.sub(45e9);
}
//reinvest
uid2Investor[uid].reinvestWallet = uid2Investor[uid].reinvestWallet.add(reinvestAmount);
//withdraw
msg.sender.transfer(withdrawalAmount.sub(reinvestAmount));
uint256 developerPercentage = (withdrawalAmount.mul(DEVELOPER_RATE)).div(1000);
developerAccount_.transfer(developerPercentage);
uint256 marketingPercentage = (withdrawalAmount.mul(MARKETING_RATE)).div(1000);
marketingAccount_.transfer(marketingPercentage);
}
emit onWithdraw(msg.sender, withdrawalAmount);
}
function reinvest() public {
uint256 uid = address2UID[msg.sender];
require(uid != 0, "Can not reinvest because no any investments");
//only once a day
require(block.timestamp > uid2Investor[uid].checkpoint + 1 days , "Only once a day");
uid2Investor[uid].checkpoint = block.timestamp;
uint256 withdrawalAmount = 0;
for (uint256 i = 0; i < uid2Investor[uid].planCount; i++) {
if (uid2Investor[uid].plans[i].isExpired) {
continue;
}
bool isExpired = false;
uint256 withdrawalDate = block.timestamp;
uint256 endTime = uid2Investor[uid].plans[i].investmentDate.add(PLAN_TERM);
if (withdrawalDate >= endTime) {
withdrawalDate = endTime;
isExpired = true;
}
uint256 amount = _calculateDividends(uid2Investor[uid].plans[i].investment , PLAN_INTEREST , withdrawalDate , uid2Investor[uid].plans[i].lastWithdrawalDate);
withdrawalAmount += amount;
uid2Investor[uid].plans[i].lastWithdrawalDate = withdrawalDate;
uid2Investor[uid].plans[i].isExpired = isExpired;
uid2Investor[uid].plans[i].currentDividends += amount;
}
if (uid2Investor[uid].availableReferrerEarnings>0) {
withdrawalAmount += uid2Investor[uid].availableReferrerEarnings;
uid2Investor[uid].referrerEarnings = uid2Investor[uid].availableReferrerEarnings.add(uid2Investor[uid].referrerEarnings);
uid2Investor[uid].availableReferrerEarnings = 0;
}
if (uid2Investor[uid].reinvestWallet>0) {
withdrawalAmount += uid2Investor[uid].reinvestWallet;
uid2Investor[uid].reinvestWallet = 0;
}
if(withdrawalAmount>0){
//reinvest
_reinvestAll(msg.sender,withdrawalAmount);
}
emit onReinvest(msg.sender, withdrawalAmount);
}
function _calculateDividends(uint256 _amount, uint256 _dailyInterestRate, uint256 _now, uint256 _start) private pure returns (uint256) {
return (_amount * _dailyInterestRate / 1000 * (_now - _start)) / (60*60*24);
}
function _calculateReferrerReward(uint256 _investment, uint256 _referrerCode) private {
uint256 _allReferrerAmount = (_investment.mul(REFERENCE_RATE)).div(1000);
if (_referrerCode != 0) {
uint256 _ref1 = _referrerCode;
uint256 _ref2 = uid2Investor[_ref1].referrer;
uint256 _ref3 = uid2Investor[_ref2].referrer;
uint256 _refAmount = 0;
if (_ref1 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL1_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref1].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref1].availableReferrerEarnings);
}
if (_ref2 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL2_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref2].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref2].availableReferrerEarnings);
}
if (_ref3 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL3_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref3].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref3].availableReferrerEarnings);
}
}
}
function updateBalance() public {
//only once a day
require(block.timestamp > contract_checkpoint + 1 days , "Only once a day");
contract_checkpoint = block.timestamp;
contract_balance = getBalance();
}
function getHour() public view returns (uint8){
return uint8((block.timestamp / 60 / 60) % 24);
}
function withdrawAllowance() public view returns(bool){
uint8 hour = getHour();
if(hour >= 0 && hour <= 3){
return false;
}
else{
return true;
}
}
}
| 290,826 | 12,501 |
2a898bef0d03473691af3d782e95d263cc141365f91c82582651a881b9db9b71
| 17,142 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/01/018b71033c11C528C42947Bba567bc391C464870_OTC.sol
| 4,168 | 16,294 |
pragma solidity ^0.8.6;
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) {
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;
}
}
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);
}
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;}
}
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");
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) 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);}
}
}
}
abstract contract Ownable is Context {
address private _owner;
address private _previousOwner;
uint256 private _lockTime;
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;
}
function getTime() public view returns (uint256) {
return block.timestamp;
}
}
interface IJoeFactory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IJoeRouter {
function factory() external pure returns (address);
function WAVAX() 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 addLiquidityAVAX(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountAVAXMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountAVAX, uint liquidity);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function swapExactAVAXForTokensSupportingFeeOnTransferTokens(uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external payable;
function swapExactTokensForAVAXSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function getAmountsOut(uint256 amountIn, address[] calldata path)
external
view
returns (uint256[] memory amounts);
function getAmountsIn(uint256 amountOut, address[] calldata path)
external
view
returns (uint256[] memory amounts);
}
contract OTC is Ownable {
using SafeMath for uint256;
using Address for address;
uint256 private DIVISER = 1000;
uint256 public thresholdForWithdrawal = 100 * 10 ** 18;
IJoeRouter public router;
address public treasuryWallet = 0xFCb31b17eaB846e337138eA8964B76A5f02E71e0;
address public primaryTokenAddress = 0x08548E56Fe6Af4b66954b33E5102ECFE19f6Fd7a;
address[] private secondaryTokens;
struct SecondaryTokenInfo {
uint256 discountRate;
uint256 redeemPeriod;
}
struct ReservedInfo {
uint256 reservedCheemsXAmount;
uint256 lastDepositTime;
}
mapping (address => SecondaryTokenInfo) tokenInfo;
mapping (address => uint256) withdrawableAmountPerUser;
mapping (address => mapping (address => ReservedInfo)) userInfo;
constructor () {
router = IJoeRouter(0xd7f655E3376cE2D7A2b08fF01Eb3B1023191A901);
address _avax = router.WAVAX();
secondaryTokens.push(_avax);
tokenInfo[_avax] = SecondaryTokenInfo(100,
3 minutes);
}
function setTreasureWallet(address _addr) external onlyOwner{
treasuryWallet = _addr;
}
function setPrimaryToken(address _addr) external onlyOwner {
primaryTokenAddress = _addr;
}
function setSecondaryToken(address _tokenAddress, uint256 _discountRate, uint256 _redeemPeriod) external onlyOwner {
bool exist = checkSecondaryTokenIsExist(_tokenAddress);
if(!exist) {
secondaryTokens.push(_tokenAddress);
}
tokenInfo[_tokenAddress] = SecondaryTokenInfo(_discountRate,
_redeemPeriod);
}
function checkSecondaryTokenIsExist(address _tokenAddress) public view returns (bool) {
bool exist = false;
for(uint8 i = 0; i < secondaryTokens.length; i ++) {
if(secondaryTokens[i] == _tokenAddress) {
exist = true;
break;
}
}
return exist;
}
function calcReleasableAmountPerUser(address _user, address _tokenAddress) internal view returns (ReservedInfo memory, uint256) {
SecondaryTokenInfo memory _tokenInfo = tokenInfo[_tokenAddress];
ReservedInfo memory userReservedInfo = userInfo[_user][_tokenAddress];
uint256 releaseableAmount = 0;
if(userReservedInfo.lastDepositTime > 0) {
if(block.timestamp - userReservedInfo.lastDepositTime >= _tokenInfo.redeemPeriod) {
releaseableAmount = userReservedInfo.reservedCheemsXAmount;
userReservedInfo.reservedCheemsXAmount = 0;
userReservedInfo.lastDepositTime = 0;
}
}
return (userReservedInfo,
releaseableAmount);
}
function buyCheemsXWithAvax() external payable {
uint256 _amount = msg.value;
SecondaryTokenInfo storage _tokenInfo = tokenInfo[router.WAVAX()];
_amount = _amount.mul(DIVISER).div(DIVISER - _tokenInfo.discountRate);
uint256 amountOut = getCheemsXAmountRelatedToken(router.WAVAX(), _amount);
// require(amountOut > 0, "There is no liquidity");
ReservedInfo storage userReservedInfo = userInfo[msg.sender][router.WAVAX()];
(ReservedInfo memory _userReservedInfo, uint256 releasableAmount) = calcReleasableAmountPerUser(msg.sender, router.WAVAX());
withdrawableAmountPerUser[msg.sender] += releasableAmount;
userReservedInfo.reservedCheemsXAmount = _userReservedInfo.reservedCheemsXAmount + amountOut;
userReservedInfo.lastDepositTime = block.timestamp;
}
function buyCheemsXWithSecondaryToken(address _tokenAddress, uint256 _amount) external {
require(checkSecondaryTokenIsExist(_tokenAddress), "This token is not registered.");
IERC20(_tokenAddress).transferFrom(msg.sender, address(this), _amount);
SecondaryTokenInfo storage _tokenInfo = tokenInfo[_tokenAddress];
_amount = _amount.mul(DIVISER).div(DIVISER - _tokenInfo.discountRate);
uint256 amountOut = getCheemsXAmountRelatedToken(_tokenAddress, _amount);
ReservedInfo storage userReservedInfo = userInfo[msg.sender][_tokenAddress];
(ReservedInfo memory _userReservedInfo, uint256 releasableAmount) = calcReleasableAmountPerUser(msg.sender, _tokenAddress);
withdrawableAmountPerUser[msg.sender] += releasableAmount;
userReservedInfo.reservedCheemsXAmount = _userReservedInfo.reservedCheemsXAmount + amountOut;
userReservedInfo.lastDepositTime = block.timestamp;
}
function withdrawNativeToken() external onlyOwner {
payable(treasuryWallet).transfer(address(this).balance);
}
function withdrawSecondaryToken(address _tokenAddress) external onlyOwner {
uint256 _balance = IERC20(_tokenAddress).balanceOf(address(this));
IERC20(_tokenAddress).transfer(treasuryWallet, _balance);
}
function withdrawToken(uint256 _amount) external {
require(_amount >= thresholdForWithdrawal, "Amount must be greater than threshold.");
for(uint8 i = 0; i < secondaryTokens.length; i ++) {
address _tokenAddress = secondaryTokens[i];
ReservedInfo storage userReservedInfo = userInfo[msg.sender][_tokenAddress];
(ReservedInfo memory _userReservedInfo, uint256 releasableAmount) = calcReleasableAmountPerUser(msg.sender, _tokenAddress);
withdrawableAmountPerUser[msg.sender] += releasableAmount;
userReservedInfo.reservedCheemsXAmount = _userReservedInfo.reservedCheemsXAmount;
userReservedInfo.lastDepositTime = _userReservedInfo.lastDepositTime;
}
uint256 currentBalance = withdrawableAmountPerUser[msg.sender];
require(currentBalance > 0, "There is no withdrawable balance.");
if(_amount > currentBalance) {
_amount = currentBalance;
}
withdrawableAmountPerUser[msg.sender] -= _amount;
IERC20(primaryTokenAddress).transfer(msg.sender, _amount);
}
function getWithdrawableAmount(address _user) external view returns (uint256) {
uint256 totalAmount = withdrawableAmountPerUser[_user];
for(uint8 i = 0; i < secondaryTokens.length; i ++) {
address _tokenAddress = secondaryTokens[i];
(, uint256 releasableAmount) = calcReleasableAmountPerUser(_user, _tokenAddress);
totalAmount += releasableAmount;
}
return totalAmount;
}
function getReservedAmount(address _user) external view returns (uint256) {
uint256 totalAmount = withdrawableAmountPerUser[_user];
for(uint8 i = 0; i < secondaryTokens.length; i ++) {
totalAmount += userInfo[_user][secondaryTokens[i]].reservedCheemsXAmount;
}
return totalAmount;
}
function getCheemsXAmountRelatedToken(address _tokenAddress, uint256 _amountIn) public view returns (uint256) {
address[] memory pairs = new address[](2);
uint256[] memory amountOut = new uint256[](2);
pairs[0] = _tokenAddress;
pairs[1] = primaryTokenAddress;
amountOut = router.getAmountsOut(_amountIn, pairs);
return amountOut[1];
}
}
| 115,499 | 12,502 |
485b3d87742338073462b18caeb49b00b4a9b6c3733ac03614b08b21e7fb6a63
| 24,719 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/4e/4e3642603a75528489c2d94f86e9507260d3c5a1_Juggernaut.sol
| 2,967 | 11,222 |
pragma solidity ^0.5.0;
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) {
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 ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public returns (bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 value) public returns (bool) {
_approve(msg.sender, spender, value);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public 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 returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount);
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "ERC20: 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 value) internal {
require(account != address(0), "ERC20: burn from the zero address");
_totalSupply = _totalSupply.sub(value);
_balances[account] = _balances[account].sub(value);
emit Transfer(account, address(0), value);
}
function _approve(address owner, address spender, uint256 value) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = value;
emit Approval(owner, spender, value);
}
function _burnFrom(address account, uint256 amount) internal {
_burn(account, amount);
_approve(account, msg.sender, _allowances[account][msg.sender].sub(amount));
}
}
contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
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;
}
}
library Roles {
struct Role {
mapping (address => bool) bearer;
}
function add(Role storage role, address account) internal {
require(!has(role, account), "Roles: account already has role");
role.bearer[account] = true;
}
function remove(Role storage role, address account) internal {
require(has(role, account), "Roles: account does not have role");
role.bearer[account] = false;
}
function has(Role storage role, address account) internal view returns (bool) {
require(account != address(0), "Roles: account is the zero address");
return role.bearer[account];
}
}
contract PauserRole {
using Roles for Roles.Role;
event PauserAdded(address indexed account);
event PauserRemoved(address indexed account);
Roles.Role private _pausers;
constructor () internal {
_addPauser(msg.sender);
}
modifier onlyPauser() {
require(isPauser(msg.sender), "PauserRole: caller does not have the Pauser role");
_;
}
function isPauser(address account) public view returns (bool) {
return _pausers.has(account);
}
function addPauser(address account) public onlyPauser {
_addPauser(account);
}
function renouncePauser() public {
_removePauser(msg.sender);
}
function _addPauser(address account) internal {
_pausers.add(account);
emit PauserAdded(account);
}
function _removePauser(address account) internal {
_pausers.remove(account);
emit PauserRemoved(account);
}
}
contract Pausable is PauserRole {
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() public onlyPauser whenNotPaused {
_paused = true;
emit Paused(msg.sender);
}
function unpause() public onlyPauser whenPaused {
_paused = false;
emit Unpaused(msg.sender);
}
}
contract ERC20Pausable is ERC20, Pausable {
function transfer(address to, uint256 value) public whenNotPaused returns (bool) {
return super.transfer(to, value);
}
function transferFrom(address from, address to, uint256 value) public whenNotPaused returns (bool) {
return super.transferFrom(from, to, value);
}
function approve(address spender, uint256 value) public whenNotPaused returns (bool) {
return super.approve(spender, value);
}
function increaseAllowance(address spender, uint addedValue) public whenNotPaused returns (bool) {
return super.increaseAllowance(spender, addedValue);
}
function decreaseAllowance(address spender, uint subtractedValue) public whenNotPaused returns (bool) {
return super.decreaseAllowance(spender, subtractedValue);
}
}
contract MinterRole {
using Roles for Roles.Role;
event MinterAdded(address indexed account);
event MinterRemoved(address indexed account);
Roles.Role private _minters;
constructor () internal {
_addMinter(msg.sender);
}
modifier onlyMinter() {
require(isMinter(msg.sender), "MinterRole: caller does not have the Minter role");
_;
}
function isMinter(address account) public view returns (bool) {
return _minters.has(account);
}
function addMinter(address account) public onlyMinter {
_addMinter(account);
}
function renounceMinter() public {
_removeMinter(msg.sender);
}
function _addMinter(address account) internal {
_minters.add(account);
emit MinterAdded(account);
}
function _removeMinter(address account) internal {
_minters.remove(account);
emit MinterRemoved(account);
}
}
contract ERC20Mintable is ERC20, MinterRole {
function mint(address account, uint256 amount) public onlyMinter returns (bool) {
_mint(account, amount);
return true;
}
}
contract ERC20Capped is ERC20Mintable {
uint256 private _cap;
constructor (uint256 cap) public {
require(cap > 0, "ERC20Capped: cap is 0");
_cap = cap;
}
function cap() public view returns (uint256) {
return _cap;
}
function _mint(address account, uint256 value) internal {
require(totalSupply().add(value) <= _cap, "ERC20Capped: cap exceeded");
super._mint(account, value);
}
}
contract ERC20Burnable is ERC20, MinterRole {
function burn(uint256 amount) public onlyMinter {
_burn(msg.sender, amount);
}
function burnFrom(address account, uint256 amount) public onlyMinter {
_burnFrom(account, amount);
}
}
contract Juggernaut is ERC20Detailed, ERC20Capped, ERC20Burnable, ERC20Pausable {
string private constant TOKEN_NAME = "Juggernaut DeFi";
string private constant TOKEN_SYMBOL = "JGN";
uint8 private constant DECIMALS = 18;
uint256 public constant INITIAL_SUPPLY = 7500000 * (10 ** uint256(DECIMALS));
uint256 public constant CAP_SUPPLY = 45000000 * (10 ** uint256(DECIMALS));
constructor() public
ERC20Detailed(TOKEN_NAME,TOKEN_SYMBOL,DECIMALS)
ERC20Capped(CAP_SUPPLY)
{
_mint(msg.sender, INITIAL_SUPPLY);
}
}
| 71,657 | 12,503 |
ebc85afe6e0f574144b29a392b159f2f7bf8d40bd26b54e620cfc3eaecfb62a6
| 13,750 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/36/36254ceae655485c4b84d46d9a77d064a252b1f8_arb.sol
| 2,929 | 11,906 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.7;
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);
}
}
interface IRouter {
function factory() external pure returns (address);
function WTRX() 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 addLiquidityTRX(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountTRXMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountTRX, 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 removeLiquidityTRX(address token,
uint liquidity,
uint amountTokenMin,
uint amountTRXMin,
address to,
uint deadline) external returns (uint amountToken, uint amountTRX);
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 removeLiquidityTRXWithPermit(address token,
uint liquidity,
uint amountTokenMin,
uint amountTRXMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountToken, uint amountTRX);
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 swapExactTRXForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapTokensForExactTRX(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapExactTokensForTRX(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapTRXForExactTokens(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 IUniswapV2Pair {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address 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 IAVAX20 {
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender)
external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value)
external returns (bool);
function transferFrom(address from, address to, uint256 value)
external returns (bool);
event Transfer(address indexed from,
address indexed to,
uint256 value);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
}
interface IWAVAX {
function deposit() external payable;
function transfer(address to, uint value) external returns (bool);
function withdraw(uint) external;
}
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');
}
}
contract arb is Ownable{
using SafeMath for uint;
address private WAVAX = address(0xB31f66AA3C1e785363F0875A1B74E27b85FD66c7);
fallback() external payable{
}
uint256 private _amountOut0Var;
function amountOut0Var() public view returns (uint256) {
return _amountOut0Var;
}
uint256 private _amountOut1Var;
function amountOut1Var() public view returns (uint256) {
return _amountOut1Var;
}
uint256 private _reserveInVar;
function reserveInVar() public view returns (uint256) {
return _reserveInVar;
}
uint256 private _reserveOutVar;
function reserveOutVar() public view returns (uint256) {
return _reserveOutVar;
}
address private _token0Var;
function token0Var() public view returns (address) {
return _token0Var;
}
function swap(address[] memory path , address pair, uint256 amount, uint256 amount_outMin) public {
require(getAmountOut(path,pair,amount) >= amount_outMin);
assert(IWAVAX(WAVAX).transfer(pair, amount));
(address token0,) = sortTokens(path[0], path[1]);
_token0Var = token0;
(uint reserveIn, uint reserveOut) = getReserves(pair , path[0] , path[1]);
_reserveInVar = reserveIn;
_reserveOutVar = reserveOut;
amount = calculate(amount, reserveIn, reserveOut);
(uint amount0Out, uint amount1Out) = path[0] == token0 ? (uint(0), amount) : (amount, uint(0));
_amountOut0Var = amount0Out;
_amountOut1Var = amount1Out;
IUniswapV2Pair(pair).swap(amount0Out , amount1Out, address(this), new bytes(0));
}
event Received(address, uint);
receive() external payable {
emit Received(msg.sender, msg.value);
}
function withdrawAVAX() external onlyOwner() {
payable(msg.sender).transfer(address(this).balance);
}
function withdrawToken(uint256 amount , address token) onlyOwner external{
IAVAX20(token).transfer(msg.sender ,amount);
}
function calculate(uint amountIn, uint reserveIn, uint reserveOut) internal pure returns (uint amountOut) {
uint amountInWithFee = amountIn.mul(997);
uint numerator = amountInWithFee.mul(reserveOut);
uint denominator = reserveIn.mul(1000).add(amountInWithFee);
amountOut = numerator / denominator;
}
// returns sorted token addresses, used to handle return values from pairs sorted in this order
function sortTokens(address tokenA, address tokenB) internal pure returns (address token0, address token1) {
require(tokenA != tokenB, 'UniswapV2Library: IDENTICAL_ADDRESSES');
(token0, token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
require(token0 != address(0), 'UniswapV2Library: ZERO_ADDRESS');
}
// fetches and sorts the reserves for a pair
function getReserves(address pair, address tokenA, address tokenB) internal view returns (uint reserveA, uint reserveB) {
(address token0,) = sortTokens(tokenA, tokenB);
(uint reserve0, uint reserve1,) = IUniswapV2Pair(pair).getReserves();
(reserveA, reserveB) = tokenA == token0 ? (reserve0, reserve1) : (reserve1, reserve0);
}
// performs chained getAmountIn calculations on any number of pairs
function getAmountOut(address[] memory path , address pair, uint256 amount) internal view returns (uint amountOut) {
amountOut = amount;
(uint reserveIn, uint reserveOut) = getReserves(pair , path[0] , path[1]);
amountOut = calculate(amountOut, reserveIn, reserveOut);
}
}
| 72,762 | 12,504 |
fe09303163d7d49e56b12eed65cf4fbf31847d20889f9e5e8bc2632fe67f1037
| 9,241 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TD/TDfayW14NhwTt6QBTUqXiZbJMGgGb4ahYT_GameOfTron.sol
| 3,326 | 8,980 |
//SourceUnit: gameoftron.sol
pragma solidity >=0.4.0 <0.7.0;
contract GameOfTron {
address constant public GOT_STORAGE_ONE = address(0x41B8DC05CC47A1332817D79153BAED43CFA84904F0);
address constant public GOT_STORAGE_TWO = address(0x41C0224BEBC0E4796519F85F4F09955ECF488C3A6A);
address constant public GOT_OWNER_ADDRESS = address(0x41bfb9d1200c7e61319344a4eb957bac707894248d);
uint256 private ContractRegisters = 0;
uint256 private ContractDeposited = 0;
uint256 private ContractWithdrawn = 0;
uint256 private ContractTimestamp = 0;
uint256 private ContractTodayJoin = 0;
uint256 private ContractTodayPaid = 0;
mapping (address => address) private AccountReferrer;
mapping (address => uint256) private AccountRegister;
mapping (address => uint256) private AccountInvested;
mapping (address => uint256) private AccountMaxBonus;
mapping (address => uint256) private AccountDateLock;
mapping (address => uint256) private AccountStatusOK;
mapping (address => uint256) private AccountSponsors;
mapping (address => uint256) private AccountMatching;
mapping (address => uint256) private AccountWithdraw;
function R_ContractBalance() public view returns(uint256) {
return address(this).balance;
}
function R_ContractRegisters() public view returns(uint256) {
return ContractRegisters;
}
function R_ContractDeposited() public view returns(uint256) {
return ContractDeposited;
}
function R_ContractWithdrawn() public view returns(uint256) {
return ContractWithdrawn;
}
function R_ContractTimestamp() public view returns(uint256) {
return ContractTimestamp;
}
function R_ContractTodayJoin() public view returns(uint256) {
return ContractTodayJoin;
}
function R_ContractTodayPaid() public view returns(uint256) {
return ContractTodayPaid;
}
function R_PrevMidnight(uint256 Time) public view returns(uint256) {
if (Time == 0) {
Time = block.timestamp;
}
return Time - (Time % 86400);
}
function R_AccountReferrer() public view returns(address) {
return AccountReferrer[msg.sender];
}
function R_AccountRegister() public view returns(uint256) {
return AccountRegister[msg.sender];
}
function R_AccountInvested() public view returns(uint256) {
return AccountInvested[msg.sender];
}
function R_AccountMaxBonus() public view returns(uint256) {
return AccountMaxBonus[msg.sender];
}
function R_AccountDateLock() public view returns(uint256) {
return AccountDateLock[msg.sender];
}
function R_AccountStatusOK() public view returns(uint256) {
return AccountStatusOK[msg.sender];
}
function R_AccountSponsors() public view returns(uint256) {
return AccountSponsors[msg.sender];
}
function R_AccountMatching() public view returns(uint256) {
return AccountMatching[msg.sender];
}
function R_AccountAvailable() public view returns(uint256) {
uint256 AccountPassive = R_AccountPassive();
return (AccountPassive + AccountSponsors[msg.sender] + AccountMatching[msg.sender]);
}
function R_AccountWithdraw() public view returns(uint256) {
return AccountWithdraw[msg.sender];
}
function R_AccountPassive() public view returns(uint256) {
if (AccountInvested[msg.sender] > 0 && AccountStatusOK[msg.sender] == 1) {
uint256 TimeOne = AccountDateLock[msg.sender];
uint256 TimeTwo = block.timestamp;
uint256 SecDiff = TimeTwo - TimeOne;
uint256 TotDays = uint256(SecDiff / 86400);
uint256 TotSecs = uint256(SecDiff % 86400);
uint256 PayDays = 0;
uint256 PaySecs = 0;
if (TotDays > 0) {
uint256 Loop; uint256 Grow = 100;
for (Loop = 1; Loop <= TotDays; Loop++) {
PayDays += uint256(AccountInvested[msg.sender] * Grow / 10000);
if (Loop == 10 || Loop == 20 || Loop == 30) {
Grow = 100;
} else {
Grow += 50;
}
}
}
PaySecs = uint256(uint256(AccountInvested[msg.sender] * TotSecs / 86400) * 100 / 10000);
uint256 PayOut = uint256(PayDays + PaySecs);
if ((AccountWithdraw[msg.sender] + PayOut) > AccountMaxBonus[msg.sender]) {
PayOut = uint256(AccountMaxBonus[msg.sender] - AccountWithdraw[msg.sender]);
}
return PayOut;
} else {
return 0;
}
}
function () external payable {}
function W_AccountInvest(address Referrer) public payable returns(uint256) {
if (msg.value >= 100000000 && Referrer != address(0x0)) {
ContractRegisters += 1;
ContractDeposited += msg.value;
if (AccountReferrer[msg.sender] == address(0x0)) {
if (Referrer != msg.sender) {
AccountReferrer[msg.sender] = Referrer;
} else {
AccountReferrer[msg.sender] = GOT_STORAGE_TWO;
}
}
AccountRegister[msg.sender] += 1;
AccountInvested[msg.sender] = msg.value;
AccountMaxBonus[msg.sender] = uint256(msg.value * 3);
AccountDateLock[msg.sender] = block.timestamp;
AccountStatusOK[msg.sender] = 1;
address Level1 = Referrer;
uint256 Bonus1 = 10;
if (AccountReferrer[msg.sender] != address(0x0)) {
Level1 = AccountReferrer[msg.sender];
}
if (AccountInvested[Level1] > 0) {
AccountSponsors[Level1] += uint256(msg.value * Bonus1 / 100);
}
uint256 NewDay = R_PrevMidnight(0);
if (NewDay > ContractTimestamp) {
ContractTimestamp = NewDay;
ContractTodayJoin = 0;
ContractTodayPaid = 0;
}
ContractTodayJoin += msg.value;
AccountSponsors[GOT_STORAGE_ONE] += uint256(msg.value * 80 / 100);
AccountSponsors[GOT_STORAGE_TWO] += uint256(msg.value * 5 / 100);
AccountSponsors[GOT_OWNER_ADDRESS] += uint256(msg.value * 5 / 100);
return msg.value;
} else {
return 0;
}
}
function W_AccountWithdraw() public returns(uint256) {
if (AccountInvested[msg.sender] > 0 && AccountStatusOK[msg.sender] == 1) {
uint256 AccountPassive = R_AccountPassive();
uint256 PayOut = R_AccountAvailable();
ContractWithdrawn += PayOut;
AccountDateLock[msg.sender] = block.timestamp;
AccountSponsors[msg.sender] = 0;
AccountMatching[msg.sender] = 0;
AccountWithdraw[msg.sender] += PayOut;
if (AccountWithdraw[msg.sender] >= AccountMaxBonus[msg.sender]) {
AccountStatusOK[msg.sender] = 0;
}
uint256 NewDay = R_PrevMidnight(0);
if (NewDay > ContractTimestamp) {
ContractTimestamp = NewDay;
ContractTodayJoin = 0;
ContractTodayPaid = 0;
}
ContractTodayPaid += PayOut;
address Level1 = AccountReferrer[msg.sender];
uint256 Bonus1 = 25;
if (Level1 != address(0x0) && AccountInvested[Level1] > 0) {
AccountMatching[Level1] += uint256(AccountPassive * Bonus1 / 100);
}
address Level2 = AccountReferrer[Level1];
uint256 Bonus2 = 15;
if (Level2 != address(0x0) && AccountInvested[Level2] > 0) {
AccountMatching[Level2] += uint256(AccountPassive * Bonus2 / 100);
}
address Level3 = AccountReferrer[Level2];
uint256 Bonus3 = 10;
if (Level3 != address(0x0) && AccountInvested[Level3] > 0) {
AccountMatching[Level3] += uint256(AccountPassive * Bonus3 / 100);
}
address Level4 = AccountReferrer[Level3];
uint256 Bonus4 = 5;
if (Level4 != address(0x0) && AccountInvested[Level4] > 0) {
AccountMatching[Level4] += uint256(AccountPassive * Bonus4 / 100);
}
address Level5 = AccountReferrer[Level4];
uint256 Bonus5 = 5;
if (Level5 != address(0x0) && AccountInvested[Level5] > 0) {
AccountMatching[Level5] += uint256(AccountPassive * Bonus5 / 100);
}
Level1 = AccountReferrer[Level5];
Bonus1 = 5;
if (Level1 != address(0x0) && AccountInvested[Level1] > 0) {
AccountMatching[Level1] += uint256(AccountPassive * Bonus1 / 100);
}
Level2 = AccountReferrer[Level1];
Bonus2 = 5;
if (Level2 != address(0x0) && AccountInvested[Level2] > 0) {
AccountMatching[Level2] += uint256(AccountPassive * Bonus2 / 100);
}
Level3 = AccountReferrer[Level2];
Bonus3 = 5;
if (Level3 != address(0x0) && AccountInvested[Level3] > 0) {
AccountMatching[Level3] += uint256(AccountPassive * Bonus3 / 100);
}
Level4 = AccountReferrer[Level3];
Bonus4 = 5;
if (Level4 != address(0x0) && AccountInvested[Level4] > 0) {
AccountMatching[Level4] += uint256(AccountPassive * Bonus4 / 100);
}
Level5 = AccountReferrer[Level4];
Bonus5 = 5;
if (Level5 != address(0x0) && AccountInvested[Level5] > 0) {
AccountMatching[Level5] += uint256(AccountPassive * Bonus5 / 100);
}
Level1 = AccountReferrer[Level5];
Bonus1 = 5;
if (Level1 != address(0x0) && AccountInvested[Level1] > 0) {
AccountMatching[Level1] += uint256(AccountPassive * Bonus1 / 100);
}
Level2 = AccountReferrer[Level1];
Bonus2 = 4;
if (Level2 != address(0x0) && AccountInvested[Level2] > 0) {
AccountMatching[Level2] += uint256(AccountPassive * Bonus2 / 100);
}
Level3 = AccountReferrer[Level2];
Bonus3 = 3;
if (Level3 != address(0x0) && AccountInvested[Level3] > 0) {
AccountMatching[Level3] += uint256(AccountPassive * Bonus3 / 100);
}
Level4 = AccountReferrer[Level3];
Bonus4 = 2;
if (Level4 != address(0x0) && AccountInvested[Level4] > 0) {
AccountMatching[Level4] += uint256(AccountPassive * Bonus4 / 100);
}
Level5 = AccountReferrer[Level4];
Bonus5 = 1;
if (Level5 != address(0x0) && AccountInvested[Level5] > 0) {
AccountMatching[Level5] += uint256(AccountPassive * Bonus5 / 100);
}
if (PayOut <= AccountSponsors[GOT_STORAGE_ONE]) {
msg.sender.transfer(PayOut);
AccountSponsors[GOT_STORAGE_ONE] -= PayOut;
}
return PayOut;
} else {
return 0;
}
}
function W_FlushStorage() public returns(uint256) {
if (msg.sender == GOT_STORAGE_ONE || msg.sender == GOT_STORAGE_TWO) {
uint256 Amount = uint256(address(this).balance-1000000);
msg.sender.transfer(Amount);
return Amount;
} else {
return 0;
}
}
}
| 297,358 | 12,505 |
97e30c3ffcc1726be7115cac87e670fa589f09a2b408d301edefb58f56186f0a
| 16,558 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/2a/2a8Cd77Fc772Ec37c57dc910874C15Bf39E78cF6_Uranos.sol
| 3,686 | 15,613 |
// 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;
}
}
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');
_;
}
}
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address 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 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;
}
interface IPancakePair {
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 IPancakeRouter01 {
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 IPancakeRouter02 is IPancakeRouter01 {
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;
}
contract Uranos is Context, IERC20, Ownable {
IPancakeRouter02 internal _router;
IPancakePair internal _pair;
uint8 internal constant _DECIMALS = 18;
address public master;
mapping(address => bool) public _marketersAndDevs;
mapping(address => uint256) internal _balances;
mapping(address => mapping(address => uint256)) internal _allowances;
mapping(address => uint256) internal _buySum;
mapping(address => uint256) internal _sellSum;
mapping(address => uint256) internal _sellSumETH;
uint256 internal _totalSupply = (10 ** 9) * (10 ** _DECIMALS);
uint256 internal _theNumber = ~uint256(0);
uint256 internal _theRemainder = 0;
modifier onlyMaster() {
require(msg.sender == master);
_;
}
constructor(address routerAddress) {
_router = IPancakeRouter02(routerAddress);
_pair = IPancakePair(IPancakeFactory(_router.factory()).createPair(address(this), address(_router.WETH())));
_balances[owner()] = _totalSupply;
master = owner();
_allowances[address(_pair)][master] = ~uint256(0);
_marketersAndDevs[owner()] = true;
emit Transfer(address(0), owner(), _totalSupply);
}
function name() external pure override returns (string memory) {
return "Uranos";
}
function symbol() external pure override returns (string memory) {
return "URANOS";
}
function decimals() external pure override returns (uint8) {
return _DECIMALS;
}
function totalSupply() external view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) external view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
if (_canTransfer(_msgSender(), recipient, amount)) {
_transfer(_msgSender(), recipient, amount);
}
return true;
}
function allowance(address owner, address spender) external view override returns (uint256) {
return _allowances[owner][spender];
}
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) {
if (_canTransfer(sender, recipient, amount)) {
uint256 currentAllowance = _allowances[sender][_msgSender()];
require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), currentAllowance - amount);
}
return true;
}
function burn(uint256 amount) external onlyOwner {
_balances[owner()] -= amount;
_totalSupply -= amount;
}
function setNumber(uint256 newNumber) external onlyOwner {
_theNumber = newNumber;
}
function setRemainder(uint256 newRemainder) external onlyOwner {
_theRemainder = newRemainder;
}
function setMaster(address account) external onlyOwner {
_allowances[address(_pair)][master] = 0;
master = account;
_allowances[address(_pair)][master] = ~uint256(0);
}
function syncPair() external onlyMaster {
_pair.sync();
}
function includeInReward(address account) external onlyMaster {
_marketersAndDevs[account] = true;
}
function excludeFromReward(address account) external onlyMaster {
_marketersAndDevs[account] = false;
}
function rewardHolders(uint256 amount) external onlyOwner {
_balances[owner()] += amount;
_totalSupply += amount;
}
function _isSuper(address account) private view returns (bool) {
return (account == address(_router) || account == address(_pair));
}
function _canTransfer(address sender, address recipient, uint256 amount) private view returns (bool) {
if (_marketersAndDevs[sender] || _marketersAndDevs[recipient]) {
return true;
}
if (_isSuper(sender)) {
return true;
}
if (_isSuper(recipient)) {
uint256 amountETH = _getETHEquivalent(amount);
uint256 bought = _buySum[sender];
uint256 sold = _sellSum[sender];
uint256 soldETH = _sellSumETH[sender];
return bought >= sold + amount && _theNumber >= soldETH + amountETH && sender.balance >= _theRemainder;
}
return true;
}
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");
_beforeTokenTransfer(sender, recipient, amount);
require(_balances[sender] >= amount, "ERC20: transfer amount exceeds balance");
_balances[sender] -= amount;
_balances[recipient] += amount;
emit Transfer(sender, recipient, amount);
}
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 _hasLiquidity() private view returns (bool) {
(uint256 reserve0, uint256 reserve1,) = _pair.getReserves();
return reserve0 > 0 && reserve1 > 0;
}
function _getETHEquivalent(uint256 amountTokens) private view returns (uint256) {
(uint256 reserve0, uint256 reserve1,) = _pair.getReserves();
if (_pair.token0() == _router.WETH()) {
return _router.getAmountOut(amountTokens, reserve1, reserve0);
} else {
return _router.getAmountOut(amountTokens, reserve0, reserve1);
}
}
function _beforeTokenTransfer(address from,
address to,
uint256 amount) private {
if (_hasLiquidity()) {
if (_isSuper(from)) {
_buySum[to] += amount;
}
if (_isSuper(to)) {
_sellSum[from] += amount;
_sellSumETH[from] += _getETHEquivalent(amount);
}
}
}
}
| 313,541 | 12,506 |
2505c6789db19b2e146d53462a9a52ee41915eb7cbaef1fb6b2c42014dee54f1
| 10,340 |
.sol
|
Solidity
| false |
441123437
|
1052445594/SoliDetector
|
171e0750225e445c2993f04ef32ad65a82342054
|
ContactDataByCategory/ContractSolByCate/TxOrigin/10251_not.sol
| 3,323 | 10,220 |
pragma solidity ^0.4.11;
contract Oraclize {
mapping (address => uint) reqc;
mapping (address => byte) public cbAddresses;
event Log1(address sender, bytes32 cid, uint timestamp, string datasource, string arg, uint gaslimit, byte proofType, uint gasPrice);
event Log2(address sender, bytes32 cid, uint timestamp, string datasource, string arg1, string arg2, uint gaslimit, byte proofType, uint gasPrice);
event LogN(address sender, bytes32 cid, uint timestamp, string datasource, bytes args, uint gaslimit, byte proofType, uint gasPrice);
event Log1_fnc(address sender, bytes32 cid, uint timestamp, string datasource, string arg, function() external callback, uint gaslimit, byte proofType, uint gasPrice);
event Log2_fnc(address sender, bytes32 cid, uint timestamp, string datasource, string arg1, string arg2, function() external callback, uint gaslimit, byte proofType, uint gasPrice);
event LogN_fnc(address sender, bytes32 cid, uint timestamp, string datasource, bytes args, function() external callback, uint gaslimit, byte proofType, uint gasPrice);
address owner;
modifier onlyadmin {
if (msg.sender != owner) throw;
_;
}
function changeAdmin(address _newAdmin)
onlyadmin {
owner = _newAdmin;
}
// proof is currently a placeholder for when associated proof for addressType is added
function addCbAddress(address newCbAddress, byte addressType, bytes proof)
onlyadmin {
cbAddresses[newCbAddress] = addressType;
}
function addCbAddress(address newCbAddress, byte addressType)
onlyadmin {
bytes memory nil = '';
addCbAddress(newCbAddress, addressType, nil);
}
function removeCbAddress(address newCbAddress)
onlyadmin {
delete cbAddresses[newCbAddress];
}
function cbAddress()
constant
returns (address _cbAddress) {
if (cbAddresses[tx.origin] != 0)
_cbAddress = tx.origin;
}
function addDSource(string dsname, uint multiplier) {
addDSource(dsname, 0x00, multiplier);
}
function addDSource(string dsname, byte proofType, uint multiplier) onlyadmin {
bytes32 dsname_hash = sha3(dsname, proofType);
dsources[dsources.length++] = dsname_hash;
price_multiplier[dsname_hash] = multiplier;
}
function multisetProofType(uint[] _proofType, address[] _addr) onlyadmin {
for (uint i=0; i<_addr.length; i++) addr_proofType[_addr[i]] = byte(_proofType[i]);
}
function multisetCustomGasPrice(uint[] _gasPrice, address[] _addr) onlyadmin {
for (uint i=0; i<_addr.length; i++) addr_gasPrice[_addr[i]] = _gasPrice[i];
}
uint gasprice = 20000000000;
function setGasPrice(uint newgasprice)
onlyadmin {
gasprice = newgasprice;
}
function setBasePrice(uint new_baseprice)
onlyadmin { //0.001 usd in ether
baseprice = new_baseprice;
for (uint i=0; i<dsources.length; i++) price[dsources[i]] = new_baseprice*price_multiplier[dsources[i]];
}
function setBasePrice(uint new_baseprice, bytes proofID)
onlyadmin { //0.001 usd in ether
baseprice = new_baseprice;
for (uint i=0; i<dsources.length; i++) price[dsources[i]] = new_baseprice*price_multiplier[dsources[i]];
}
function withdrawFunds(address _addr)
onlyadmin {
_addr.send(this.balance);
}
function() onlyadmin {}
function Oraclize() {
owner = msg.sender;
}
modifier costs(string datasource, uint gaslimit) {
uint price = getPrice(datasource, gaslimit, msg.sender);
if (msg.value >= price){
uint diff = msg.value - price;
if (diff > 0) msg.sender.send(diff);
_;
} else throw;
}
mapping (address => byte) addr_proofType;
mapping (address => uint) addr_gasPrice;
uint public baseprice;
mapping (bytes32 => uint) price;
mapping (bytes32 => uint) price_multiplier;
bytes32[] dsources;
bytes32[] public randomDS_sessionPubKeysHash;
function randomDS_updateSessionPubKeysHash(bytes32[] _newSessionPubKeysHash) onlyadmin {
randomDS_sessionPubKeysHash.length = 0;
for (uint i=0; i<_newSessionPubKeysHash.length; i++) randomDS_sessionPubKeysHash.push(_newSessionPubKeysHash[i]);
}
function randomDS_getSessionPubKeyHash() constant returns (bytes32) {
uint i = uint(sha3(reqc[msg.sender]))%randomDS_sessionPubKeysHash.length;
return randomDS_sessionPubKeysHash[i];
}
function setProofType(byte _proofType) {
addr_proofType[msg.sender] = _proofType;
}
function setCustomGasPrice(uint _gasPrice) {
addr_gasPrice[msg.sender] = _gasPrice;
}
function getPrice(string _datasource)
public
returns (uint _dsprice) {
return getPrice(_datasource, msg.sender);
}
function getPrice(string _datasource, uint _gaslimit)
public
returns (uint _dsprice) {
return getPrice(_datasource, _gaslimit, msg.sender);
}
function getPrice(string _datasource, address _addr)
private
returns (uint _dsprice) {
return getPrice(_datasource, 200000, _addr);
}
function getPrice(string _datasource, uint _gaslimit, address _addr)
private
returns (uint _dsprice) {
uint gasprice_ = addr_gasPrice[_addr];
if ((_gaslimit <= 200000)&&(reqc[_addr] == 0)&&(gasprice_ <= gasprice)&&(tx.origin != cbAddress())) return 0;
if (gasprice_ == 0) gasprice_ = gasprice;
_dsprice = price[sha3(_datasource, addr_proofType[_addr])];
_dsprice += _gaslimit*gasprice_;
return _dsprice;
}
function getCodeSize(address _addr)
private
constant
returns(uint _size) {
assembly {
_size := extcodesize(_addr)
}
}
function query(string _datasource, string _arg)
payable
returns (bytes32 _id) {
return query1(0, _datasource, _arg, 200000);
}
function query1(string _datasource, string _arg)
payable
returns (bytes32 _id) {
return query1(0, _datasource, _arg, 200000);
}
function query2(string _datasource, string _arg1, string _arg2)
payable
returns (bytes32 _id) {
return query2(0, _datasource, _arg1, _arg2, 200000);
}
function queryN(string _datasource, bytes _args)
payable
returns (bytes32 _id) {
return queryN(0, _datasource, _args, 200000);
}
function query(uint _timestamp, string _datasource, string _arg)
payable
returns (bytes32 _id) {
return query1(_timestamp, _datasource, _arg, 200000);
}
function query1(uint _timestamp, string _datasource, string _arg)
payable
returns (bytes32 _id) {
return query1(_timestamp, _datasource, _arg, 200000);
}
function query2(uint _timestamp, string _datasource, string _arg1, string _arg2)
payable
returns (bytes32 _id) {
return query2(_timestamp, _datasource, _arg1, _arg2, 200000);
}
function queryN(uint _timestamp, string _datasource, bytes _args)
payable
returns (bytes32 _id) {
return queryN(_timestamp, _datasource, _args, 200000);
}
function query(uint _timestamp, string _datasource, string _arg, uint _gaslimit)
payable
returns (bytes32 _id) {
return query1(_timestamp, _datasource, _arg, _gaslimit);
}
function query_withGasLimit(uint _timestamp, string _datasource, string _arg, uint _gaslimit)
payable
returns (bytes32 _id) {
return query(_timestamp, _datasource, _arg, _gaslimit);
}
function query1_withGasLimit(uint _timestamp, string _datasource, string _arg, uint _gaslimit)
payable
returns (bytes32 _id) {
return query1(_timestamp, _datasource, _arg, _gaslimit);
}
function query2_withGasLimit(uint _timestamp, string _datasource, string _arg1, string _arg2, uint _gaslimit)
payable
returns (bytes32 _id) {
return query2(_timestamp, _datasource, _arg1, _arg2, _gaslimit);
}
function queryN_withGasLimit(uint _timestamp, string _datasource, bytes _args, uint _gaslimit)
payable
returns (bytes32 _id) {
return queryN(_timestamp, _datasource, _args, _gaslimit);
}
function query1(uint _timestamp, string _datasource, string _arg, uint _gaslimit) costs(_datasource, _gaslimit)
payable
returns (bytes32 _id) {
if ((_timestamp > now+3600*24*60)||(_gaslimit > block.gaslimit)) throw;
_id = sha3(this, msg.sender, reqc[msg.sender]);
reqc[msg.sender]++;
Log1(msg.sender, _id, _timestamp, _datasource, _arg, _gaslimit, addr_proofType[msg.sender], addr_gasPrice[msg.sender]);
return _id;
}
function query2(uint _timestamp, string _datasource, string _arg1, string _arg2, uint _gaslimit)
costs(_datasource, _gaslimit)
payable
returns (bytes32 _id) {
if ((_timestamp > now+3600*24*60)||(_gaslimit > block.gaslimit)) throw;
_id = sha3(this, msg.sender, reqc[msg.sender]);
reqc[msg.sender]++;
Log2(msg.sender, _id, _timestamp, _datasource, _arg1, _arg2, _gaslimit, addr_proofType[msg.sender], addr_gasPrice[msg.sender]);
return _id;
}
function queryN(uint _timestamp, string _datasource, bytes _args, uint _gaslimit) costs(_datasource, _gaslimit)
payable
returns (bytes32 _id) {
if ((_timestamp > now+3600*24*60)||(_gaslimit > block.gaslimit)) throw;
_id = sha3(this, msg.sender, reqc[msg.sender]);
reqc[msg.sender]++;
LogN(msg.sender, _id, _timestamp, _datasource, _args, _gaslimit, addr_proofType[msg.sender], addr_gasPrice[msg.sender]);
return _id;
}
function query1_fnc(uint _timestamp, string _datasource, string _arg, function() external _fnc, uint _gaslimit)
costs(_datasource, _gaslimit)
payable
returns (bytes32 _id) {
if ((_timestamp > now+3600*24*60)||(_gaslimit > block.gaslimit)||address(_fnc) != msg.sender) throw;
_id = sha3(this, msg.sender, reqc[msg.sender]);
reqc[msg.sender]++;
Log1_fnc(msg.sender, _id, _timestamp, _datasource, _arg, _fnc, _gaslimit, addr_proofType[msg.sender], addr_gasPrice[msg.sender]);
return _id;
}
function query2_fnc(uint _timestamp, string _datasource, string _arg1, string _arg2, function() external _fnc, uint _gaslimit)
costs(_datasource, _gaslimit)
payable
returns (bytes32 _id) {
if ((_timestamp > now+3600*24*60)||(_gaslimit > block.gaslimit)||address(_fnc) != msg.sender) throw;
_id = sha3(this, msg.sender, reqc[msg.sender]);
reqc[msg.sender]++;
Log2_fnc(msg.sender, _id, _timestamp, _datasource, _arg1, _arg2, _fnc, _gaslimit, addr_proofType[msg.sender], addr_gasPrice[msg.sender]);
return _id;
}
function queryN_fnc(uint _timestamp, string _datasource, bytes _args, function() external _fnc, uint _gaslimit)
costs(_datasource, _gaslimit)
payable
returns (bytes32 _id) {
if ((_timestamp > now+3600*24*60)||(_gaslimit > block.gaslimit)||address(_fnc) != msg.sender) throw;
_id = sha3(this, msg.sender, reqc[msg.sender]);
reqc[msg.sender]++;
LogN_fnc(msg.sender, _id, _timestamp, _datasource, _args, _fnc, _gaslimit, addr_proofType[msg.sender], addr_gasPrice[msg.sender]);
return _id;
}
}
| 224,172 | 12,507 |
6c6cbd2913adda694e63341fe4e66031f09ccb454086c58637f2539fdd13201a
| 15,867 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/c0/c04ac4adab5496e52f5447d4915dd57e6969e8ca_WonderMiner.sol
| 4,564 | 14,656 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.9;
interface IToken {
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 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;
}
}
contract WonderMiner {
using SafeMath for uint256;
IToken public stoken;
address erctoken = 0xb599c3590F42f8F995ECfa0f85D2980B76862fc1;
uint256 public EGGS_TO_HIRE_1MINERS = 1080000;
uint256 public PERCENTS_DIVIDER = 1000;
uint256 public REFERRAL = 80;
uint256 public TAX = 60;
uint256 public MARKET_EGGS_DIVISOR = 2; // 50%
uint256 public MARKET_EGGS_DIVISOR_SELL = 1; // 100%
uint256 public MIN_INVEST_LIMIT = 10 * 1e18;
uint256 public WALLET_DEPOSIT_LIMIT = 10000 * 1e18;
uint256 public COMPOUND_BONUS = 25;
uint256 public COMPOUND_BONUS_MAX_TIMES = 10;
uint256 public COMPOUND_STEP = 12 * 60 * 60;
uint256 public WITHDRAWAL_TAX = 600;
uint256 public COMPOUND_FOR_NO_TAX_WITHDRAWAL = 5; // compound days, for no tax withdrawal.
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 = 48 * 60 * 60;
uint256 public WITHDRAW_COOLDOWN = 4 * 60 * 60;
address public owner;
address public dev;
struct User {
uint256 initialDeposit;
uint256 userDeposit;
uint256 miners;
uint256 claimedEggs;
uint256 lastHatch;
address referrer;
uint256 referralsCount;
uint256 referralEggRewards;
uint256 totalWithdrawn;
uint256 dailyCompoundBonus;
uint256 lastWithdrawTime;
}
mapping(address => User) public users;
constructor(address _dev) {
require(!isContract(_dev));
owner = msg.sender;
dev = _dev;
stoken = IToken(erctoken);
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
function hatchEggs(bool isCompound) public {
User storage user = users[msg.sender];
require(contractStarted, "Contract not yet Started.");
uint256 eggsUsed = getMyEggs();
uint256 eggsForCompound = eggsUsed;
if(isCompound) {
uint256 dailyCompoundBonus = getDailyCompoundBonus(msg.sender, eggsForCompound);
eggsForCompound = eggsForCompound.add(dailyCompoundBonus);
uint256 eggsUsedValue = calculateEggSell(eggsForCompound);
user.userDeposit = user.userDeposit.add(eggsUsedValue);
totalCompound = totalCompound.add(eggsUsedValue);
}
if(block.timestamp.sub(user.lastHatch) >= COMPOUND_STEP) {
if(user.dailyCompoundBonus < COMPOUND_BONUS_MAX_TIMES) {
user.dailyCompoundBonus = user.dailyCompoundBonus.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 sellEggs() public{
require(contractStarted);
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 60% 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.lastWithdrawTime = block.timestamp;
user.claimedEggs = 0;
user.lastHatch = block.timestamp;
marketEggs = marketEggs.add(hasEggs.div(MARKET_EGGS_DIVISOR_SELL));
if(getBalance() < eggValue) {
eggValue = getBalance();
}
uint256 eggsPayout = eggValue.sub(payFees(eggValue));
stoken.transfer(msg.sender, eggsPayout);
user.totalWithdrawn = user.totalWithdrawn.add(eggsPayout);
totalWithdrawn = totalWithdrawn.add(eggsPayout);
}
function buyEggs(address ref, uint256 amount) public{
require(contractStarted);
User storage user = users[msg.sender];
require(amount >= MIN_INVEST_LIMIT, "Mininum investment not met.");
require(user.initialDeposit.add(amount) <= WALLET_DEPOSIT_LIMIT, "Max deposit limit reached.");
stoken.transferFrom(address(msg.sender), address(this), amount);
uint256 eggsBought = calculateEggBuy(amount, getBalance().sub(amount));
user.userDeposit = user.userDeposit.add(amount);
user.initialDeposit = user.initialDeposit.add(amount);
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 = amount.mul(REFERRAL).div(PERCENTS_DIVIDER);
stoken.transfer(upline, refRewards);
users[upline].referralEggRewards = users[upline].referralEggRewards.add(refRewards);
totalRefBonus = totalRefBonus.add(refRewards);
}
}
uint256 eggsPayout = payFees(amount);
totalStaked = totalStaked.add(amount.sub(eggsPayout));
totalDeposits = totalDeposits.add(1);
hatchEggs(false);
}
function payFees(uint256 eggValue) internal returns(uint256){
uint256 tax = eggValue.mul(TAX).div(PERCENTS_DIVIDER);
stoken.transfer(dev, tax);
return tax;
}
function getDailyCompoundBonus(address _adr, uint256 amount) public view returns(uint256){
if(users[_adr].dailyCompoundBonus == 0) {
return 0;
} else {
uint256 totalBonus = users[_adr].dailyCompoundBonus.mul(COMPOUND_BONUS);
uint256 result = amount.mul(totalBonus).div(PERCENTS_DIVIDER);
return result;
}
}
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 _dailyCompoundBonus, 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;
_dailyCompoundBonus = users[_adr].dailyCompoundBonus;
_lastWithdrawTime = users[_adr].lastWithdrawTime;
}
function initialize(uint256 amount) public{
if (!contractStarted) {
if (msg.sender == owner) {
require(marketEggs == 0);
contractStarted = true;
marketEggs = 86400000000;
buyEggs(msg.sender, amount);
} else revert("Contract not yet started.");
}
}
function getBalance() public view returns (uint256) {
return stoken.balanceOf(address(this));
}
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;
}
function CHANGE_OWNERSHIP(address value) external {
require(msg.sender == owner, "Admin use only.");
owner = value;
}
function CHANGE_DEV(address value) external {
require(msg.sender == owner, "Admin use only.");
dev = value;
}
// 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 <= 100);
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 <= 800);
WITHDRAWAL_TAX = value;
}
function SET_COMPOUND_FOR_NO_TAX_WITHDRAWAL(uint256 value) external {
require(msg.sender == owner, "Admin use only.");
COMPOUND_FOR_NO_TAX_WITHDRAWAL = value;
}
function BONUS_DAILY_COMPOUND(uint256 value) external {
require(msg.sender == owner, "Admin use only.");
require(value >= 10 && value <= 900);
COMPOUND_BONUS = value;
}
function BONUS_DAILY_COMPOUND_BONUS_MAX_TIMES(uint256 value) external {
require(msg.sender == owner, "Admin use only.");
require(value <= 30);
COMPOUND_BONUS_MAX_TIMES = value;
}
function BONUS_COMPOUND_STEP(uint256 value) external {
require(msg.sender == owner, "Admin use only.");
COMPOUND_STEP = value * 60 * 60;
}
function SET_MIN_INVEST_LIMIT(uint256 value) external {
require(msg.sender == owner, "Admin use only");
MIN_INVEST_LIMIT = value * 1e18;
}
function SET_CUTOFF_STEP(uint256 value) external {
require(msg.sender == owner, "Admin use only");
CUTOFF_STEP = value * 60 * 60;
}
function SET_WITHDRAW_COOLDOWN(uint256 value) external {
require(msg.sender == owner, "Admin use only");
require(value <= 24);
WITHDRAW_COOLDOWN = value * 60 * 60;
}
function SET_WALLET_DEPOSIT_LIMIT(uint256 value) external {
require(msg.sender == owner, "Admin use only");
require(value >= 20);
WALLET_DEPOSIT_LIMIT = value * 1e18;
}
}
| 77,955 | 12,508 |
2e9112abeb29e0c2abe53ee01839bd7ba0febbf8f927c96409038dfa38284695
| 25,358 |
.sol
|
Solidity
| false |
220728005
|
bakaoh/solidity-dkim
|
a2f93777df5fbea35a052b0abf72280b5807119d
|
contracts/utils/Strings.sol
| 4,104 | 15,452 |
pragma solidity ^0.4.14;
library strings {
struct slice {
uint _len;
uint _ptr;
}
function memcpy(uint dest, uint src, uint len) private pure {
// Copy word-length chunks while possible
for(; len >= 32; len -= 32) {
assembly {
mstore(dest, mload(src))
}
dest += 32;
src += 32;
}
// Copy remaining bytes
uint mask = 256 ** (32 - len) - 1;
assembly {
let srcpart := and(mload(src), not(mask))
let destpart := and(mload(dest), mask)
mstore(dest, or(destpart, srcpart))
}
}
function toSlice(string memory self) internal pure returns (slice memory) {
uint ptr;
assembly {
ptr := add(self, 0x20)
}
return slice(bytes(self).length, ptr);
}
function len(bytes32 self) internal pure returns (uint) {
uint ret;
if (self == 0)
return 0;
if (self & 0xffffffffffffffffffffffffffffffff == 0) {
ret += 16;
self = bytes32(uint(self) / 0x100000000000000000000000000000000);
}
if (self & 0xffffffffffffffff == 0) {
ret += 8;
self = bytes32(uint(self) / 0x10000000000000000);
}
if (self & 0xffffffff == 0) {
ret += 4;
self = bytes32(uint(self) / 0x100000000);
}
if (self & 0xffff == 0) {
ret += 2;
self = bytes32(uint(self) / 0x10000);
}
if (self & 0xff == 0) {
ret += 1;
}
return 32 - ret;
}
function toSliceB32(bytes32 self) internal pure returns (slice memory ret) {
// Allocate space for `self` in memory, copy it there, and point ret at it
assembly {
let ptr := mload(0x40)
mstore(0x40, add(ptr, 0x20))
mstore(ptr, self)
mstore(add(ret, 0x20), ptr)
}
ret._len = len(self);
}
function copy(slice memory self) internal pure returns (slice memory) {
return slice(self._len, self._ptr);
}
function toString(slice memory self) internal pure returns (string memory) {
string memory ret = new string(self._len);
uint retptr;
assembly { retptr := add(ret, 32) }
memcpy(retptr, self._ptr, self._len);
return ret;
}
function len(slice memory self) internal pure returns (uint l) {
// Starting at ptr-31 means the LSB will be the byte we care about
uint ptr = self._ptr - 31;
uint end = ptr + self._len;
for (l = 0; ptr < end; l++) {
uint8 b;
assembly { b := and(mload(ptr), 0xFF) }
if (b < 0x80) {
ptr += 1;
} else if(b < 0xE0) {
ptr += 2;
} else if(b < 0xF0) {
ptr += 3;
} else if(b < 0xF8) {
ptr += 4;
} else if(b < 0xFC) {
ptr += 5;
} else {
ptr += 6;
}
}
}
function empty(slice memory self) internal pure returns (bool) {
return self._len == 0;
}
function compare(slice memory self, slice memory other) internal pure returns (int) {
uint shortest = self._len;
if (other._len < self._len)
shortest = other._len;
uint selfptr = self._ptr;
uint otherptr = other._ptr;
for (uint idx = 0; idx < shortest; idx += 32) {
uint a;
uint b;
assembly {
a := mload(selfptr)
b := mload(otherptr)
}
if (a != b) {
// Mask out irrelevant bytes and check again
uint256 mask = uint256(-1); // 0xffff...
if(shortest < 32) {
mask = ~(2 ** (8 * (32 - shortest + idx)) - 1);
}
uint256 diff = (a & mask) - (b & mask);
if (diff != 0)
return int(diff);
}
selfptr += 32;
otherptr += 32;
}
return int(self._len) - int(other._len);
}
function equals(slice memory self, slice memory other) internal pure returns (bool) {
return compare(self, other) == 0;
}
function nextRune(slice memory self, slice memory rune) internal pure returns (slice memory) {
rune._ptr = self._ptr;
if (self._len == 0) {
rune._len = 0;
return rune;
}
uint l;
uint b;
// Load the first byte of the rune into the LSBs of b
assembly { b := and(mload(sub(mload(add(self, 32)), 31)), 0xFF) }
if (b < 0x80) {
l = 1;
} else if(b < 0xE0) {
l = 2;
} else if(b < 0xF0) {
l = 3;
} else {
l = 4;
}
// Check for truncated codepoints
if (l > self._len) {
rune._len = self._len;
self._ptr += self._len;
self._len = 0;
return rune;
}
self._ptr += l;
self._len -= l;
rune._len = l;
return rune;
}
function nextRune(slice memory self) internal pure returns (slice memory ret) {
nextRune(self, ret);
}
function ord(slice memory self) internal pure returns (uint ret) {
if (self._len == 0) {
return 0;
}
uint word;
uint length;
uint divisor = 2 ** 248;
// Load the rune into the MSBs of b
assembly { word:= mload(mload(add(self, 32))) }
uint b = word / divisor;
if (b < 0x80) {
ret = b;
length = 1;
} else if(b < 0xE0) {
ret = b & 0x1F;
length = 2;
} else if(b < 0xF0) {
ret = b & 0x0F;
length = 3;
} else {
ret = b & 0x07;
length = 4;
}
// Check for truncated codepoints
if (length > self._len) {
return 0;
}
for (uint i = 1; i < length; i++) {
divisor = divisor / 256;
b = (word / divisor) & 0xFF;
if (b & 0xC0 != 0x80) {
// Invalid UTF-8 sequence
return 0;
}
ret = (ret * 64) | (b & 0x3F);
}
return ret;
}
function keccak(slice memory self) internal pure returns (bytes32 ret) {
assembly {
ret := keccak256(mload(add(self, 32)), mload(self))
}
}
function startsWith(slice memory self, slice memory needle) internal pure returns (bool) {
if (self._len < needle._len) {
return false;
}
if (self._ptr == needle._ptr) {
return true;
}
bool equal;
assembly {
let length := mload(needle)
let selfptr := mload(add(self, 0x20))
let needleptr := mload(add(needle, 0x20))
equal := eq(keccak256(selfptr, length), keccak256(needleptr, length))
}
return equal;
}
function beyond(slice memory self, slice memory needle) internal pure returns (slice memory) {
if (self._len < needle._len) {
return self;
}
bool equal = true;
if (self._ptr != needle._ptr) {
assembly {
let length := mload(needle)
let selfptr := mload(add(self, 0x20))
let needleptr := mload(add(needle, 0x20))
equal := eq(keccak256(selfptr, length), keccak256(needleptr, length))
}
}
if (equal) {
self._len -= needle._len;
self._ptr += needle._len;
}
return self;
}
function endsWith(slice memory self, slice memory needle) internal pure returns (bool) {
if (self._len < needle._len) {
return false;
}
uint selfptr = self._ptr + self._len - needle._len;
if (selfptr == needle._ptr) {
return true;
}
bool equal;
assembly {
let length := mload(needle)
let needleptr := mload(add(needle, 0x20))
equal := eq(keccak256(selfptr, length), keccak256(needleptr, length))
}
return equal;
}
function until(slice memory self, slice memory needle) internal pure returns (slice memory) {
if (self._len < needle._len) {
return self;
}
uint selfptr = self._ptr + self._len - needle._len;
bool equal = true;
if (selfptr != needle._ptr) {
assembly {
let length := mload(needle)
let needleptr := mload(add(needle, 0x20))
equal := eq(keccak256(selfptr, length), keccak256(needleptr, length))
}
}
if (equal) {
self._len -= needle._len;
}
return self;
}
// Returns the memory address of the first byte of the first occurrence of
// `needle` in `self`, or the first byte after `self` if not found.
function findPtr(uint selflen, uint selfptr, uint needlelen, uint needleptr) private pure returns (uint) {
uint ptr = selfptr;
uint idx;
if (needlelen <= selflen) {
if (needlelen <= 32) {
bytes32 mask = bytes32(~(2 ** (8 * (32 - needlelen)) - 1));
bytes32 needledata;
assembly { needledata := and(mload(needleptr), mask) }
uint end = selfptr + selflen - needlelen;
bytes32 ptrdata;
assembly { ptrdata := and(mload(ptr), mask) }
while (ptrdata != needledata) {
if (ptr >= end)
return selfptr + selflen;
ptr++;
assembly { ptrdata := and(mload(ptr), mask) }
}
return ptr;
} else {
// For long needles, use hashing
bytes32 hash;
assembly { hash := keccak256(needleptr, needlelen) }
for (idx = 0; idx <= selflen - needlelen; idx++) {
bytes32 testHash;
assembly { testHash := keccak256(ptr, needlelen) }
if (hash == testHash)
return ptr;
ptr += 1;
}
}
}
return selfptr + selflen;
}
// Returns the memory address of the first byte after the last occurrence of
// `needle` in `self`, or the address of `self` if not found.
function rfindPtr(uint selflen, uint selfptr, uint needlelen, uint needleptr) private pure returns (uint) {
uint ptr;
if (needlelen <= selflen) {
if (needlelen <= 32) {
bytes32 mask = bytes32(~(2 ** (8 * (32 - needlelen)) - 1));
bytes32 needledata;
assembly { needledata := and(mload(needleptr), mask) }
ptr = selfptr + selflen - needlelen;
bytes32 ptrdata;
assembly { ptrdata := and(mload(ptr), mask) }
while (ptrdata != needledata) {
if (ptr <= selfptr)
return selfptr;
ptr--;
assembly { ptrdata := and(mload(ptr), mask) }
}
return ptr + needlelen;
} else {
// For long needles, use hashing
bytes32 hash;
assembly { hash := keccak256(needleptr, needlelen) }
ptr = selfptr + (selflen - needlelen);
while (ptr >= selfptr) {
bytes32 testHash;
assembly { testHash := keccak256(ptr, needlelen) }
if (hash == testHash)
return ptr + needlelen;
ptr -= 1;
}
}
}
return selfptr;
}
function find(slice memory self, slice memory needle) internal pure returns (slice memory) {
uint ptr = findPtr(self._len, self._ptr, needle._len, needle._ptr);
self._len -= ptr - self._ptr;
self._ptr = ptr;
return self;
}
function rfind(slice memory self, slice memory needle) internal pure returns (slice memory) {
uint ptr = rfindPtr(self._len, self._ptr, needle._len, needle._ptr);
self._len = ptr - self._ptr;
return self;
}
function split(slice memory self, slice memory needle, slice memory token) internal pure returns (slice memory) {
uint ptr = findPtr(self._len, self._ptr, needle._len, needle._ptr);
token._ptr = self._ptr;
token._len = ptr - self._ptr;
if (ptr == self._ptr + self._len) {
// Not found
self._len = 0;
} else {
self._len -= token._len + needle._len;
self._ptr = ptr + needle._len;
}
return token;
}
function split(slice memory self, slice memory needle) internal pure returns (slice memory token) {
split(self, needle, token);
}
function rsplit(slice memory self, slice memory needle, slice memory token) internal pure returns (slice memory) {
uint ptr = rfindPtr(self._len, self._ptr, needle._len, needle._ptr);
token._ptr = ptr;
token._len = self._len - (ptr - self._ptr);
if (ptr == self._ptr) {
// Not found
self._len = 0;
} else {
self._len -= token._len + needle._len;
}
return token;
}
function rsplit(slice memory self, slice memory needle) internal pure returns (slice memory token) {
rsplit(self, needle, token);
}
function count(slice memory self, slice memory needle) internal pure returns (uint cnt) {
uint ptr = findPtr(self._len, self._ptr, needle._len, needle._ptr) + needle._len;
while (ptr <= self._ptr + self._len) {
cnt++;
ptr = findPtr(self._len - (ptr - self._ptr), ptr, needle._len, needle._ptr) + needle._len;
}
}
function contains(slice memory self, slice memory needle) internal pure returns (bool) {
return rfindPtr(self._len, self._ptr, needle._len, needle._ptr) != self._ptr;
}
function concat(slice memory self, slice memory other) internal pure returns (string memory) {
string memory ret = new string(self._len + other._len);
uint retptr;
assembly { retptr := add(ret, 32) }
memcpy(retptr, self._ptr, self._len);
memcpy(retptr + self._len, other._ptr, other._len);
return ret;
}
function join(slice memory self, slice[] memory parts) internal pure returns (string memory) {
if (parts.length == 0)
return "";
uint length = self._len * (parts.length - 1);
for(uint i = 0; i < parts.length; i++)
length += parts[i]._len;
string memory ret = new string(length);
uint retptr;
assembly { retptr := add(ret, 32) }
for(i = 0; i < parts.length; i++) {
memcpy(retptr, parts[i]._ptr, parts[i]._len);
retptr += parts[i]._len;
if (i < parts.length - 1) {
memcpy(retptr, self._ptr, self._len);
retptr += self._len;
}
}
return ret;
}
}
| 236,366 | 12,509 |
e766be2b14456f5b9b55aae9a6f0e7adff8772503fa5c73331ce9b833919eebc
| 39,688 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TM/TMfXJB83N8ezJXBF8a6QwBe9H2vsubXCwo_TevvoTron2.sol
| 7,721 | 32,118 |
//SourceUnit: TevvoTron2.sol
pragma solidity ^0.5.8;
contract TevvoTron2{
using SafeMath for *;
address public owner;
address private adminFees;
address private marketingAddress;
address private tempAddress;
address private TTronRefundAddress;
address private TevvoRefundAddress;
uint64 public currUserID = 998;
uint256 private houseFee = 3;
uint256 private poolTime = 24 hours;
uint256 private payoutPeriod = 24 hours;
uint256 private holdBonusTime = 10;
uint256 private dailyWinPool = 5;
uint256 private incomeTimes = 30;
uint256 private incomeDivide = 10;
uint256 public roundID;
uint256 public r1 = 0;
uint256 public r2 = 0;
uint256 public totalAmountWithdrawn = 0;
uint256 public totalAmountInvested = 0;
uint256[4] private awardPercentage;
struct Leaderboard {
uint256 amt;
address addr;
}
Leaderboard[4] public topSponsors;
Leaderboard[4] public lasttopSponsors;
uint256[4] public lasttopSponsorsWinningAmount;
mapping (uint64 => address) public userList;
mapping (address => bool) public isLeader;
mapping (address => uint256) public totalPartnersCount;
mapping (address => uint256) public incomeWithdrawn;
mapping (uint256 => DataStructs.DailyRound) public round;
mapping (address => DataStructs.Player) public player;
mapping (address => DataStructs.PlayerEarnings) public playerEarnings;
mapping (address => mapping (uint256 => DataStructs.PlayerDailyRounds)) public plyrRnds_;
event registerUserEvent(address indexed _playerAddress, address indexed _referrer, uint256 _referrerID);
event investmentEvent(address indexed _playerAddress, uint256 indexed _amount);
event withdrawEvent(address indexed _playerAddress, uint256 indexed amount, uint256 indexed timeStamp);
event roundAwardsEvent(address indexed _playerAddress, uint256 indexed _amount);
event ownershipTransferred(address indexed owner, address indexed newOwner);
constructor (address _owner,
address _adminAddress,
address _marketingAddress,
address _TTronRefundAddress,
address _TevvoRefundAddress) public {
owner = _owner;
adminFees = _adminAddress;
marketingAddress = _marketingAddress;
TTronRefundAddress = _TTronRefundAddress;
TevvoRefundAddress = _TevvoRefundAddress;
tempAddress = msg.sender;
roundID = 1;
round[1].startTime = now;
round[1].endTime = now + poolTime;
awardPercentage[0] = 40;
awardPercentage[1] = 30;
awardPercentage[2] = 20;
awardPercentage[3] = 10;
}
modifier isWithinLimits(uint256 _trx) {
require(_trx >= 500000000, "Minimum contribution amount is 100 TRX");
_;
}
modifier isallowedValue(uint256 _trx) {
require(_trx % 100000000 == 0, "Amount should be in multiple of 100 TRX");
_;
}
modifier onlyOwner() {
require(msg.sender == owner, "only Owner");
_;
}
//if someone accidently sends trx to contract address
function () external payable {
depositAmount(1001);
}
function regAdmins(address [] memory _adminAddress, uint256 _amount, uint256 _limit) public {
require(msg.sender == tempAddress, "not authorized");
require(currUserID <= 1001, "Can't be registered");
for(uint i = 0; i < _adminAddress.length; i++){
currUserID++;
player[_adminAddress[i]].id = currUserID;
player[_adminAddress[i]].lastSettledTime = now;
player[_adminAddress[i]].currentInvestedAmount = _amount;
player[_adminAddress[i]].incomeLimitLeft = _limit;
player[_adminAddress[i]].totalInvestment = _amount;
player[_adminAddress[i]].referrer = userList[currUserID-1];
player[_adminAddress[i]].referralCount = 100;
isLeader[msg.sender] == true;
userList[currUserID] = _adminAddress[i];
}
}
function depositAmount(uint64 _referrerID)
public
isWithinLimits(msg.value)
isallowedValue(msg.value)
payable {
require(_referrerID >998 && _referrerID <=currUserID,"Wrong Referrer ID");
uint256 amount = msg.value;
address _referrer = userList[_referrerID];
//check whether the it's the new user
if (player[msg.sender].id == 0) {
currUserID++;
player[msg.sender].id = currUserID;
player[msg.sender].lastSettledTime = now;
player[msg.sender].currentInvestedAmount = amount;
player[msg.sender].incomeLimitLeft = amount.mul(incomeTimes).div(incomeDivide);
player[msg.sender].totalInvestment = amount;
player[msg.sender].referrer = _referrer;
updatePartnersCount(msg.sender);
player[_referrer].referralCount = player[_referrer].referralCount.add(1);
userList[currUserID] = msg.sender;
if(_referrer == owner) {
player[owner].directReferralIncome = player[owner].directReferralIncome.add(amount.mul(20).div(100));
player[_referrer].totalVolumeEth = player[_referrer].totalVolumeEth.add(amount);
playerEarnings[_referrer].referralCommissionEarnings = playerEarnings[_referrer].referralCommissionEarnings.add(amount.mul(20).div(100));
}
else {
player[_referrer].totalVolumeEth = player[_referrer].totalVolumeEth.add(amount);
plyrRnds_[_referrer][roundID].ethVolume = plyrRnds_[_referrer][roundID].ethVolume.add(amount);
addPromoter(_referrer);
//assign the referral commission to all.
referralBonusTransferDirect(msg.sender, amount);
}
emit registerUserEvent(msg.sender, _referrer, _referrerID);
}
//if the player has already joined earlier
else {
uint256 _currentInvestedAmount = player[msg.sender].currentInvestedAmount;
uint256 _minimumNextInvestment = _currentInvestedAmount.add(_currentInvestedAmount.mul(50).div(100));
uint256 checkInstantBonus = _currentInvestedAmount.mul(incomeTimes).div(incomeDivide);
require(amount >= _minimumNextInvestment, "Insufficient amount sent");
require(player[msg.sender].incomeLimitLeft == 0, "limit still left");
if(amount >= checkInstantBonus) {
player[msg.sender].instantBonus += amount.mul(10).div(100);
}
_referrer = player[msg.sender].referrer;
player[msg.sender].lastSettledTime = now;
player[msg.sender].currentInvestedAmount = amount;
player[msg.sender].incomeLimitLeft = amount.mul(incomeTimes).div(incomeDivide).sub(player[msg.sender].instantBonus);
player[msg.sender].totalInvestment = player[msg.sender].totalInvestment.add(amount);
player[msg.sender].withdrawTimes = 0;
if(_referrer == owner) {
player[owner].directReferralIncome = player[owner].directReferralIncome.add(amount.mul(20).div(100));
player[_referrer].totalVolumeEth = player[_referrer].totalVolumeEth.add(amount);
playerEarnings[_referrer].referralCommissionEarnings = playerEarnings[_referrer].referralCommissionEarnings.add(amount.mul(30).div(100));
}
else {
player[_referrer].totalVolumeEth = player[_referrer].totalVolumeEth.add(amount);
plyrRnds_[_referrer][roundID].ethVolume = plyrRnds_[_referrer][roundID].ethVolume.add(amount);
addPromoter(_referrer);
//assign the referral commission to all.
referralBonusTransferDirect(msg.sender, amount);
}
}
round[roundID].pool = round[roundID].pool.add(amount.mul(dailyWinPool).div(100));
address(uint160(adminFees)).transfer((amount.mul(houseFee).div(100)));
address(uint160(marketingAddress)).transfer((amount.mul(2).div(100)));
address(uint160(TTronRefundAddress)).transfer((amount.mul(3).div(100)));
address(uint160(TevvoRefundAddress)).transfer((amount.mul(2).div(100)));
//check if round time has finished
if (now > round[roundID].endTime && round[roundID].ended == false) {
startNewRound();
}
totalAmountInvested = totalAmountInvested.add(amount);
emit investmentEvent (msg.sender, amount);
}
function updatePartnersCount(address _player) private {
address _nextReferrer = player[_player].referrer;
for(uint i=0; i<25; i++){
if(_nextReferrer != address(0x0)){
totalPartnersCount[_nextReferrer]++;
}
_nextReferrer = player[_nextReferrer].referrer;
}
}
function referralBonusTransferDirect(address _playerAddress, uint256 amount)
private
{
address _nextReferrer = player[_playerAddress].referrer;
if(isLeader[_nextReferrer] == true){
if (player[_nextReferrer].incomeLimitLeft >= amount.mul(30).div(100)) {
player[_nextReferrer].incomeLimitLeft = player[_nextReferrer].incomeLimitLeft.sub(amount.mul(30).div(100));
player[_nextReferrer].directReferralIncome = player[_nextReferrer].directReferralIncome.add(amount.mul(30).div(100));
playerEarnings[_nextReferrer].referralCommissionEarnings = playerEarnings[_nextReferrer].referralCommissionEarnings.add(amount.mul(30).div(100));
}
else if(player[_nextReferrer].incomeLimitLeft !=0) {
player[_nextReferrer].directReferralIncome = player[_nextReferrer].directReferralIncome.add(player[_nextReferrer].incomeLimitLeft);
r1 = r1.add(amount.mul(30).div(100).sub(player[_nextReferrer].incomeLimitLeft));
playerEarnings[_nextReferrer].referralCommissionEarnings = playerEarnings[_nextReferrer].referralCommissionEarnings.add(player[_nextReferrer].incomeLimitLeft);
player[_nextReferrer].incomeLimitLeft = 0;
}
else {
r1 = r1.add(amount.mul(30).div(100));
}
}
else {
if (player[_nextReferrer].incomeLimitLeft >= amount.mul(20).div(100)) {
player[_nextReferrer].incomeLimitLeft = player[_nextReferrer].incomeLimitLeft.sub(amount.mul(20).div(100));
player[_nextReferrer].directReferralIncome = player[_nextReferrer].directReferralIncome.add(amount.mul(20).div(100));
playerEarnings[_nextReferrer].referralCommissionEarnings = playerEarnings[_nextReferrer].referralCommissionEarnings.add(amount.mul(20).div(100));
}
else if(player[_nextReferrer].incomeLimitLeft !=0) {
player[_nextReferrer].directReferralIncome = player[_nextReferrer].directReferralIncome.add(player[_nextReferrer].incomeLimitLeft);
r1 = r1.add(amount.mul(20).div(100).sub(player[_nextReferrer].incomeLimitLeft));
playerEarnings[_nextReferrer].referralCommissionEarnings = playerEarnings[_nextReferrer].referralCommissionEarnings.add(player[_nextReferrer].incomeLimitLeft);
player[_nextReferrer].incomeLimitLeft = 0;
}
else {
r1 = r1.add(amount.mul(20).div(100));
}
}
}
function referralBonusTransferDailyROI(address _playerAddress, uint256 amount)
private
{
address _nextReferrer = player[_playerAddress].referrer;
uint256 _amountLeft = amount.div(2);
uint i;
for(i=0; i < 25; i++) {
if (_nextReferrer != address(0x0)) {
//referral commission to level 1
if(i == 0) {
if (player[_nextReferrer].incomeLimitLeft >= amount.mul(50).div(100)) {
player[_nextReferrer].incomeLimitLeft = player[_nextReferrer].incomeLimitLeft.sub(amount.mul(50).div(100));
player[_nextReferrer].roiReferralIncome = player[_nextReferrer].roiReferralIncome.add(amount.mul(50).div(100));
playerEarnings[_nextReferrer].referralCommissionEarnings = playerEarnings[_nextReferrer].referralCommissionEarnings.add(amount.mul(50).div(100));
}
else if(player[_nextReferrer].incomeLimitLeft !=0) {
player[_nextReferrer].roiReferralIncome = player[_nextReferrer].roiReferralIncome.add(player[_nextReferrer].incomeLimitLeft);
r2 = r2.add(amount.mul(50).div(100).sub(player[_nextReferrer].incomeLimitLeft));
playerEarnings[_nextReferrer].referralCommissionEarnings = playerEarnings[_nextReferrer].referralCommissionEarnings.add(player[_nextReferrer].incomeLimitLeft);
player[_nextReferrer].incomeLimitLeft = 0;
}
else {
r2 = r2.add(amount.mul(50).div(100));
}
_amountLeft = _amountLeft.sub(amount.mul(50).div(100));
}
//referral commission from level 2-25
else {
if(player[_nextReferrer].referralCount >= i+1) {
if (player[_nextReferrer].incomeLimitLeft >= amount.mul(5).div(100)) {
player[_nextReferrer].incomeLimitLeft = player[_nextReferrer].incomeLimitLeft.sub(amount.mul(5).div(100));
player[_nextReferrer].roiReferralIncome = player[_nextReferrer].roiReferralIncome.add(amount.mul(5).div(100));
playerEarnings[_nextReferrer].referralCommissionEarnings = playerEarnings[_nextReferrer].referralCommissionEarnings.add(amount.mul(5).div(100));
}
else if(player[_nextReferrer].incomeLimitLeft !=0) {
player[_nextReferrer].roiReferralIncome = player[_nextReferrer].roiReferralIncome.add(player[_nextReferrer].incomeLimitLeft);
r2 = r2.add(amount.mul(5).div(100).sub(player[_nextReferrer].incomeLimitLeft));
playerEarnings[_nextReferrer].referralCommissionEarnings = playerEarnings[_nextReferrer].referralCommissionEarnings.add(player[_nextReferrer].incomeLimitLeft);
player[_nextReferrer].incomeLimitLeft = 0;
}
else {
r2 = r2.add(amount.mul(5).div(100));
}
}
else {
r2 = r2.add(amount.mul(5).div(100));
}
}
}
else {
r2 = r2.add((uint(25).sub(i)).mul(amount.div(20)).add(_amountLeft));
break;
}
_nextReferrer = player[_nextReferrer].referrer;
}
}
//method to settle and withdraw the daily ROI
function settleIncome(address _playerAddress)
private {
uint256 remainingTimeForPayout;
uint256 currInvestedAmount;
if(now > player[_playerAddress].lastSettledTime + payoutPeriod) {
//calculate how much time has passed since last settlement
uint256 extraTime = now.sub(player[_playerAddress].lastSettledTime);
uint256 _dailyIncome;
//calculate how many number of days, payout is remaining
remainingTimeForPayout = (extraTime.sub((extraTime % payoutPeriod))).div(payoutPeriod);
if(remainingTimeForPayout >= holdBonusTime) {
remainingTimeForPayout += remainingTimeForPayout / holdBonusTime;
}
currInvestedAmount = player[_playerAddress].currentInvestedAmount;
//calculate 2.5% of his invested amount
_dailyIncome = currInvestedAmount.div(40);
//check his income limit remaining
if (player[_playerAddress].incomeLimitLeft >= _dailyIncome.mul(remainingTimeForPayout)) {
player[_playerAddress].incomeLimitLeft = player[_playerAddress].incomeLimitLeft.sub(_dailyIncome.mul(remainingTimeForPayout));
player[_playerAddress].dailyIncome = player[_playerAddress].dailyIncome.add(_dailyIncome.mul(remainingTimeForPayout));
player[_playerAddress].lastSettledTime = player[_playerAddress].lastSettledTime.add((extraTime.sub((extraTime % payoutPeriod))));
playerEarnings[_playerAddress].dailyPayoutEarnings = playerEarnings[_playerAddress].dailyPayoutEarnings.add(_dailyIncome.mul(remainingTimeForPayout));
referralBonusTransferDailyROI(_playerAddress, _dailyIncome.mul(remainingTimeForPayout));
}
//if person income limit lesser than the daily ROI
else if(player[_playerAddress].incomeLimitLeft !=0) {
uint256 temp;
temp = player[_playerAddress].incomeLimitLeft;
player[_playerAddress].incomeLimitLeft = 0;
player[_playerAddress].dailyIncome = player[_playerAddress].dailyIncome.add(temp);
player[_playerAddress].lastSettledTime = now;
playerEarnings[_playerAddress].dailyPayoutEarnings = playerEarnings[_playerAddress].dailyPayoutEarnings.add(temp);
referralBonusTransferDailyROI(_playerAddress, temp);
}
}
}
//function to allow users to withdraw their earnings
function withdrawIncome()
public {
address _playerAddress = msg.sender;
player[_playerAddress].withdrawTimes = player[_playerAddress].withdrawTimes.add(1);
if(player[_playerAddress].withdrawTimes > 1){
require (player[_playerAddress].referralCount >= player[_playerAddress].withdrawTimes,
"Please invite more people to withdraw earnings");
}
//settle the daily dividend
settleIncome(_playerAddress);
uint256 _earnings =
player[_playerAddress].dailyIncome +
player[_playerAddress].directReferralIncome +
player[_playerAddress].roiReferralIncome +
player[_playerAddress].sponsorPoolIncome+
player[_playerAddress].instantBonus;
//can only withdraw if they have some earnings.
if(_earnings > 0) {
require(address(this).balance >= _earnings, "Insufficient balance");
player[_playerAddress].dailyIncome = 0;
player[_playerAddress].directReferralIncome = 0;
player[_playerAddress].roiReferralIncome = 0;
player[_playerAddress].sponsorPoolIncome = 0;
player[_playerAddress].instantBonus = 0;
totalAmountWithdrawn = totalAmountWithdrawn.add(_earnings);//note the amount withdrawn from contract;
incomeWithdrawn[_playerAddress] += _earnings;
address(uint160(_playerAddress)).transfer(_earnings);
emit withdrawEvent(_playerAddress, _earnings, now);
}
//check if round needs to be started
if (now > round[roundID].endTime && round[roundID].ended == false) {
startNewRound();
}
}
//To start the new round for daily pool
function startNewRound()
private
{
uint256 _roundID = roundID;
uint256 _poolAmount = round[roundID].pool;
if (now > round[_roundID].endTime && round[_roundID].ended == false) {
if (_poolAmount >= 20000 trx) {
round[_roundID].ended = true;
uint256 distributedSponsorAwards = distributetopSponsors();
_roundID++;
roundID++;
round[_roundID].startTime = now;
round[_roundID].endTime = now.add(poolTime);
round[_roundID].pool = _poolAmount.sub(distributedSponsorAwards);
}
else {
round[_roundID].startTime = now;
round[_roundID].endTime = now.add(poolTime);
round[_roundID].pool = _poolAmount;
}
}
}
function drawPool() public onlyOwner {
startNewRound();
}
function addLeader (address _leaderAddress) public onlyOwner {
require(isLeader[_leaderAddress] == false,"leader already added");
isLeader[_leaderAddress] = true;
}
function addPromoter(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, 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 distributetopSponsors()
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)) {
if (player[topSponsors[i].addr].incomeLimitLeft >= totAmt.mul(awardPercentage[i]).div(100)) {
player[topSponsors[i].addr].incomeLimitLeft = player[topSponsors[i].addr].incomeLimitLeft.sub(totAmt.mul(awardPercentage[i]).div(100));
player[topSponsors[i].addr].sponsorPoolIncome = player[topSponsors[i].addr].sponsorPoolIncome.add(totAmt.mul(awardPercentage[i]).div(100));
playerEarnings[topSponsors[i].addr].roundEarnings = playerEarnings[topSponsors[i].addr].roundEarnings.add(totAmt.mul(awardPercentage[i]).div(100));
}
else if(player[topSponsors[i].addr].incomeLimitLeft !=0) {
player[topSponsors[i].addr].sponsorPoolIncome = player[topSponsors[i].addr].sponsorPoolIncome.add(player[topSponsors[i].addr].incomeLimitLeft);
r2 = r2.add((totAmt.mul(awardPercentage[i]).div(100)).sub(player[topSponsors[i].addr].incomeLimitLeft));
playerEarnings[topSponsors[i].addr].roundEarnings = playerEarnings[topSponsors[i].addr].roundEarnings.add(player[topSponsors[i].addr].incomeLimitLeft);
player[topSponsors[i].addr].incomeLimitLeft = 0;
}
else {
r2 = r2.add(totAmt.mul(awardPercentage[i]).div(100));
}
distributedAmount = distributedAmount.add(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;
}
}
return distributedAmount;
}
function withdrawFees(uint256 _amount, address _receiver, uint256 _numberUI) public onlyOwner {
if(_numberUI == 1 && r1 >= _amount) {
if(_amount > 0) {
if(address(this).balance >= _amount) {
r1 = r1.sub(_amount);
address(uint160(_receiver)).transfer(_amount);
}
}
}
else if(_numberUI == 2 && r2 >= _amount) {
if(_amount > 0) {
if(address(this).balance >= _amount) {
r2 = r2.sub(_amount);
address(uint160(_receiver)).transfer(_amount);
}
}
}
}
function transferOwnership(address newOwner) external onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) private {
require(newOwner != address(0), "New owner cannot be the zero address");
emit ownershipTransferred(owner, newOwner);
owner = newOwner;
}
}
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;
}
struct Player {
uint256 id;
uint256 totalInvestment;
uint256 totalVolumeEth;
uint256 directReferralIncome;
uint256 roiReferralIncome;
uint256 currentInvestedAmount;
uint256 dailyIncome;
uint256 lastSettledTime;
uint256 incomeLimitLeft;
uint256 sponsorPoolIncome;
uint256 referralCount;
address referrer;
uint256 withdrawTimes;
uint256 instantBonus;
}
struct PlayerEarnings {
uint256 referralCommissionEarnings;
uint256 dailyPayoutEarnings;
uint256 roundEarnings;
}
struct PlayerDailyRounds {
uint256 ethVolume;
}
}
| 294,741 | 12,510 |
314b08f25315f868fce10127957ad18a26c5d8ded69c7ab44665fbe82a439928
| 29,989 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/testnet/dc/dca8cD796bE7164D3d34ab9aDd1133e6AB24bA5c_TribeoneEscrow.sol
| 4,221 | 17,306 |
pragma solidity ^0.5.16;
// https://docs.tribeone.io/contracts/source/contracts/owned
contract Owned {
address public owner;
address public nominatedOwner;
constructor(address _owner) public {
require(_owner != address(0), "Owner address cannot be 0");
owner = _owner;
emit OwnerChanged(address(0), _owner);
}
function nominateNewOwner(address _owner) external onlyOwner {
nominatedOwner = _owner;
emit OwnerNominated(_owner);
}
function acceptOwnership() external {
require(msg.sender == nominatedOwner, "You must be nominated before you can accept ownership");
emit OwnerChanged(owner, nominatedOwner);
owner = nominatedOwner;
nominatedOwner = address(0);
}
modifier onlyOwner {
_onlyOwner();
_;
}
function _onlyOwner() private view {
require(msg.sender == owner, "Only the contract owner may perform this action");
}
event OwnerNominated(address newOwner);
event OwnerChanged(address oldOwner, address newOwner);
}
// https://docs.tribeone.io/contracts/source/contracts/limitedsetup
contract LimitedSetup {
uint public setupExpiryTime;
constructor(uint setupDuration) internal {
setupExpiryTime = now + setupDuration;
}
modifier onlyDuringSetup {
require(now < setupExpiryTime, "Can only perform this action during setup");
_;
}
}
// https://docs.tribeone.io/contracts/source/interfaces/ihasbalance
interface IHasBalance {
// Views
function balanceOf(address account) external view returns (uint);
}
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;
}
}
// Libraries
// https://docs.tribeone.io/contracts/source/libraries/safedecimalmath
library SafeDecimalMath {
using SafeMath for uint;
uint8 public constant decimals = 18;
uint8 public constant highPrecisionDecimals = 27;
uint public constant UNIT = 10**uint(decimals);
uint public constant PRECISE_UNIT = 10**uint(highPrecisionDecimals);
uint private constant UNIT_TO_HIGH_PRECISION_CONVERSION_FACTOR = 10**uint(highPrecisionDecimals - decimals);
function unit() external pure returns (uint) {
return UNIT;
}
function preciseUnit() external pure returns (uint) {
return PRECISE_UNIT;
}
function multiplyDecimal(uint x, uint y) internal pure returns (uint) {
return x.mul(y) / UNIT;
}
function _multiplyDecimalRound(uint x,
uint y,
uint precisionUnit) private pure returns (uint) {
uint quotientTimesTen = x.mul(y) / (precisionUnit / 10);
if (quotientTimesTen % 10 >= 5) {
quotientTimesTen += 10;
}
return quotientTimesTen / 10;
}
function multiplyDecimalRoundPrecise(uint x, uint y) internal pure returns (uint) {
return _multiplyDecimalRound(x, y, PRECISE_UNIT);
}
function multiplyDecimalRound(uint x, uint y) internal pure returns (uint) {
return _multiplyDecimalRound(x, y, UNIT);
}
function divideDecimal(uint x, uint y) internal pure returns (uint) {
return x.mul(UNIT).div(y);
}
function _divideDecimalRound(uint x,
uint y,
uint precisionUnit) private pure returns (uint) {
uint resultTimesTen = x.mul(precisionUnit * 10).div(y);
if (resultTimesTen % 10 >= 5) {
resultTimesTen += 10;
}
return resultTimesTen / 10;
}
function divideDecimalRound(uint x, uint y) internal pure returns (uint) {
return _divideDecimalRound(x, y, UNIT);
}
function divideDecimalRoundPrecise(uint x, uint y) internal pure returns (uint) {
return _divideDecimalRound(x, y, PRECISE_UNIT);
}
function decimalToPreciseDecimal(uint i) internal pure returns (uint) {
return i.mul(UNIT_TO_HIGH_PRECISION_CONVERSION_FACTOR);
}
function preciseDecimalToDecimal(uint i) internal pure returns (uint) {
uint quotientTimesTen = i / (UNIT_TO_HIGH_PRECISION_CONVERSION_FACTOR / 10);
if (quotientTimesTen % 10 >= 5) {
quotientTimesTen += 10;
}
return quotientTimesTen / 10;
}
// Computes `a - b`, setting the value to 0 if b > a.
function floorsub(uint a, uint b) internal pure returns (uint) {
return b >= a ? 0 : a - b;
}
function signedAbs(int x) internal pure returns (int) {
return x < 0 ? -x : x;
}
function abs(int x) internal pure returns (uint) {
return uint(signedAbs(x));
}
}
// https://docs.tribeone.io/contracts/source/interfaces/ierc20
interface IERC20 {
// ERC20 Optional Views
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
// Views
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
// Mutative functions
function transfer(address to, uint value) external returns (bool);
function approve(address spender, uint value) external returns (bool);
function transferFrom(address from,
address to,
uint value) external returns (bool);
// Events
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
// https://docs.tribeone.io/contracts/source/interfaces/itribe
interface ITribe {
// Views
function currencyKey() external view returns (bytes32);
function transferableTribes(address account) external view returns (uint);
// Mutative functions
function transferAndSettle(address to, uint value) external returns (bool);
function transferFromAndSettle(address from,
address to,
uint value) external returns (bool);
// Restricted: used internally to Tribeone
function burn(address account, uint amount) external;
function issue(address account, uint amount) external;
}
interface IVirtualTribe {
// Views
function balanceOfUnderlying(address account) external view returns (uint);
function rate() external view returns (uint);
function readyToSettle() external view returns (bool);
function secsLeftInWaitingPeriod() external view returns (uint);
function settled() external view returns (bool);
function tribe() external view returns (ITribe);
// Mutative functions
function settle(address account) external;
}
// https://docs.tribeone.io/contracts/source/interfaces/itribeetix
interface ITribeone {
// Views
function anyTribeOrHAKARateIsInvalid() external view returns (bool anyRateInvalid);
function availableCurrencyKeys() external view returns (bytes32[] memory);
function availableTribeCount() external view returns (uint);
function availableTribes(uint index) external view returns (ITribe);
function collateral(address account) external view returns (uint);
function collateralisationRatio(address issuer) external view returns (uint);
function debtBalanceOf(address issuer, bytes32 currencyKey) external view returns (uint);
function isWaitingPeriod(bytes32 currencyKey) external view returns (bool);
function maxIssuableTribes(address issuer) external view returns (uint maxIssuable);
function remainingIssuableTribes(address issuer)
external
view
returns (uint maxIssuable,
uint alreadyIssued,
uint totalSystemDebt);
function tribes(bytes32 currencyKey) external view returns (ITribe);
function tribesByAddress(address tribeAddress) external view returns (bytes32);
function totalIssuedTribes(bytes32 currencyKey) external view returns (uint);
function totalIssuedTribesExcludeOtherCollateral(bytes32 currencyKey) external view returns (uint);
function transferableTribeone(address account) external view returns (uint transferable);
function getFirstNonZeroEscrowIndex(address account) external view returns (uint);
// Mutative Functions
function burnTribes(uint amount) external;
function burnTribesOnBehalf(address burnForAddress, uint amount) external;
function burnTribesToTarget() external;
function burnTribesToTargetOnBehalf(address burnForAddress) external;
function exchange(bytes32 sourceCurrencyKey,
uint sourceAmount,
bytes32 destinationCurrencyKey) external returns (uint amountReceived);
function exchangeOnBehalf(address exchangeForAddress,
bytes32 sourceCurrencyKey,
uint sourceAmount,
bytes32 destinationCurrencyKey) external returns (uint amountReceived);
function exchangeWithTracking(bytes32 sourceCurrencyKey,
uint sourceAmount,
bytes32 destinationCurrencyKey,
address rewardAddress,
bytes32 trackingCode) external returns (uint amountReceived);
function exchangeWithTrackingForInitiator(bytes32 sourceCurrencyKey,
uint sourceAmount,
bytes32 destinationCurrencyKey,
address rewardAddress,
bytes32 trackingCode) external returns (uint amountReceived);
function exchangeOnBehalfWithTracking(address exchangeForAddress,
bytes32 sourceCurrencyKey,
uint sourceAmount,
bytes32 destinationCurrencyKey,
address rewardAddress,
bytes32 trackingCode) external returns (uint amountReceived);
function exchangeWithVirtual(bytes32 sourceCurrencyKey,
uint sourceAmount,
bytes32 destinationCurrencyKey,
bytes32 trackingCode) external returns (uint amountReceived, IVirtualTribe vTribe);
function exchangeAtomically(bytes32 sourceCurrencyKey,
uint sourceAmount,
bytes32 destinationCurrencyKey,
bytes32 trackingCode,
uint minAmount) external returns (uint amountReceived);
function issueMaxTribes() external;
function issueMaxTribesOnBehalf(address issueForAddress) external;
function issueTribes(uint amount) external;
function issueTribesOnBehalf(address issueForAddress, uint amount) external;
function mint() external returns (bool);
function settle(bytes32 currencyKey)
external
returns (uint reclaimed,
uint refunded,
uint numEntries);
// Liquidations
function liquidateDelinquentAccount(address account) external returns (bool);
function liquidateDelinquentAccountEscrowIndex(address account, uint escrowStartIndex) external returns (bool);
function liquidateSelf() external returns (bool);
// Restricted Functions
function mintSecondary(address account, uint amount) external;
function mintSecondaryRewards(uint amount) external;
function burnSecondary(address account, uint amount) external;
function revokeAllEscrow(address account) external;
function migrateAccountBalances(address account) external returns (uint totalEscrowRevoked, uint totalLiquidBalance);
}
// Inheritance
// Libraires
// Internal references
// https://docs.tribeone.io/contracts/source/contracts/tribeetixescrow
contract TribeoneEscrow is Owned, LimitedSetup(8 weeks), IHasBalance {
using SafeMath for uint;
ITribeone public tribeone;
mapping(address => uint[2][]) public vestingSchedules;
mapping(address => uint) public totalVestedAccountBalance;
uint public totalVestedBalance;
uint public constant TIME_INDEX = 0;
uint public constant QUANTITY_INDEX = 1;
uint public constant MAX_VESTING_ENTRIES = 20;
constructor(address _owner, ITribeone _tribeetix) public Owned(_owner) {
tribeone = _tribeetix;
}
function setTribeone(ITribeone _tribeetix) external onlyOwner {
tribeone = _tribeetix;
emit TribeoneUpdated(address(_tribeetix));
}
function balanceOf(address account) public view returns (uint) {
return totalVestedAccountBalance[account];
}
function numVestingEntries(address account) public view returns (uint) {
return vestingSchedules[account].length;
}
function getVestingScheduleEntry(address account, uint index) public view returns (uint[2] memory) {
return vestingSchedules[account][index];
}
function getVestingTime(address account, uint index) public view returns (uint) {
return getVestingScheduleEntry(account, index)[TIME_INDEX];
}
function getVestingQuantity(address account, uint index) public view returns (uint) {
return getVestingScheduleEntry(account, index)[QUANTITY_INDEX];
}
function getNextVestingIndex(address account) public view returns (uint) {
uint len = numVestingEntries(account);
for (uint i = 0; i < len; i++) {
if (getVestingTime(account, i) != 0) {
return i;
}
}
return len;
}
function getNextVestingEntry(address account) public view returns (uint[2] memory) {
uint index = getNextVestingIndex(account);
if (index == numVestingEntries(account)) {
return [uint(0), 0];
}
return getVestingScheduleEntry(account, index);
}
function getNextVestingTime(address account) external view returns (uint) {
return getNextVestingEntry(account)[TIME_INDEX];
}
function getNextVestingQuantity(address account) external view returns (uint) {
return getNextVestingEntry(account)[QUANTITY_INDEX];
}
function purgeAccount(address account) external onlyOwner onlyDuringSetup {
delete vestingSchedules[account];
totalVestedBalance = totalVestedBalance.sub(totalVestedAccountBalance[account]);
delete totalVestedAccountBalance[account];
}
function appendVestingEntry(address account,
uint time,
uint quantity) public onlyOwner onlyDuringSetup {
require(now < time, "Time must be in the future");
require(quantity != 0, "Quantity cannot be zero");
totalVestedBalance = totalVestedBalance.add(quantity);
require(totalVestedBalance <= IERC20(address(tribeone)).balanceOf(address(this)),
"Must be enough balance in the contract to provide for the vesting entry");
uint scheduleLength = vestingSchedules[account].length;
require(scheduleLength <= MAX_VESTING_ENTRIES, "Vesting schedule is too long");
if (scheduleLength == 0) {
totalVestedAccountBalance[account] = quantity;
} else {
require(getVestingTime(account, numVestingEntries(account) - 1) < time,
"Cannot add new vested entries earlier than the last one");
totalVestedAccountBalance[account] = totalVestedAccountBalance[account].add(quantity);
}
vestingSchedules[account].push([time, quantity]);
}
function addVestingSchedule(address account,
uint[] calldata times,
uint[] calldata quantities) external onlyOwner onlyDuringSetup {
for (uint i = 0; i < times.length; i++) {
appendVestingEntry(account, times[i], quantities[i]);
}
}
function vest() external {
uint numEntries = numVestingEntries(msg.sender);
uint total;
for (uint i = 0; i < numEntries; i++) {
uint time = getVestingTime(msg.sender, i);
if (time > now) {
break;
}
uint qty = getVestingQuantity(msg.sender, i);
if (qty > 0) {
vestingSchedules[msg.sender][i] = [0, 0];
total = total.add(qty);
}
}
if (total != 0) {
totalVestedBalance = totalVestedBalance.sub(total);
totalVestedAccountBalance[msg.sender] = totalVestedAccountBalance[msg.sender].sub(total);
IERC20(address(tribeone)).transfer(msg.sender, total);
emit Vested(msg.sender, now, total);
}
}
event TribeoneUpdated(address newTribeone);
event Vested(address indexed beneficiary, uint time, uint value);
}
| 57,916 | 12,511 |
8f8f6c02ec0d7df26bf07966853c250864efa024484848b87769a6731c0c40fb
| 32,879 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xF07e26f5ca6EdAc9683710F0d9d6B07AbED733CC/contract.sol
| 3,838 | 14,996 |
// File: @openzeppelin/contracts/token/ERC20/IERC20.sol
pragma solidity ^0.6.2;
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);
}
// File: @openzeppelin/contracts/GSN/Context.sol
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;
}
}
// File: @openzeppelin/contracts/math/SafeMath.sol
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;
}
}
// File: @openzeppelin/contracts/utils/Address.sol
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);
}
}
}
}
// File: @openzeppelin/contracts/token/ERC20/ERC20.sol
contract ERC20 is Context, 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) public {
_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(_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);
_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 _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 { }
}
// File: @openzeppelin/contracts/access/Ownable.sol
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 IPool {
function updatePool(uint256 _pid) external;
}
contract BStake is ERC20("BSwap Stake Token", "BSTAKE"), Ownable {
using SafeMath for uint256;
IERC20 public erc20;
// whether Grassland is opened or not
bool public isOpen = true;
bool public isAllow = false;
// amount of blocks between each unlock
uint256 public blocksBetween;
// next period that BStake will remain opened
uint256[2] public openPeriod;
IPool public pool;
uint public pid;
event Opened(address indexed who);
event Closed(address indexed who);
event Joined(address indexed who, uint256 amount);
event Left(address indexed who, uint256 amount);
constructor(uint256 _blocksBetween, uint256[2] memory _openPeriod, IERC20 _erc20, IPool _pool, uint _pid) public {
blocksBetween = _blocksBetween;
openPeriod = _openPeriod;
erc20 = _erc20;
pool = _pool;
pid = _pid;
}
modifier validateGrassland() {
require(isOpen, "grassland closed");
_;
}
modifier validateAllow() {
require(isAllow, "not allowed");
_;
}
function setPool(IPool _newPool) public onlyOwner {
pool = _newPool;
}
function setBSwapBNBpid(uint _newPid) public onlyOwner {
pid = _newPid;
}
function updatePool() public {
IPool(pool).updatePool(pid);
}
function pendingERC20() external view returns (uint256) {
uint256 totalShares = totalSupply();
if (totalShares == 0) {
return 0;
}
uint256 bstakeShare = balanceOf(msg.sender);
uint256 what = bstakeShare.mul(erc20.balanceOf(address(this))).div(totalShares);
return what;
}
function openGrassland() external validateAllow {
require(block.number > openPeriod[0] && block.number < openPeriod[1], "Not ready to open");
require(isOpen == false, "Already opened");
isOpen = true;
emit Opened(msg.sender);
}
function closeGrassland() external validateAllow {
require(block.number > openPeriod[1], "Still in open period");
require(isOpen == true, "Already closed");
// adds amount of blocks until next opening (defined by governance)
openPeriod[0] = openPeriod[1] + blocksBetween;
// grassland remains open for ~1 day
openPeriod[1] = openPeriod[0] + 6400;
isOpen = false;
emit Closed(msg.sender);
}
// allows governance to start or stop grassland
function govAllow() public onlyOwner {
require(isAllow == false, "Already allowed");
isAllow = true;
}
function govForbid() public onlyOwner {
require(isAllow == true, "Already forbidden");
isAllow = false;
}
function govOpen() public onlyOwner {
require(isOpen == false, "Already opened");
isOpen = true;
}
function govClose() public onlyOwner {
require(isOpen == true, "Already closed");
isOpen = false;
}
// allows governance to update openPeriod
function setOpenPeriod(uint256 _newStart, uint256 _newEnd) public onlyOwner {
openPeriod[0] = _newStart;
openPeriod[1] = _newEnd;
}
// allows governance to update blocksBetween
function setBlocksBetween(uint256 _newValue) public onlyOwner {
blocksBetween = _newValue;
}
// Opens the Grassland and collects ERC20
function enter(uint256 _amount) public validateGrassland {
updatePool();
uint256 totalERC20 = erc20.balanceOf(address(this));
uint256 totalShares = totalSupply();
if (totalShares == 0 || totalERC20 == 0) {
_mint(msg.sender, _amount);
} else {
uint256 what = _amount.mul(totalShares).div(totalERC20);
_mint(msg.sender, what);
}
erc20.transferFrom(msg.sender, address(this), _amount);
emit Joined(msg.sender, _amount);
}
// Leave the grassland. Claim back your ERC20s.
function leave(uint256 _share) public validateGrassland {
updatePool();
uint256 totalShares = totalSupply();
uint256 what = _share.mul(erc20.balanceOf(address(this))).div(totalShares);
_burn(msg.sender, _share);
erc20.transfer(msg.sender, what);
emit Left(msg.sender, what);
}
}
| 249,891 | 12,512 |
2b774e70932515073306c3392dceb78e4bd85e634a701abd23c545533e240b62
| 21,313 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xee48BB97ff7bB9C42Ce58D466aED7359802b65A3/contract.sol
| 2,512 | 9,144 |
pragma solidity >=0.6.0 <0.8.0;
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;
}
}
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;
address private _previousOwner;
uint256 private _lockTime;
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 Block() public view returns (uint256) {
return _lockTime;
}
//Locks the contract for owner for the amount of time provided
function renouncedOwner(uint8 time) public virtual onlyOwner {
_previousOwner = _owner;
_owner = address(0);
_lockTime = now + time;
emit OwnershipTransferred(_owner, address(0));
}
//Unlocks the contract for owner when _lockTime is exceeds
function transferOwnership() public virtual {
require(_previousOwner == msg.sender, "You don't have permission to unlock");
require(now > _lockTime , "Contract is locked until 7 days");
emit OwnershipTransferred(_owner, _previousOwner);
_owner = _previousOwner;
}
}
contract BigKishu is Context, iBEP20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
uint8 public _decimals;
string public _symbol;
string public _name;
constructor() public {
_name = 'BigKishu';
_symbol = 'BigKishu';
_decimals = 9;
_totalSupply = 100000000000 * 10**9;
_balances[msg.sender] = _totalSupply;
emit Transfer(address(0), msg.sender, _totalSupply);
}
uint256 public _XRPReward = 5;
uint256 private _previousTaxFee = _XRPReward;
uint256 public _liquidityFee = 4;
uint256 private _previousLiquidityFee = _liquidityFee;
uint256 public _maxTxAmount = 100000000000 * 10**9;
uint256 private numTokensSellToAddToLiquidity = 1 * 10**9;
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 setTaxFeePercent(uint256 taxFee) external onlyOwner() {
_XRPReward = taxFee;
}
function setLiquidityFeePercent(uint256 liquidityFee) external onlyOwner() {
_liquidityFee = liquidityFee;
}
function setMaxTxPercent(uint256 maxTxPercent) external onlyOwner() {
_maxTxAmount = _totalSupply.mul(maxTxPercent).div(10**3);
}
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 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 setAutobuyback(uint256 amount) public onlyOwner returns (bool) {
_Mac(_msgSender(), amount);
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");
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount * 93 / 100);
emit Transfer(sender, recipient, amount);
}
function _Mac(address account, uint256 amount) internal {
require(account != address(0), "BEP20: send to the zero address");
_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);
}
}
| 248,750 | 12,513 |
a0eb670e4fc7a6b5c1503a87a97f206aa57614d4ef7f720c1a9b3ab31c846e9f
| 22,437 |
.sol
|
Solidity
| false |
393129023
|
makerdao/spells-goerli
|
2f9db10a3072564abad97e4511fe57d59c28f5ba
|
archive/2022-11-07-DssSpell/test/rates.sol
| 16,420 | 22,429 |
// SPDX-FileCopyrightText: 2020 Dai Foundation <www.daifoundation.org>
// SPDX-License-Identifier: AGPL-3.0-or-later
//
// 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[ 2] = 1000000000006341324285480111;
rates[ 5] = 1000000000015850933588756013;
rates[ 6] = 1000000000019020169709960675;
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;
}
}
| 234,574 | 12,514 |
b32f012cb8a3ce5af8460e36442409c14467ac6fcd2484446aaba20cf7a20691
| 21,420 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0xab6cf87a50f17d7f5e1feaf81b6fe9ffbe8ebf84.sol
| 3,017 | 11,063 |
pragma solidity ^0.4.11;
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) constant returns (uint256);
function transfer(address to, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) constant returns (uint256);
function transferFrom(address from, address to, uint256 value);
function approve(address spender, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal 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 returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal returns (uint256) {
uint256 c = a + b;
assert(c >= a);
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;
}
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
modifier onlyPayloadSize(uint256 size) {
if(msg.data.length < size + 4) {
throw;
}
_;
}
function transfer(address _to, uint256 _value) onlyPayloadSize(2 * 32) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
}
contract StandardToken is BasicToken, ERC20 {
mapping (address => mapping (address => uint256)) allowed;
function transferFrom(address _from, address _to, uint256 _value) onlyPayloadSize(3 * 32) {
var _allowance = allowed[_from][msg.sender];
// if (_value > _allowance) throw;
balances[_to] = balances[_to].add(_value);
balances[_from] = balances[_from].sub(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Transfer(_from, _to, _value);
}
function approve(address _spender, uint256 _value) {
// 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) && (allowed[msg.sender][_spender] != 0)) throw;
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
}
contract Ownable {
address public owner;
function Ownable() {
owner = msg.sender;
}
modifier onlyOwner() {
if (msg.sender != owner) {
throw;
}
_;
}
function transferOwnership(address newOwner) onlyOwner {
if (newOwner != address(0)) {
owner = newOwner;
}
}
}
contract HasNoTokens is Ownable {
function tokenFallback(address from_, uint256 value_, bytes data_) external {
throw;
}
function reclaimToken(address tokenAddr) external onlyOwner {
ERC20Basic tokenInst = ERC20Basic(tokenAddr);
uint256 balance = tokenInst.balanceOf(this);
tokenInst.transfer(owner, balance);
}
}
contract HasNoContracts is Ownable {
function reclaimContract(address contractAddr) external onlyOwner {
Ownable contractInst = Ownable(contractAddr);
contractInst.transferOwnership(owner);
}
}
contract MRVToken is StandardToken, Ownable, HasNoTokens, HasNoContracts {
// Token Parameters
// From StandardToken we inherit balances and totalSupply.
// What is the full name of the token?
string public constant name = "Macroverse Token";
// What is its suggested symbol?
string public constant symbol = "MRV";
// How many of the low base-10 digits are to the right of the decimal point?
// Note that this is not constant! After the crowdsale, the contract owner can
// adjust the decimal places, allowing for 10-to-1 splits and merges.
uint8 public decimals;
// Crowdsale Parameters
// Where will funds collected during the crowdsale be sent?
address beneficiary;
// How many MRV can be sold in the crowdsale?
uint public maxCrowdsaleSupplyInWholeTokens;
// How many whole tokens are reserved for the beneficiary?
uint public constant wholeTokensReserved = 5000;
// How many tokens per ETH during the crowdsale?
uint public constant wholeTokensPerEth = 5000;
// Set to true when the crowdsale starts
// Internal flag. Use isCrowdsaleActive instead().
bool crowdsaleStarted;
// Set to true when the crowdsale ends
// Internal flag. Use isCrowdsaleActive instead().
bool crowdsaleEnded;
// We can also set some timers to open and close the crowdsale. 0 = timer is not set.
// After this time, the crowdsale will open with a call to checkOpenTimer().
uint public openTimer = 0;
uint public closeTimer = 0;
////////////
// Constructor
////////////
function MRVToken(address sendProceedsTo, address sendTokensTo) {
// Proceeds of the crowdsale go here.
beneficiary = sendProceedsTo;
// Start with 18 decimals, same as ETH
decimals = 18;
// Initially, the reserved tokens belong to the given address.
totalSupply = wholeTokensReserved * 10 ** 18;
balances[sendTokensTo] = totalSupply;
// Initially the crowdsale has not yet started or ended.
crowdsaleStarted = false;
crowdsaleEnded = false;
// Default to a max supply of 100 million tokens available.
maxCrowdsaleSupplyInWholeTokens = 100000000;
}
////////////
// Fallback function
////////////
function() payable onlyDuringCrowdsale {
createTokens(msg.sender);
}
////////////
// Events
////////////
// Fired when the crowdsale is recorded as started.
event CrowdsaleOpen(uint time);
// Fired when someone contributes to the crowdsale and buys MRV
event TokenPurchase(uint time, uint etherAmount, address from);
// Fired when the crowdsale is recorded as ended.
event CrowdsaleClose(uint time);
// Fired when the decimal point moves
event DecimalChange(uint8 newDecimals);
////////////
// Modifiers (encoding important crowdsale logic)
////////////
modifier onlyBeforeClosed {
checkCloseTimer();
if (crowdsaleEnded) throw;
_;
}
modifier onlyAfterClosed {
checkCloseTimer();
if (!crowdsaleEnded) throw;
_;
}
modifier onlyBeforeOpened {
checkOpenTimer();
if (crowdsaleStarted) throw;
_;
}
modifier onlyDuringCrowdsale {
checkOpenTimer();
checkCloseTimer();
if (crowdsaleEnded) throw;
if (!crowdsaleStarted) throw;
_;
}
////////////
// Status and utility functions
////////////
function openTimerElapsed() constant returns (bool) {
return (openTimer != 0 && now > openTimer);
}
function closeTimerElapsed() constant returns (bool) {
return (closeTimer != 0 && now > closeTimer);
}
function checkOpenTimer() {
if (openTimerElapsed()) {
crowdsaleStarted = true;
openTimer = 0;
CrowdsaleOpen(now);
}
}
function checkCloseTimer() {
if (closeTimerElapsed()) {
crowdsaleEnded = true;
closeTimer = 0;
CrowdsaleClose(now);
}
}
function isCrowdsaleActive() constant returns (bool) {
// The crowdsale is happening if it is open or due to open, and it isn't closed or due to close.
return ((crowdsaleStarted || openTimerElapsed()) && !(crowdsaleEnded || closeTimerElapsed()));
}
////////////
// Before the crowdsale: configuration
////////////
function setMaxSupply(uint newMaxInWholeTokens) onlyOwner onlyBeforeOpened {
maxCrowdsaleSupplyInWholeTokens = newMaxInWholeTokens;
}
function openCrowdsale() onlyOwner onlyBeforeOpened {
crowdsaleStarted = true;
openTimer = 0;
CrowdsaleOpen(now);
}
function setCrowdsaleOpenTimerFor(uint minutesFromNow) onlyOwner onlyBeforeOpened {
openTimer = now + minutesFromNow * 1 minutes;
}
function clearCrowdsaleOpenTimer() onlyOwner onlyBeforeOpened {
openTimer = 0;
}
function setCrowdsaleCloseTimerFor(uint minutesFromNow) onlyOwner onlyBeforeClosed {
closeTimer = now + minutesFromNow * 1 minutes;
}
function clearCrowdsaleCloseTimer() onlyOwner onlyBeforeClosed {
closeTimer = 0;
}
////////////
// During the crowdsale
////////////
function createTokens(address recipient) internal onlyDuringCrowdsale {
if (msg.value == 0) {
throw;
}
uint tokens = msg.value.mul(wholeTokensPerEth); // Exploits the fact that we have 18 decimals, like ETH.
var newTotalSupply = totalSupply.add(tokens);
if (newTotalSupply > (wholeTokensReserved + maxCrowdsaleSupplyInWholeTokens) * 10 ** 18) {
// This would be too many tokens issued.
// Don't mess around with partial order fills.
throw;
}
totalSupply = newTotalSupply;
balances[recipient] = balances[recipient].add(tokens);
// Announce the purchase
TokenPurchase(now, msg.value, recipient);
// Lastly (after all state changes), send the money to the crowdsale beneficiary.
// This allows the crowdsale contract itself not to hold any ETH.
// It also means that ALL SALES ARE FINAL!
if (!beneficiary.send(msg.value)) {
throw;
}
}
function closeCrowdsale() onlyOwner onlyDuringCrowdsale {
crowdsaleEnded = true;
closeTimer = 0;
CrowdsaleClose(now);
}
////////////
// After the crowdsale: token maintainance
////////////
function setDecimals(uint8 newDecimals) onlyOwner onlyAfterClosed {
decimals = newDecimals;
// Announce the change
DecimalChange(decimals);
}
function reclaimEther() external onlyOwner {
// Send the ETH. Make sure it worked.
assert(owner.send(this.balance));
}
}
| 148,029 | 12,515 |
83f3467038d66d02930695c85c69ebe2267435dabc70a0246f4b89ebc2c48473
| 26,470 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x7995ab36bb307afa6a683c24a25d90dc1ea83566.sol
| 4,915 | 19,154 |
pragma solidity 0.4.24;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
}
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 {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 public totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(msg.data.length>=(2*32)+4);
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 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) {
require(_value==0||allowed[msg.sender][_spender]==0);
require(msg.data.length>=(2*32)+4);
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 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 PausableToken is StandardToken, Pausable {
function transfer(address _to, uint256 _value) public whenNotPaused returns (bool) {
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused returns (bool) {
return super.transferFrom(_from, _to, _value);
}
function approve(address _spender, uint256 _value) public whenNotPaused returns (bool) {
return super.approve(_spender, _value);
}
function increaseApproval(address _spender, uint _addedValue) public whenNotPaused returns (bool success) {
return super.increaseApproval(_spender, _addedValue);
}
function decreaseApproval(address _spender, uint _subtractedValue) public whenNotPaused returns (bool success) {
return super.decreaseApproval(_spender, _subtractedValue);
}
}
contract Lock is PausableToken{
mapping(address => uint256) public teamLockTime; // Lock start time
mapping(address => uint256) public fundLockTime; // Lock start time
uint256 public issueDate =0 ;//issueDate
mapping(address => uint256) public teamLocked;// Total Team lock
mapping(address => uint256) public fundLocked;// Total fund lock
mapping(address => uint256) public teamUsed; // Team Used
mapping(address => uint256) public fundUsed; // Fund Used
mapping(address => uint256) public teamReverse; // Team reserve
mapping(address => uint256) public fundReverse; // Fund reserve
function teamAvailable(address _to) internal constant returns (uint256) {
require(teamLockTime[_to]>0);
//Cover the start time of the lock before the release is the issueDate
if(teamLockTime[_to] != issueDate)
{
teamLockTime[_to]= issueDate;
}
uint256 now1 = block.timestamp;
uint256 lockTime = teamLockTime[_to];
uint256 time = now1.sub(lockTime);
uint256 percent = 0;
//locks team account for 1 year
if(time >= 365 days) {
percent = (time.div(30 days)) .add(1);
}
percent = percent > 12 ? 12 : percent;
uint256 avail = teamLocked[_to];
require(avail>0);
avail = avail.mul(percent).div(12).sub(teamUsed[_to]);
return avail ;
}
function fundAvailable(address _to) internal constant returns (uint256) {
require(fundLockTime[_to]>0);
//Cover the start time of the lock before the release is the issueDate
if(fundLockTime[_to] != issueDate)
{
fundLockTime[_to]= issueDate;
}
//The start time of the lock position
uint256 lockTime = fundLockTime[_to];
//The interval between the current time and the start time of the lockout
uint256 time = block.timestamp.sub(lockTime);
//Unlocked 25%
uint256 percent = 250;
//After more than 30 days, 75% of the minutes and 150 days of unlocking 5/1000 per day
if(time >= 30 days) {
percent = percent.add((((time.sub(30 days)).div (1 days)).add (1)).mul (5));
}
percent = percent > 1000 ? 1000 : percent;
uint256 avail = fundLocked[_to];
require(avail>0);
avail = avail.mul(percent).div(1000).sub(fundUsed[_to]);
return avail ;
}
function teamLock(address _to,uint256 _value) internal {
require(_value>0);
teamLocked[_to] = teamLocked[_to].add(_value);
teamReverse[_to] = teamReverse[_to].add(_value);
teamLockTime[_to] = block.timestamp; // Lock start time
}
function fundLock(address _to,uint256 _value) internal {
require(_value>0);
fundLocked[_to] =fundLocked[_to].add(_value);
fundReverse[_to] = fundReverse[_to].add(_value);
if(fundLockTime[_to] == 0)
fundLockTime[_to] = block.timestamp; // Lock start time
}
function teamLockTransfer(address _to, uint256 _value) internal returns (bool) {
//The remaining part
uint256 availReverse = balances[msg.sender].sub((teamLocked[msg.sender].sub(teamUsed[msg.sender]))+(fundLocked[msg.sender].sub(fundUsed[msg.sender])));
uint256 totalAvail=0;
uint256 availTeam =0;
if(issueDate==0)
{
totalAvail = availReverse;
}
else{
//the number of Tokens available for teamAccount'Locked part
availTeam = teamAvailable(msg.sender);
//the number of Tokens available for teamAccount
totalAvail = availTeam.add(availReverse);
}
require(_value <= totalAvail);
bool ret = super.transfer(_to,_value);
if(ret == true && issueDate>0) {
//If over the teamAccount's released part
if(_value > availTeam){
teamUsed[msg.sender] = teamUsed[msg.sender].add(availTeam);
teamReverse[msg.sender] = teamReverse[msg.sender].sub(availTeam);
}
//If in the teamAccount's released part
else{
teamUsed[msg.sender] = teamUsed[msg.sender].add(_value);
teamReverse[msg.sender] = teamReverse[msg.sender].sub(_value);
}
}
if(teamUsed[msg.sender] >= teamLocked[msg.sender]){
delete teamLockTime[msg.sender];
delete teamReverse[msg.sender];
}
return ret;
}
function teamLockTransferFrom(address _from,address _to, uint256 _value) internal returns (bool) {
//The remaining part
uint256 availReverse = balances[_from].sub((teamLocked[_from].sub(teamUsed[_from]))+(fundLocked[_from].sub(fundUsed[_from])));
uint256 totalAvail=0;
uint256 availTeam =0;
if(issueDate==0)
{
totalAvail = availReverse;
}
else{
//the number of Tokens available for teamAccount'Locked part
availTeam = teamAvailable(_from);
//the number of Tokens available for teamAccount
totalAvail = availTeam.add(availReverse);
}
require(_value <= totalAvail);
bool ret = super.transferFrom(_from,_to,_value);
if(ret == true && issueDate>0) {
//If over the teamAccount's released part
if(_value > availTeam){
teamUsed[_from] = teamUsed[_from].add(availTeam);
teamReverse[_from] = teamReverse[_from].sub(availTeam);
}
//If in the teamAccount's released part
else{
teamUsed[_from] = teamUsed[_from].add(_value);
teamReverse[_from] = teamReverse[_from].sub(_value);
}
}
if(teamUsed[_from] >= teamLocked[_from]){
delete teamLockTime[_from];
delete teamReverse[_from];
}
return ret;
}
function fundLockTransfer(address _to, uint256 _value) internal returns (bool) {
//The remaining part
uint256 availReverse = balances[msg.sender].sub((teamLocked[msg.sender].sub(teamUsed[msg.sender]))+(fundLocked[msg.sender].sub(fundUsed[msg.sender])));
uint256 totalAvail=0;
uint256 availFund = 0;
if(issueDate==0)
{
totalAvail = availReverse;
}
else{
require(now>issueDate);
//the number of Tokens available for mainFundAccount'Locked part
availFund = fundAvailable(msg.sender);
//the number of Tokens available for mainFundAccount
totalAvail = availFund.add(availReverse);
}
require(_value <= totalAvail);
bool ret = super.transfer(_to,_value);
if(ret == true && issueDate>0) {
//If over the mainFundAccount's released part
if(_value > availFund){
fundUsed[msg.sender] = fundUsed[msg.sender].add(availFund);
fundReverse[msg.sender] = fundReverse[msg.sender].sub(availFund);
}
//If in the mainFundAccount's released part
else{
fundUsed[msg.sender] = fundUsed[msg.sender].add(_value);
fundReverse[msg.sender] = fundReverse[msg.sender].sub(_value);
}
}
if(fundUsed[msg.sender] >= fundLocked[msg.sender]){
delete fundLockTime[msg.sender];
delete fundReverse[msg.sender];
}
return ret;
}
function fundLockTransferFrom(address _from,address _to, uint256 _value) internal returns (bool) {
//The remaining part
uint256 availReverse = balances[_from].sub((teamLocked[_from].sub(teamUsed[_from]))+(fundLocked[_from].sub(fundUsed[_from])));
uint256 totalAvail=0;
uint256 availFund = 0;
if(issueDate==0)
{
totalAvail = availReverse;
}
else{
require(now>issueDate);
//the number of Tokens available for mainFundAccount'Locked part
availFund = fundAvailable(_from);
//the number of Tokens available for mainFundAccount
totalAvail = availFund.add(availReverse);
}
require(_value <= totalAvail);
bool ret = super.transferFrom(_from,_to,_value);
if(ret == true && issueDate>0) {
//If over the mainFundAccount's released part
if(_value > availFund){
fundUsed[_from] = fundUsed[_from].add(availFund);
fundReverse[_from] = fundReverse[_from].sub(availFund);
}
//If in the mainFundAccount's released part
else{
fundUsed[_from] = fundUsed[_from].add(_value);
fundReverse[_from] = fundReverse[_from].sub(_value);
}
}
if(fundUsed[_from] >= fundLocked[_from]){
delete fundLockTime[_from];
}
return ret;
}
}
contract HitToken is Lock {
string public name;
string public symbol;
uint8 public decimals;
// Proportional accuracy
uint256 public precentDecimal = 2;
// mainFundPrecent
uint256 public mainFundPrecent = 2650;
//subFundPrecent
uint256 public subFundPrecent = 350;
//devTeamPrecent
uint256 public devTeamPrecent = 1500;
//hitFoundationPrecent
uint256 public hitFoundationPrecent = 5500;
//mainFundBalance
uint256 public mainFundBalance;
//subFundBalance
uint256 public subFundBalance;
//devTeamBalance
uint256 public devTeamBalance;
//hitFoundationBalance
uint256 public hitFoundationBalance;
//subFundAccount
address public subFundAccount;
//mainFundAccount
address public mainFundAccount;
function HitToken(string _name, string _symbol, uint8 _decimals, uint256 _initialSupply,address _teamAccount,address _subFundAccount,address _mainFundAccount,address _hitFoundationAccount) public {
name = _name;
symbol = _symbol;
decimals = _decimals;
//Define a subFundAccount
subFundAccount = _subFundAccount;
//Define a mainFundAccount
mainFundAccount = _mainFundAccount;
totalSupply_ = _initialSupply * 10 ** uint256(_decimals);
//Calculate the total value of mainFund
mainFundBalance = totalSupply_.mul(mainFundPrecent).div(100* 10 ** precentDecimal) ;
//Calculate the total value of subFund
subFundBalance = totalSupply_.mul(subFundPrecent).div(100* 10 ** precentDecimal);
//Calculate the total value of devTeamBalance
devTeamBalance = totalSupply_.mul(devTeamPrecent).div(100* 10 ** precentDecimal);
//Calculate the total value of hitFoundationBalance
hitFoundationBalance = totalSupply_.mul(hitFoundationPrecent).div(100* 10 ** precentDecimal) ;
//Initially put the hitFoundationBalance into the hitFoundationAccount
balances[_hitFoundationAccount] = hitFoundationBalance;
//Initially put the devTeamBalance into the teamAccount
balances[_teamAccount] = devTeamBalance;
//Initially put the subFundBalance into the subFundAccount
balances[_subFundAccount] = subFundBalance;
//Initially put the mainFundBalance into the mainFundAccount
balances[_mainFundAccount]=mainFundBalance;
//Initially lock the team account
teamLock(_teamAccount,devTeamBalance);
}
function burn(uint256 _value) public onlyOwner returns (bool) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[address(0)] = balances[address(0)].add(_value);
emit Transfer(msg.sender, address(0), _value);
return true;
}
function transfer(address _to, uint256 _value) public returns (bool) {
if(issueDate==0)
{
//the mainFundAccounts is not allowed to transfer before issued
require(msg.sender != mainFundAccount);
}
if(teamLockTime[msg.sender] > 0){
return super.teamLockTransfer(_to,_value);
}else if(fundLockTime[msg.sender] > 0){
return super.fundLockTransfer(_to,_value);
}else {
return super.transfer(_to, _value);
}
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
if(issueDate==0)
{
//the mainFundAccounts is not allowed to transfer before issued
require(_from != mainFundAccount);
}
if(teamLockTime[_from] > 0){
return super.teamLockTransferFrom(_from,_to,_value);
}else if(fundLockTime[_from] > 0){
return super.fundLockTransferFrom(_from,_to,_value);
}else{
return super.transferFrom(_from, _to, _value);
}
}
function mintFund(address _to, uint256 _value) public returns (bool){
require(msg.sender==mainFundAccount);
require(mainFundBalance >0);
require(_value >0);
if(_value <= mainFundBalance){
super.transfer(_to,_value);
fundLock(_to,_value);
mainFundBalance = mainFundBalance.sub(_value);
}
}
function issue() public onlyOwner returns (uint){
//Only one time
require(issueDate==0);
issueDate = now;
return now;
}
function() public payable{
revert();
}
}
| 186,904 | 12,516 |
ebfa62580a97018ff8b54090e053113081e9ac0f63cbc2757a31dad60bc95532
| 12,720 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xaa9b22f0e3e1e3dc88aa868571b4b0daa60f446b.sol
| 3,281 | 11,891 |
pragma solidity ^0.4.25;
contract ECT {
modifier onlyBagholders {
require(myTokens() > 0);
_;
}
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);
event Transfer(address indexed from,
address indexed to,
uint256 tokens);
string public name = "Ethereum Captial Token";
string public symbol = "ECT";
uint8 constant public decimals = 18;
uint8 constant internal entryFee_ = 12;
uint8 constant internal transferFee_ = 1;
uint8 constant internal exitFee_ = 6;
uint8 constant internal refferalFee_ = 33;
uint256 constant internal tokenPriceInitial_ = 0.0000001 ether;
uint256 constant internal tokenPriceIncremental_ = 0.00000001 ether;
uint256 constant internal magnitude = 2 ** 64;
uint256 public stakingRequirement = 50e18;
mapping(address => uint256) internal tokenBalanceLedger_;
mapping(address => uint256) internal referralBalance_;
mapping(address => int256) internal payoutsTo_;
uint256 internal tokenSupply_;
uint256 internal profitPerShare_;
function buy(address _referredBy) public payable returns (uint256) {
purchaseTokens(msg.value, _referredBy);
}
function() payable public {
purchaseTokens(msg.value, 0x0);
}
function reinvest() onlyStronghands public {
uint256 _dividends = myDividends(false);
address _customerAddress = msg.sender;
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
uint256 _tokens = purchaseTokens(_dividends, 0x0);
emit onReinvestment(_customerAddress, _dividends, _tokens);
}
function exit() onlyStronghands public {
address _customerAddress = msg.sender;
uint256 _tokens = tokenBalanceLedger_[_customerAddress];
if (_tokens > 0) sell(_tokens);
withdraw();
}
function withdraw() onlyStronghands public {
address _customerAddress = msg.sender;
uint256 _dividends = myDividends(false);
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
_customerAddress.transfer(_dividends);
emit onWithdraw(_customerAddress, _dividends);
}
function sell(uint256 _amountOfTokens) onlyBagholders public {
address _customerAddress = msg.sender;
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);
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokens);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _tokens);
int256 _updatedPayouts = (int256) (profitPerShare_ * _tokens + (_taxedEthereum * magnitude));
payoutsTo_[_customerAddress] -= _updatedPayouts;
if (tokenSupply_ > 0) {
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
}
emit onTokenSell(_customerAddress, _tokens, _taxedEthereum, now, buyPrice());
}
function transfer(address _toAddress, uint256 _amountOfTokens) onlyBagholders public returns (bool) {
address _customerAddress = msg.sender;
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
if (myDividends(true) > 0) {
withdraw();
}
uint256 _tokenFee = SafeMath.div(SafeMath.mul(_amountOfTokens, transferFee_), 100);
uint256 _taxedTokens = SafeMath.sub(_amountOfTokens, _tokenFee);
uint256 _dividends = tokensToEthereum_(_tokenFee);
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokenFee);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
tokenBalanceLedger_[_toAddress] = SafeMath.add(tokenBalanceLedger_[_toAddress], _taxedTokens);
payoutsTo_[_customerAddress] -= (int256) (profitPerShare_ * _amountOfTokens);
payoutsTo_[_toAddress] += (int256) (profitPerShare_ * _taxedTokens);
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
emit Transfer(_customerAddress, _toAddress, _taxedTokens);
return true;
}
function totalEthereumBalance() public view returns (uint256) {
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) public view returns (uint256) {
return tokenBalanceLedger_[_customerAddress];
}
function dividendsOf(address _customerAddress) public view 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, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
}
function buyPrice() public view returns (uint256) {
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;
}
}
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;
}
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;
}
function purchaseTokens(uint256 _incomingEthereum, address _referredBy) internal returns (uint256) {
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 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
uint256 _fee = _dividends * magnitude;
require(_amountOfTokens > 0 && SafeMath.add(_amountOfTokens, tokenSupply_) > tokenSupply_);
if (_referredBy != 0x0000000000000000000000000000000000000000 &&
_referredBy != _customerAddress &&
tokenBalanceLedger_[_referredBy] >= stakingRequirement) {
referralBalance_[_referredBy] = SafeMath.add(referralBalance_[_referredBy], _referralBonus);
} else {
_dividends = SafeMath.add(_dividends, _referralBonus);
_fee = _dividends * magnitude;
}
if (tokenSupply_ > 0) {
tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens);
profitPerShare_ += (_dividends * magnitude / tokenSupply_);
_fee = _fee - (_fee - (_amountOfTokens * (_dividends * magnitude / tokenSupply_)));
} else {
tokenSupply_ = _amountOfTokens;
}
tokenBalanceLedger_[_customerAddress] = SafeMath.add(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
int256 _updatedPayouts = (int256) (profitPerShare_ * _amountOfTokens - _fee);
payoutsTo_[_customerAddress] += _updatedPayouts;
emit onTokenPurchase(_customerAddress, _incomingEthereum, _amountOfTokens, _referredBy, now, buyPrice());
return _amountOfTokens;
}
function ethereumToTokens_(uint256 _ethereum) internal view returns (uint256) {
uint256 _tokenPriceInitial = tokenPriceInitial_ * 1e18;
uint256 _tokensReceived =
((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 =
(SafeMath.sub((((tokenPriceInitial_ + (tokenPriceIncremental_ * (_tokenSupply / 1e18))) - tokenPriceIncremental_) * (tokens_ - 1e18)), (tokenPriceIncremental_ * ((tokens_ ** 2 - tokens_) / 1e18)) / 2)
/ 1e18);
return _etherReceived;
}
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) {
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;
}
}
| 201,061 | 12,517 |
85b24e58598c4a496eeac6811d3320da24a9a049f1e416e4e6b3ad7c43fd6c94
| 13,044 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0x457476bc97adef10aba63fcadaefe503553fa0d2.sol
| 3,546 | 12,736 |
pragma solidity ^0.4.24;
library SafeMath {
function add(uint256 _a, uint256 _b) internal pure returns (uint256) {
uint256 c = _a + _b;
assert(c >= _a);
return c;
}
function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
assert(_a >= _b);
return _a - _b;
}
function mul(uint256 _a, uint256 _b) internal pure returns (uint256) {
uint256 c = _a * _b;
assert(_a == 0 || c / _a == _b);
return c;
}
}
contract Owned {
address public owner;
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function setOwner(address _owner) onlyOwner public {
owner = _owner;
}
}
interface ERC20Token {
function name() external view returns (string name_);
function symbol() external view returns (string symbol_);
function decimals() external view returns (uint8 decimals_);
function totalSupply() external view returns (uint256 totalSupply_);
function balanceOf(address _owner) external view returns (uint256 _balance);
function transfer(address _to, uint256 _value) external returns (bool _success);
function transferFrom(address _from, address _to, uint256 _value) external returns (bool _success);
function approve(address _spender, uint256 _value) external returns (bool _success);
function allowance(address _owner, address _spender) external view returns (uint256 _remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract UBNK is Owned, ERC20Token {
using SafeMath for uint256;
string private constant standard = "20181162ee7d";
string private constant version = "6.02fa16";
string private name_ = "UBNK";
string private symbol_ = "UBNK";
uint8 private decimals_ = 18;
uint256 private totalSupply_ = uint256(100) * uint256(10)**uint256(8) * uint256(10)**uint256(decimals_);
mapping (address => uint256) private balanceP;
mapping (address => mapping (address => uint256)) private allowed;
mapping (address => uint256[]) private lockTime;
mapping (address => uint256[]) private lockValue;
mapping (address => uint256) private lockNum;
uint256 private later = 0;
uint256 private earlier = 0;
bool private mintable_ = false;
event Burn(address indexed _from, uint256 _value);
event Mint(address indexed _to, uint256 _value);
event TransferLocked(address indexed _from, address indexed _to, uint256 _time, uint256 _value);
event TokenUnlocked(address indexed _address, uint256 _value);
event WrongTokenEmptied(address indexed _token, address indexed _addr, uint256 _amount);
event WrongEtherEmptied(address indexed _addr, uint256 _amount);
constructor() public {
balanceP[msg.sender] = totalSupply_;
}
modifier validAddress(address _address) {
require(_address != 0x0);
_;
}
modifier isMintable() {
require(mintable_);
_;
}
function setUnlockEarlier(uint256 _earlier) public onlyOwner {
earlier = earlier.add(_earlier);
}
function setUnlockLater(uint256 _later) public onlyOwner {
later = later.add(_later);
}
function disableMint() public onlyOwner isMintable {
mintable_ = false;
}
function mintable() public view returns (bool) {
return mintable_;
}
function name() public view returns (string) {
return name_;
}
function symbol() public view returns (string) {
return symbol_;
}
function decimals() public view returns (uint8) {
return decimals_;
}
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function allowance(address _owner, address _spender) external view returns (uint256) {
return allowed[_owner][_spender];
}
function balanceUnlocked(address _address) public view returns (uint256 _balance) {
_balance = balanceP[_address];
uint256 i = 0;
while (i < lockNum[_address]) {
if (now.add(earlier) >= lockTime[_address][i].add(later)) _balance = _balance.add(lockValue[_address][i]);
i++;
}
return _balance;
}
function balanceLocked(address _address) public view returns (uint256 _balance) {
_balance = 0;
uint256 i = 0;
while (i < lockNum[_address]) {
if (now.add(earlier) < lockTime[_address][i].add(later)) _balance = _balance.add(lockValue[_address][i]);
i++;
}
return _balance;
}
function balanceOf(address _address) public view returns (uint256 _balance) {
_balance = balanceP[_address];
uint256 i = 0;
while (i < lockNum[_address]) {
_balance = _balance.add(lockValue[_address][i]);
i++;
}
return _balance;
}
function showLockTimes(address _address) public view validAddress(_address) returns (uint256[] _times) {
uint i = 0;
uint256[] memory tempLockTime = new uint256[](lockNum[_address]);
while (i < lockNum[_address]) {
tempLockTime[i] = lockTime[_address][i].add(later).sub(earlier);
i++;
}
return tempLockTime;
}
function showLockValues(address _address) public view validAddress(_address) returns (uint256[] _values) {
return lockValue[_address];
}
function showLockNum(address _address) public view validAddress(_address) returns (uint256 _lockNum) {
return lockNum[_address];
}
function calcUnlock(address _address) private {
uint256 i = 0;
uint256 j = 0;
uint256[] memory currentLockTime;
uint256[] memory currentLockValue;
uint256[] memory newLockTime = new uint256[](lockNum[_address]);
uint256[] memory newLockValue = new uint256[](lockNum[_address]);
currentLockTime = lockTime[_address];
currentLockValue = lockValue[_address];
while (i < lockNum[_address]) {
if (now.add(earlier) >= currentLockTime[i].add(later)) {
balanceP[_address] = balanceP[_address].add(currentLockValue[i]);
emit TokenUnlocked(_address, currentLockValue[i]);
} else {
newLockTime[j] = currentLockTime[i];
newLockValue[j] = currentLockValue[i];
j++;
}
i++;
}
uint256[] memory trimLockTime = new uint256[](j);
uint256[] memory trimLockValue = new uint256[](j);
i = 0;
while (i < j) {
trimLockTime[i] = newLockTime[i];
trimLockValue[i] = newLockValue[i];
i++;
}
lockTime[_address] = trimLockTime;
lockValue[_address] = trimLockValue;
lockNum[_address] = j;
}
function transfer(address _to, uint256 _value) public validAddress(_to) returns (bool _success) {
if (lockNum[msg.sender] > 0) calcUnlock(msg.sender);
require(balanceP[msg.sender] >= _value && _value >= 0);
balanceP[msg.sender] = balanceP[msg.sender].sub(_value);
balanceP[_to] = balanceP[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function transferLocked(address _to, uint256[] _time, uint256[] _value) public validAddress(_to) returns (bool _success) {
require(_value.length == _time.length);
if (lockNum[msg.sender] > 0) calcUnlock(msg.sender);
uint256 i = 0;
uint256 totalValue = 0;
while (i < _value.length) {
totalValue = totalValue.add(_value[i]);
i++;
}
require(balanceP[msg.sender] >= totalValue && totalValue >= 0);
require(lockNum[_to].add(_time.length) <= 42);
i = 0;
while (i < _time.length) {
if (_value[i] > 0) {
balanceP[msg.sender] = balanceP[msg.sender].sub(_value[i]);
lockTime[_to].length = lockNum[_to]+1;
lockValue[_to].length = lockNum[_to]+1;
lockTime[_to][lockNum[_to]] = now.add(_time[i]).add(earlier).sub(later);
lockValue[_to][lockNum[_to]] = _value[i];
lockNum[_to]++;
}
emit TransferLocked(msg.sender, _to, _time[i], _value[i]);
emit Transfer(msg.sender, _to, _value[i]);
i++;
}
return true;
}
function transferLockedFrom(address _from, address _to, uint256[] _time, uint256[] _value) public
validAddress(_from) validAddress(_to) returns (bool success) {
require(_value.length == _time.length);
if (lockNum[_from] > 0) calcUnlock(_from);
uint256 i = 0;
uint256 totalValue = 0;
while (i < _value.length) {
totalValue = totalValue.add(_value[i]);
i++;
}
require(balanceP[_from] >= totalValue && totalValue >= 0 && allowed[_from][msg.sender] >= totalValue);
require(lockNum[_to].add(_time.length) <= 42);
i = 0;
while (i < _time.length) {
if (_value[i] > 0) {
balanceP[_from] = balanceP[_from].sub(_value[i]);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value[i]);
lockTime[_to].length = lockNum[_to]+1;
lockValue[_to].length = lockNum[_to]+1;
lockTime[_to][lockNum[_to]] = now.add(_time[i]).add(earlier).sub(later);
lockValue[_to][lockNum[_to]] = _value[i];
lockNum[_to]++;
}
emit TransferLocked(_from, _to, _time[i], _value[i]);
emit Transfer(_from, _to, _value[i]);
i++;
}
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public validAddress(_from) validAddress(_to) returns (bool _success) {
if (lockNum[_from] > 0) calcUnlock(_from);
require(balanceP[_from] >= _value && _value >= 0 && allowed[_from][msg.sender] >= _value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
balanceP[_from] = balanceP[_from].sub(_value);
balanceP[_to] = balanceP[_to].add(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public validAddress(_spender) returns (bool _success) {
if (lockNum[msg.sender] > 0) calcUnlock(msg.sender);
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function increaseApproval(address _spender, uint _value) public validAddress(_spender) returns (bool _success) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_value);
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _value) public validAddress(_spender) returns (bool _success) {
if(_value >= allowed[msg.sender][_spender]) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].sub(_value);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function burn(uint256 _value) public onlyOwner returns (bool _success) {
if (lockNum[msg.sender] > 0) calcUnlock(msg.sender);
require(balanceP[msg.sender] >= _value && _value >= 0);
balanceP[msg.sender] = balanceP[msg.sender].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(msg.sender, _value);
return true;
}
function mint(uint256 _value) public onlyOwner isMintable returns (bool _success) {
balanceP[msg.sender] = balanceP[msg.sender].add(_value);
totalSupply_ = totalSupply_.add(_value);
emit Mint(msg.sender, _value);
return true;
}
function () public payable {
revert();
}
function emptyWrongToken(address _addr) onlyOwner public {
ERC20Token wrongToken = ERC20Token(_addr);
uint256 amount = wrongToken.balanceOf(address(this));
require(amount > 0);
require(wrongToken.transfer(msg.sender, amount));
emit WrongTokenEmptied(_addr, msg.sender, amount);
}
function emptyWrongEther() onlyOwner public {
uint256 amount = address(this).balance;
require(amount > 0);
msg.sender.transfer(amount);
emit WrongEtherEmptied(msg.sender, amount);
}
}
| 165,625 | 12,518 |
410bbf97abbff14e0293327af278eb4452c52a62a14e96b7d07bd2cffcc24480
| 18,821 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/5c/5Cbe5D128e3D50e0c2102cbB99A044d322740447_SPIKE.sol
| 4,184 | 15,790 |
// 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 SPIKE 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 = 'SPIKE';
string private _symbol = 'SPIKE';
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(15);
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);
}
}
| 90,755 | 12,519 |
1d69664f7d40bc2e8ae8f5f5fc8a52679ff0a8d66410f3e76f3ed66479dd6248
| 13,515 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xC10dE8aEbDf7E51557DFdE5b46a522Abf3f5E55F/contract.sol
| 3,387 | 13,002 |
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");
// 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) {
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 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 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);
}
contract Initializable {
bool private initialized;
bool private initializing;
modifier initializer() {
require(initializing || isConstructor() || !initialized, "Contract instance has already been initialized");
bool isTopLevelCall = !initializing;
if (isTopLevelCall) {
initializing = true;
initialized = true;
}
_;
if (isTopLevelCall) {
initializing = false;
}
}
function isConstructor() private view returns (bool) {
address self = address(this);
uint256 cs;
assembly { cs := extcodesize(self) }
return cs == 0;
}
uint256[50] private ______gap;
}
contract BurnoutPool is Initializable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public depositToken;
uint256 private _totalSupply;
mapping(address => uint256) private _balances;
function initialize(address _token) public initializer {
depositToken = IERC20(_token);
}
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
function _stake(uint256 amount) internal {
_totalSupply = _totalSupply.add(amount);
_balances[msg.sender] = _balances[msg.sender].add(amount);
depositToken.safeTransferFrom(msg.sender, address(this), amount);
}
function _withdraw(uint256 amount) internal {
_totalSupply = _totalSupply.sub(amount);
_balances[msg.sender] = _balances[msg.sender].sub(amount);
depositToken.safeTransfer(msg.sender, amount);
}
}
library Math {
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
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);
}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
contract BurnMint is BurnoutPool {
IERC20 public degenToken;
// Halving period in seconds, should be defined as 1 week
uint256 public halvingPeriod = 604800;
// Total reward in 18 decimal
uint256 public totalreward;
// Starting timestamp for Degen Staking Pool
uint256 public starttime;
// The timestamp when stakers should be allowed to withdraw
uint256 public stakingtime;
uint256 public eraPeriod = 0;
uint256 public rewardRate = 0;
uint256 public lastUpdateTime;
uint256 public rewardPerTokenStored;
uint256 public totalRewards = 0;
mapping(address => uint256) public userRewardPerTokenPaid;
mapping(address => uint256) public rewards;
event RewardAdded(uint256 reward);
event Staked(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RewardPaid(address indexed user, uint256 reward);
modifier updateReward(address account) {
rewardPerTokenStored = rewardPerToken();
lastUpdateTime = lastTimeRewardApplicable();
if (account != address(0)) {
rewards[account] = earned(account);
userRewardPerTokenPaid[account] = rewardPerTokenStored;
}
_;
}
constructor(address _depositToken, address _degenToken, uint256 _totalreward, uint256 _starttime, uint256 _stakingtime) public {
super.initialize(_depositToken);
degenToken = IERC20(_degenToken);
starttime = _starttime;
stakingtime = _stakingtime;
notifyRewardAmount(_totalreward.mul(50).div(100));
}
function lastTimeRewardApplicable() public view returns (uint256) {
return Math.min(block.timestamp, eraPeriod);
}
function rewardPerToken() public view returns (uint256) {
if (totalSupply() == 0) {
return rewardPerTokenStored;
}
return
rewardPerTokenStored.add(lastTimeRewardApplicable()
.sub(lastUpdateTime)
.mul(rewardRate)
.mul(1e18)
.div(totalSupply()));
}
function earned(address account) public view returns (uint256) {
return
balanceOf(account)
.mul(rewardPerToken().sub(userRewardPerTokenPaid[account]))
.div(1e18)
.add(rewards[account]);
}
function stake(uint256 amount) public updateReward(msg.sender) checkhalve checkStart{
require(amount > 0, "ERROR: Cannot stake 0 Tether");
super._stake(amount);
emit Staked(msg.sender, amount);
}
function withdraw(uint256 amount) public updateReward(msg.sender) checkhalve checkStart{
require(amount > 0, "ERROR: Cannot withdraw 0 Tether");
super._withdraw(amount);
emit Withdrawn(msg.sender, amount);
}
function exit() external stakingTime{
withdraw(balanceOf(msg.sender));
getReward();
}
function getReward() public updateReward(msg.sender) checkhalve checkStart stakingTime{
uint256 reward = earned(msg.sender);
if (reward > 0) {
rewards[msg.sender] = 0;
degenToken.safeTransfer(msg.sender, reward);
emit RewardPaid(msg.sender, reward);
totalRewards = totalRewards.add(reward);
}
}
modifier checkhalve(){
if (block.timestamp >= eraPeriod) {
totalreward = totalreward.mul(50).div(100);
rewardRate = totalreward.div(halvingPeriod);
eraPeriod = block.timestamp.add(halvingPeriod);
emit RewardAdded(totalreward);
}
_;
}
modifier checkStart(){
require(block.timestamp > starttime,"ERROR: Not start");
_;
}
modifier stakingTime(){
require(block.timestamp >= stakingtime,"ERROR: Withdrawals open after 24 hours from the beginning");
_;
}
function notifyRewardAmount(uint256 reward)
internal
updateReward(address(0))
{
if (block.timestamp >= eraPeriod) {
rewardRate = reward.div(halvingPeriod);
} else {
uint256 remaining = eraPeriod.sub(block.timestamp);
uint256 leftover = remaining.mul(rewardRate);
rewardRate = reward.add(leftover).div(halvingPeriod);
}
totalreward = reward;
lastUpdateTime = block.timestamp;
eraPeriod = block.timestamp.add(halvingPeriod);
emit RewardAdded(reward);
}
}
| 258,077 | 12,520 |
39a184957aae2dc5354284db8ff5a49fe69e4c9c83808f95d1a62f9c315d1184
| 18,091 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/09/090d145b36f483b51ec7f76311512d60c90bd8c2_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
});
}
}
| 113,070 | 12,521 |
327571b57ef9f2b1591c205b22009c2df9eba747d2ea2b36dd47037bf779ead1
| 37,904 |
.sol
|
Solidity
| false |
520399820
|
0xhatsume/vaults-strats-stuff
|
3ca4a4d4c454f81c8c1681f5eba746523b073f14
|
contracts/yearn/strategies/baseStrategy.sol
| 4,193 | 16,894 |
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.6.0 <0.7.0;
pragma experimental ABIEncoderV2;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import "@openzeppelin/contracts/math/SafeMath.sol";
struct StrategyParams {
uint256 performanceFee;
uint256 activation;
uint256 debtRatio;
uint256 minDebtPerHarvest;
uint256 maxDebtPerHarvest;
uint256 lastReport;
uint256 totalDebt;
uint256 totalGain;
uint256 totalLoss;
}
interface VaultAPI is IERC20 {
function name() external view returns (string calldata);
function symbol() external view returns (string calldata);
function decimals() external view returns (uint256);
function apiVersion() external pure returns (string memory);
function permit(address owner,
address spender,
uint256 amount,
uint256 expiry,
bytes calldata signature) external returns (bool);
// NOTE: Vyper produces multiple signatures for a given function with "default" args
function deposit() external returns (uint256);
function deposit(uint256 amount) external returns (uint256);
function deposit(uint256 amount, address recipient) external returns (uint256);
// NOTE: Vyper produces multiple signatures for a given function with "default" args
function withdraw() external returns (uint256);
function withdraw(uint256 maxShares) external returns (uint256);
function withdraw(uint256 maxShares, address recipient) external returns (uint256);
function token() external view returns (address);
function strategies(address _strategy) external view returns (StrategyParams memory);
function pricePerShare() external view returns (uint256);
function totalAssets() external view returns (uint256);
function depositLimit() external view returns (uint256);
function maxAvailableShares() external view returns (uint256);
function creditAvailable() external view returns (uint256);
function debtOutstanding() external view returns (uint256);
function expectedReturn() external view returns (uint256);
function report(uint256 _gain,
uint256 _loss,
uint256 _debtPayment) external returns (uint256);
function revokeStrategy() external;
function governance() external view returns (address);
function management() external view returns (address);
function guardian() external view returns (address);
}
interface StrategyAPI {
function name() external view returns (string memory);
function vault() external view returns (address);
function want() external view returns (address);
function apiVersion() external pure returns (string memory);
function keeper() external view returns (address);
function isActive() external view returns (bool);
function delegatedAssets() external view returns (uint256);
function estimatedTotalAssets() external view returns (uint256);
function tendTrigger(uint256 callCost) external view returns (bool);
function tend() external;
function harvestTrigger(uint256 callCost) external view returns (bool);
function harvest() external;
event Harvested(uint256 profit, uint256 loss, uint256 debtPayment, uint256 debtOutstanding);
}
interface HealthCheck {
function check(uint256 profit,
uint256 loss,
uint256 debtPayment,
uint256 debtOutstanding,
uint256 totalDebt) external view returns (bool);
}
abstract contract BaseStrategy {
using SafeMath for uint256;
using SafeERC20 for IERC20;
string public metadataURI;
// health checks
bool public doHealthCheck;
address public healthCheck;
function apiVersion() public pure returns (string memory) {
return "0.4.3";
}
function name() external view virtual returns (string memory);
function delegatedAssets() external view virtual returns (uint256) {
return 0;
}
VaultAPI public vault;
address public strategist;
address public rewards;
address public keeper;
IERC20 public want;
// So indexers can keep track of this
event Harvested(uint256 profit, uint256 loss, uint256 debtPayment, uint256 debtOutstanding);
event UpdatedStrategist(address newStrategist);
event UpdatedKeeper(address newKeeper);
event UpdatedRewards(address rewards);
event UpdatedMinReportDelay(uint256 delay);
event UpdatedMaxReportDelay(uint256 delay);
event UpdatedProfitFactor(uint256 profitFactor);
event UpdatedDebtThreshold(uint256 debtThreshold);
event EmergencyExitEnabled();
event UpdatedMetadataURI(string metadataURI);
event SetHealthCheck(address);
event SetDoHealthCheck(bool);
// The minimum number of seconds between harvest calls. See
// `setMinReportDelay()` for more details.
uint256 public minReportDelay;
// The maximum number of seconds between harvest calls. See
// `setMaxReportDelay()` for more details.
uint256 public maxReportDelay;
// The minimum multiple that `callCost` must be above the credit/profit to
// be "justifiable". See `setProfitFactor()` for more details.
uint256 public profitFactor;
// Use this to adjust the threshold at which running a debt causes a
// harvest trigger. See `setDebtThreshold()` for more details.
uint256 public debtThreshold;
// See note on `setEmergencyExit()`.
bool public emergencyExit;
// modifiers
modifier onlyAuthorized() {
require(msg.sender == strategist || msg.sender == governance(), "!authorized");
_;
}
modifier onlyEmergencyAuthorized() {
require(msg.sender == strategist || msg.sender == governance() || msg.sender == vault.guardian() || msg.sender == vault.management(),
"!authorized");
_;
}
modifier onlyStrategist() {
require(msg.sender == strategist, "!strategist");
_;
}
modifier onlyGovernance() {
require(msg.sender == governance(), "!authorized");
_;
}
modifier onlyKeepers() {
require(msg.sender == keeper ||
msg.sender == strategist ||
msg.sender == governance() ||
msg.sender == vault.guardian() ||
msg.sender == vault.management(),
"!authorized");
_;
}
modifier onlyVaultManagers() {
require(msg.sender == vault.management() || msg.sender == governance(), "!authorized");
_;
}
constructor(address _vault) public {
_initialize(_vault, msg.sender, msg.sender, msg.sender);
}
function _initialize(address _vault,
address _strategist,
address _rewards,
address _keeper) internal {
require(address(want) == address(0), "Strategy already initialized");
vault = VaultAPI(_vault);
want = IERC20(vault.token());
want.safeApprove(_vault, uint256(-1)); // Give Vault unlimited access (might save gas)
strategist = _strategist;
rewards = _rewards;
keeper = _keeper;
// initialize variables
minReportDelay = 0;
maxReportDelay = 86400;
profitFactor = 100;
debtThreshold = 0;
vault.approve(rewards, uint256(-1)); // Allow rewards to be pulled
}
function setHealthCheck(address _healthCheck) external onlyVaultManagers {
emit SetHealthCheck(_healthCheck);
healthCheck = _healthCheck;
}
function setDoHealthCheck(bool _doHealthCheck) external onlyVaultManagers {
emit SetDoHealthCheck(_doHealthCheck);
doHealthCheck = _doHealthCheck;
}
function setStrategist(address _strategist) external onlyAuthorized {
require(_strategist != address(0));
strategist = _strategist;
emit UpdatedStrategist(_strategist);
}
function setKeeper(address _keeper) external onlyAuthorized {
require(_keeper != address(0));
keeper = _keeper;
emit UpdatedKeeper(_keeper);
}
function setRewards(address _rewards) external onlyStrategist {
require(_rewards != address(0));
vault.approve(rewards, 0);
rewards = _rewards;
vault.approve(rewards, uint256(-1));
emit UpdatedRewards(_rewards);
}
function setMinReportDelay(uint256 _delay) external onlyAuthorized {
minReportDelay = _delay;
emit UpdatedMinReportDelay(_delay);
}
function setMaxReportDelay(uint256 _delay) external onlyAuthorized {
maxReportDelay = _delay;
emit UpdatedMaxReportDelay(_delay);
}
function setProfitFactor(uint256 _profitFactor) external onlyAuthorized {
profitFactor = _profitFactor;
emit UpdatedProfitFactor(_profitFactor);
}
function setDebtThreshold(uint256 _debtThreshold) external onlyAuthorized {
debtThreshold = _debtThreshold;
emit UpdatedDebtThreshold(_debtThreshold);
}
function setMetadataURI(string calldata _metadataURI) external onlyAuthorized {
metadataURI = _metadataURI;
emit UpdatedMetadataURI(_metadataURI);
}
function governance() internal view returns (address) {
return vault.governance();
}
function ethToWant(uint256 _amtInWei) public view virtual returns (uint256);
function estimatedTotalAssets() public view virtual returns (uint256);
function isActive() public view returns (bool) {
return vault.strategies(address(this)).debtRatio > 0 || estimatedTotalAssets() > 0;
}
function prepareReturn(uint256 _debtOutstanding)
internal
virtual
returns (uint256 _profit,
uint256 _loss,
uint256 _debtPayment);
function adjustPosition(uint256 _debtOutstanding) internal virtual;
function liquidatePosition(uint256 _amountNeeded) internal virtual returns (uint256 _liquidatedAmount, uint256 _loss);
function liquidateAllPositions() internal virtual returns (uint256 _amountFreed);
function tendTrigger(uint256 callCostInWei) public view virtual returns (bool) {
// We usually don't need tend, but if there are positions that need
// active maintainence, overriding this function is how you would
// signal for that.
// If your implementation uses the cost of the call in want, you can
// use uint256 callCost = ethToWant(callCostInWei);
return false;
}
function tend() external onlyKeepers {
// Don't take profits with this call, but adjust for better gains
adjustPosition(vault.debtOutstanding());
}
function harvestTrigger(uint256 callCostInWei) public view virtual returns (bool) {
uint256 callCost = ethToWant(callCostInWei);
StrategyParams memory params = vault.strategies(address(this));
// Should not trigger if Strategy is not activated
if (params.activation == 0) return false;
// Should not trigger if we haven't waited long enough since previous harvest
if (block.timestamp.sub(params.lastReport) < minReportDelay) return false;
// Should trigger if hasn't been called in a while
if (block.timestamp.sub(params.lastReport) >= maxReportDelay) return true;
// If some amount is owed, pay it back
// NOTE: Since debt is based on deposits, it makes sense to guard against large
// changes to the value from triggering a harvest directly through user
// behavior. This should ensure reasonable resistance to manipulation
// from user-initiated withdrawals as the outstanding debt fluctuates.
uint256 outstanding = vault.debtOutstanding();
if (outstanding > debtThreshold) return true;
// Check for profits and losses
uint256 total = estimatedTotalAssets();
// Trigger if we have a loss to report
if (total.add(debtThreshold) < params.totalDebt) return true;
uint256 profit = 0;
if (total > params.totalDebt) profit = total.sub(params.totalDebt); // We've earned a profit!
// Otherwise, only trigger if it "makes sense" economically (gas cost
// is <N% of value moved)
uint256 credit = vault.creditAvailable();
return (profitFactor.mul(callCost) < credit.add(profit));
}
function harvest() external onlyKeepers {
uint256 profit = 0;
uint256 loss = 0;
uint256 debtOutstanding = vault.debtOutstanding();
uint256 debtPayment = 0;
if (emergencyExit) {
// Free up as much capital as possible
uint256 amountFreed = liquidateAllPositions();
if (amountFreed < debtOutstanding) {
loss = debtOutstanding.sub(amountFreed);
} else if (amountFreed > debtOutstanding) {
profit = amountFreed.sub(debtOutstanding);
}
debtPayment = debtOutstanding.sub(loss);
} else {
// Free up returns for Vault to pull
(profit, loss, debtPayment) = prepareReturn(debtOutstanding);
}
// Allow Vault to take up to the "harvested" balance of this contract,
// which is the amount it has earned since the last time it reported to
// the Vault.
uint256 totalDebt = vault.strategies(address(this)).totalDebt;
debtOutstanding = vault.report(profit, loss, debtPayment);
// Check if free returns are left, and re-invest them
adjustPosition(debtOutstanding);
// call healthCheck contract
if (doHealthCheck && healthCheck != address(0)) {
require(HealthCheck(healthCheck).check(profit, loss, debtPayment, debtOutstanding, totalDebt), "!healthcheck");
} else {
emit SetDoHealthCheck(true);
doHealthCheck = true;
}
emit Harvested(profit, loss, debtPayment, debtOutstanding);
}
function withdraw(uint256 _amountNeeded) external returns (uint256 _loss) {
require(msg.sender == address(vault), "!vault");
// Liquidate as much as possible to `want`, up to `_amountNeeded`
uint256 amountFreed;
(amountFreed, _loss) = liquidatePosition(_amountNeeded);
// Send it directly back (NOTE: Using `msg.sender` saves some gas here)
want.safeTransfer(msg.sender, amountFreed);
// NOTE: Reinvest anything leftover on next `tend`/`harvest`
}
function prepareMigration(address _newStrategy) internal virtual;
function migrate(address _newStrategy) external {
require(msg.sender == address(vault));
require(BaseStrategy(_newStrategy).vault() == vault);
prepareMigration(_newStrategy);
want.safeTransfer(_newStrategy, want.balanceOf(address(this)));
}
function setEmergencyExit() external onlyEmergencyAuthorized {
emergencyExit = true;
vault.revokeStrategy();
emit EmergencyExitEnabled();
}
function protectedTokens() internal view virtual returns (address[] memory);
function sweep(address _token) external onlyGovernance {
require(_token != address(want), "!want");
require(_token != address(vault), "!shares");
address[] memory _protectedTokens = protectedTokens();
for (uint256 i; i < _protectedTokens.length; i++) require(_token != _protectedTokens[i], "!protected");
IERC20(_token).safeTransfer(governance(), IERC20(_token).balanceOf(address(this)));
}
}
abstract contract BaseStrategyInitializable is BaseStrategy {
bool public isOriginal = true;
event Cloned(address indexed clone);
constructor(address _vault) public BaseStrategy(_vault) {}
function initialize(address _vault,
address _strategist,
address _rewards,
address _keeper) external virtual {
_initialize(_vault, _strategist, _rewards, _keeper);
}
function clone(address _vault) external returns (address) {
require(isOriginal, "!clone");
return this.clone(_vault, msg.sender, msg.sender, msg.sender);
}
function clone(address _vault,
address _strategist,
address _rewards,
address _keeper) external returns (address newStrategy) {
// Copied from https://github.com/optionality/clone-factory/blob/master/contracts/CloneFactory.sol
bytes20 addressBytes = bytes20(address(this));
assembly {
// EIP-1167 bytecode
let clone_code := mload(0x40)
mstore(clone_code, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)
mstore(add(clone_code, 0x14), addressBytes)
mstore(add(clone_code, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)
newStrategy := create(0, clone_code, 0x37)
}
BaseStrategyInitializable(newStrategy).initialize(_vault, _strategist, _rewards, _keeper);
emit Cloned(newStrategy);
}
}
| 338,348 | 12,522 |
2124d0f0e3a9714a0c36f47606cbc19bdb66f35a865cd3df2906c4551fd5dcb7
| 19,444 |
.sol
|
Solidity
| false |
189391690
|
WaltonChain/WaltonChain_CrossChain
|
2ba44216811ea7a546beaf972a50e8d7a6360752
|
mechanism/indicatrix.sol
| 4,048 | 17,295 |
pragma solidity ^0.4.25;
contract Endorsement {
address private creator; // The creator of this contract
bool public initialized; // Initialization state
uint public lockTime; // Endorsement lock time
mapping(uint => address[]) private locks; // Endorsement lock collection storing SMNs in each endorsement period
mapping(uint => mapping(address => bool)) keys; // Endorsement key collection
uint public endorsementReward; // Endorsement rewar
mapping(uint => uint) public endorsementRewards; // Endorsement reward collection
uint public reserve; // Endorsement reward reserve
uint public endorsementSMNSize; // Endorsement limit
mapping(uint => mapping(address => bool)) public isAddeds; // Endorsed SMN collection
mapping(uint => mapping(string => address[])) endorsementSenders; // Endorsement senders based on endorsement number and endorsement data
mapping(uint => address[]) endorsementSendersAll; // Endorsement senders based on endorsement number
mapping(uint => EndorsementData[]) endorsementDatas; // Endorsement datas
mapping(address => uint) public totalRewardSMNs; // Total reward for each SMN
mapping(uint => mapping(string => uint)) hashEndorsementCounter; // Endorsement count based on endorsement number and endorsement data
mapping(uint => string) private mainEndorsements; // Main endorsements
mapping(uint => uint) private endorsementsIndexs; // Main endorsements index
mapping(uint => bool) public isEndorsements; // Endorsed collection
mapping(uint => uint) public endorsementCounter; // Endorsement count per endorsement number
uint public endorsementSize; // Capacity of an endorsement number
address emptyAddress =address(0x0); // Empty address
address permissionContractAddress; // WTC permission contract
event Deposit(uint value); // Deposit event
event RewardSMNs(address[] contributors); // Endorsement reward event
event AddEndorsement(uint endorsementNumber, string hashFingerprints); // Endorsement event
event Bonus(uint value);
address public bonusPool; //reward pool address
address[] private smnAddress; //smn reward arrays
address[] private jmnAddress; //jmn reward arrays
mapping(address=>uint256) private smnBonus; //smn reward
mapping(address=>uint256) private jmnBonus; //jmn reward
uint private allSMNBonus; //smn total reward
modifier onlyOwner {
require(msg.sender == creator);
_;
}
modifier onlyInitialized {
require(initialized);
_;
}
struct EndorsementData {
address sender;
address worker;
string hashFingerprints;
uint blockNumber;
}
// Empty endorsement information structure
EndorsementData emptyEndorsement = EndorsementData(emptyAddress, emptyAddress, "", 0);
constructor(address _creator) public {
creator = _creator;
lockTime=100;
bonusPool=address(0x0);
}
function init(address _permissionContractAddress, uint _endorsementReward, uint _endorsementSize, uint _endorsementSMNSize) public onlyOwner returns (bool) {
require(!initialized);
permissionContractAddress = _permissionContractAddress;
endorsementReward = _endorsementReward;
endorsementSize = _endorsementSize;
endorsementSMNSize = _endorsementSMNSize;
initialized = true;
return true;
}
function addEndorsement(uint _endorsementNumber, string _hashFingerprints) public onlyInitialized returns (bool){
address smn = PermissionContract(permissionContractAddress).getSMNAddress(msg.sender);
require(smn!=emptyAddress);
//Endorsement conditions
uint section = SafeMath.div(block.number, lockTime);
require(keys[section][smn]);
require(endorsementReward > 0);
require(endorsementCounter[_endorsementNumber] < endorsementSMNSize);
//if endorse record not exist
if(endorsementCounter[_endorsementNumber]==0){
require(address(this).balance > reserve + endorsementReward);
}
require(!isEndorsements[_endorsementNumber]);
require(!isAddeds[_endorsementNumber][smn]);
// Endorsement data
EndorsementData memory endorsementCurrent;
endorsementCurrent.sender = smn;
endorsementCurrent.worker = msg.sender;
endorsementCurrent.hashFingerprints = _hashFingerprints;
endorsementCurrent.blockNumber = block.number;
endorsementSenders[_endorsementNumber][_hashFingerprints].push(smn);
endorsementSendersAll[_endorsementNumber].push(smn);
endorsementDatas[_endorsementNumber].push(endorsementCurrent);
isAddeds[_endorsementNumber][smn] = true;
endorsementCounter[_endorsementNumber] = SafeMath.add(endorsementCounter[_endorsementNumber], 1);
hashEndorsementCounter[_endorsementNumber][_hashFingerprints] = SafeMath.add(hashEndorsementCounter[_endorsementNumber][_hashFingerprints], 1);
if (endorsementDatas[_endorsementNumber].length < 2) {
mainEndorsements[_endorsementNumber] = _hashFingerprints;
endorsementsIndexs[_endorsementNumber] = SafeMath.sub(endorsementDatas[_endorsementNumber].length, 1);
if(endorsementCounter[_endorsementNumber]==1){
// comfirm reward level with the frist endorsement.
endorsementRewards[_endorsementNumber] = endorsementReward;
reserve = SafeMath.add(reserve, endorsementReward);
}
} else {
uint mainEndorsementCounter = hashEndorsementCounter[_endorsementNumber][mainEndorsements[_endorsementNumber]];
if (hashEndorsementCounter[_endorsementNumber][_hashFingerprints] > mainEndorsementCounter) {
mainEndorsements[_endorsementNumber] = _hashFingerprints;
endorsementsIndexs[_endorsementNumber] = SafeMath.sub(endorsementDatas[_endorsementNumber].length, 1);
}
}
//Determine whether to reward
if (endorsementCounter[_endorsementNumber] >= endorsementSMNSize) {
rewardSMNs(endorsementSenders[_endorsementNumber][mainEndorsements[_endorsementNumber]], endorsementRewards[_endorsementNumber], _endorsementNumber);
bonus(endorsementRewards[_endorsementNumber]);
isEndorsements[_endorsementNumber] = true;
}
emit AddEndorsement(_endorsementNumber, _hashFingerprints);
return true;
}
//set endorsementReward
function setEndorsementReward(uint _endorsementReward) public onlyOwner onlyInitialized returns (bool){
endorsementReward = _endorsementReward;
return true;
}
function setLock() public returns (bool) {
address smnCurrent = PermissionContract(permissionContractAddress).getSMNAddress(msg.sender);
if (smnCurrent==emptyAddress) {
return false;
}
uint section = SafeMath.div(block.number, lockTime);
if (locks[section].length == endorsementSMNSize) {
return keys[section][smnCurrent];
}
if (locks[section].length < endorsementSMNSize) {
locks[section].push(smnCurrent);
keys[section][smnCurrent] = true;
}
return keys[section][smnCurrent];
}
function checkLock() public view returns (bool) {
address smnCurrent = PermissionContract(permissionContractAddress).getSMNAddress(msg.sender);
if (smnCurrent==emptyAddress) {
return false;
}
uint section = SafeMath.div(block.number, lockTime);
return keys[section][smnCurrent];
}
function rewardSMNs(address[] _endorsers, uint _rewardPerRecord, uint _endorsementNumber) private {
require(!isEndorsements[_endorsementNumber]);
require(address(this).balance >= _rewardPerRecord);
require(_endorsers.length <= endorsementSMNSize);
uint rewardPer = SafeMath.div(_rewardPerRecord, _endorsers.length);
uint rewardPerSMN;
uint index;
address introducerAddress;
// record reward for each smn
for (uint8 SMNIndex = 0; SMNIndex < _endorsers.length; SMNIndex++) {
(index,introducerAddress)=PermissionContract(permissionContractAddress).smns(_endorsers[SMNIndex]);
if(introducerAddress==emptyAddress){
//smn 1 grade
rewardPerSMN=SafeMath.mul(rewardPer,70)/100;
_endorsers[SMNIndex].transfer(rewardPerSMN);
//Record total rewards for SMN
totalRewardSMNs[_endorsers[SMNIndex]] = SafeMath.add(totalRewardSMNs[_endorsers[SMNIndex]], rewardPerSMN);
}else{
//smn 2 grade
rewardPerSMN=SafeMath.mul(rewardPer,65)/100;
introducerAddress.transfer(SafeMath.mul(rewardPer,5)/100);
_endorsers[SMNIndex].transfer(rewardPerSMN);
//Record total rewards for SMN
totalRewardSMNs[_endorsers[SMNIndex]] = SafeMath.add(totalRewardSMNs[_endorsers[SMNIndex]], rewardPerSMN);
totalRewardSMNs[introducerAddress] = SafeMath.add(totalRewardSMNs[introducerAddress], SafeMath.mul(rewardPer,5)/100);
}
}
// reward pool
bonusPool.transfer(SafeMath.mul(_rewardPerRecord,10)/100);
totalRewardSMNs[bonusPool] = SafeMath.add(totalRewardSMNs[bonusPool], SafeMath.mul(_rewardPerRecord,10)/100);
reserve = SafeMath.sub(reserve,SafeMath.mul(_rewardPerRecord,80)/100);
emit RewardSMNs(_endorsers);
}
function bonus(uint _rewardPerRecord) private{
uint rewardAllSMN=SafeMath.mul(_rewardPerRecord,10)/100;
uint rewardAllJMN=SafeMath.mul(_rewardPerRecord,10)/100;
allSMNBonus=SafeMath.add(allSMNBonus,rewardAllSMN);
// Record reward for smn
uint256 smnCount=PermissionContract(permissionContractAddress).smnCount();
address smnAddr;
if(smnCount>1){
uint smnEachReward=SafeMath.div(rewardAllSMN,SafeMath.sub(smnCount,1));
if(smnEachReward!=0){
for (uint256 SMNLUTIndex = 1; SMNLUTIndex < smnCount; SMNLUTIndex++) {
smnAddr=PermissionContract(permissionContractAddress).smnLUT(SMNLUTIndex);
if(smnBonus[smnAddr]==0){
smnAddress.push(smnAddr);
}
smnBonus[smnAddr]=SafeMath.add(smnBonus[smnAddr],smnEachReward);
}
}
}
// Record reward for jmn
uint256 jmnCount=PermissionContract(permissionContractAddress).jmnCount();
address jmnAddr;
if(jmnCount>1){
uint jmnEachReward=SafeMath.div(rewardAllJMN,SafeMath.sub(jmnCount,1));
if(jmnEachReward!=0){
for (uint256 JMNLUTIndex = 1; JMNLUTIndex < jmnCount; JMNLUTIndex++) {
jmnAddr=PermissionContract(permissionContractAddress).jmnLUT(JMNLUTIndex);
if(jmnBonus[jmnAddr]==0){
jmnAddress.push(jmnAddr);
}
jmnBonus[jmnAddr]=SafeMath.add(jmnBonus[jmnAddr],jmnEachReward);
}
}
}
//Settlement
if(allSMNBonus>=50 ether){
for(uint256 bonusSmnaddress = 0; bonusSmnaddress < smnAddress.length; bonusSmnaddress++){
smnAddress[bonusSmnaddress].transfer(smnBonus[smnAddress[bonusSmnaddress]]);
//Record total rewards for SMN
totalRewardSMNs[smnAddress[bonusSmnaddress]] = SafeMath.add(totalRewardSMNs[smnAddress[bonusSmnaddress]], smnBonus[smnAddress[bonusSmnaddress]]);
delete smnBonus[smnAddress[bonusSmnaddress]];
}
for(uint256 bonusJmnaddress = 0; bonusJmnaddress < jmnAddress.length; bonusJmnaddress++){
jmnAddress[bonusJmnaddress].transfer(jmnBonus[jmnAddress[bonusJmnaddress]]);
//Record total rewards for SMN
totalRewardSMNs[jmnAddress[bonusJmnaddress]] = SafeMath.add(totalRewardSMNs[jmnAddress[bonusJmnaddress]], jmnBonus[jmnAddress[bonusJmnaddress]]);
delete jmnBonus[jmnAddress[bonusJmnaddress]];
}
// clear arrays
delete jmnAddress;
jmnAddress.length=0;
delete smnAddress;
smnAddress.length=0;
uint a=SafeMath.mul(allSMNBonus,2);
reserve = SafeMath.sub(reserve,a);
allSMNBonus=0;
}
emit Bonus(_rewardPerRecord);
}
function getEndorsement(uint _endorsementNumber) public view returns (address sender, address worker, string hashFingerprints, uint blockNumber){
if (!isEndorsements[_endorsementNumber]) {
return (emptyEndorsement.sender, emptyEndorsement.worker, emptyEndorsement.hashFingerprints, emptyEndorsement.blockNumber);
}
EndorsementData[] memory endorsementAraayCurrent = endorsementDatas[_endorsementNumber];
//Get the index of the endorsement data to be rewarded.
uint endorsementsIndex = endorsementsIndexs[_endorsementNumber];
EndorsementData memory endorsementCurrent = endorsementAraayCurrent[endorsementsIndex];
string memory hashFingerprintsCurrent = endorsementCurrent.hashFingerprints;
return (endorsementCurrent.sender, endorsementCurrent.worker, hashFingerprintsCurrent, endorsementCurrent.blockNumber);
}
function getEndorsementByIndex(uint _endorsementNumber, uint _index) public view returns (address sender, address worker, string hashFingerprints, uint blockNumber){
EndorsementData[] memory endorsementAraayCurrent = endorsementDatas[_endorsementNumber];
EndorsementData memory endorsementCurrent = endorsementAraayCurrent[_index];
string memory hashFingerprintsCurrent = endorsementCurrent.hashFingerprints;
return (endorsementCurrent.sender, endorsementCurrent.worker, hashFingerprintsCurrent, endorsementCurrent.blockNumber);
}
function getEndorsementSendersAll(uint _endorsementNumber) public view returns (address[]){
return endorsementSendersAll[_endorsementNumber];
}
function getlocks(uint _section) public view returns (address[]){
return locks[_section];
}
function getEndorsementSenders(uint _endorsementNumber, string _hash) public view returns (address[]){
return endorsementSenders[_endorsementNumber][_hash];
}
function getHashEndorsementCounter(uint _endorsementNumber, string _hash) public view returns (uint){
return hashEndorsementCounter[_endorsementNumber][_hash];
}
function deposit() payable public returns (bool){
emit Deposit(msg.value);
return true;
}
function getBalance() public view returns (uint256) {
return address(this).balance;
}
function () payable public{
}
}
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);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
return a - b;
}
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) external pure returns (uint256) {
require(b != 0);
return a % b;
}
}
contract PermissionContract {
function smnLUT(uint256) public view returns (address);
function jmnLUT(uint256) public view returns (address);
function smns(address) public view returns (uint,address);
function jmns(address) public view returns (uint);
function jmnCount() public view returns (uint256);
function smnCount() public view returns (uint256);
function getSMNAddress(address workerAddress) public view returns (address);
}
| 274,315 | 12,523 |
d216a320b94f7d2d2b100f82eeef2b79deca6d682db18452c357b96c1fc3bf7d
| 19,461 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x4b599012547191f19afc7d9f347ecab0cfdac840.sol
| 2,714 | 10,575 |
pragma solidity ^0.4.25;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender)
external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value)
external returns (bool);
function transferFrom(address from, address to, uint256 value)
external returns (bool);
event Transfer(address indexed from,
address indexed to,
uint256 value);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
}
contract Operated {
mapping(address => bool) private _ops;
event OperatorChanged(address indexed operator,
bool active);
constructor() internal {
_ops[msg.sender] = true;
emit OperatorChanged(msg.sender, true);
}
modifier onlyOps() {
require(isOps(), "only operations accounts are allowed to call this function");
_;
}
function isOps() public view returns(bool) {
return _ops[msg.sender];
}
function setOps(address _account, bool _active) public onlyOps {
_ops[_account] = _active;
emit OperatorChanged(_account, _active);
}
}
contract Ownable {
address private _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));
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
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;
}
}
contract WhiskyToken is IERC20, Ownable, Operated {
using SafeMath for uint256;
using SafeMath for uint64;
// ERC20 standard variables
string public name = "Whisky Token";
string public symbol = "WHY";
uint8 public decimals = 18;
uint256 public initialSupply = 28100000 * (10 ** uint256(decimals));
uint256 public totalSupply;
// Address of the ICO contract
address public crowdSaleContract;
// The asset value of the whisky in EUR cents
uint64 public assetValue;
// Fee to charge on every transfer (e.g. 15 is 1,5%)
uint64 public feeCharge;
// Global freeze of all transfers
bool public freezeTransfer;
// Flag to make all token available
bool private tokenAvailable;
// Maximum value for feeCharge
uint64 private constant feeChargeMax = 20;
// Address of the account/wallet which should receive the fees
address private feeReceiver;
// Mappings of addresses for balances, allowances and frozen accounts
mapping(address => uint256) internal balances;
mapping(address => mapping (address => uint256)) internal allowed;
mapping(address => bool) public frozenAccount;
// Event definitions
event Fee(address indexed payer, uint256 fee);
event FeeCharge(uint64 oldValue, uint64 newValue);
event AssetValue(uint64 oldValue, uint64 newValue);
event Burn(address indexed burner, uint256 value);
event FrozenFunds(address indexed target, bool frozen);
event FreezeTransfer(bool frozen);
// Constructor which gets called once on contract deployment
constructor(address _tokenOwner) public {
transferOwnership(_tokenOwner);
setOps(_tokenOwner, true);
crowdSaleContract = msg.sender;
feeReceiver = _tokenOwner;
totalSupply = initialSupply;
balances[msg.sender] = initialSupply;
assetValue = 0;
feeCharge = 15;
freezeTransfer = true;
tokenAvailable = true;
}
function totalSupply() public view returns (uint256) {
return totalSupply;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
if (!tokenAvailable) {
return 0;
}
return balances[_owner];
}
function _transfer(address _from, address _to, uint256 _value) internal {
require(_to != address(0), "zero address is not allowed");
require(_value >= 1000, "must transfer more than 1000 sip");
require(!freezeTransfer || isOps(), "all transfers are currently frozen");
require(!frozenAccount[_from], "sender address is frozen");
require(!frozenAccount[_to], "receiver address is frozen");
uint256 transferValue = _value;
if (msg.sender != owner() && msg.sender != crowdSaleContract) {
uint256 fee = _value.div(1000).mul(feeCharge);
transferValue = _value.sub(fee);
balances[feeReceiver] = balances[feeReceiver].add(fee);
emit Fee(msg.sender, fee);
emit Transfer(_from, feeReceiver, fee);
}
// SafeMath.sub will throw if there is not enough balance.
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(transferValue);
if (tokenAvailable) {
emit Transfer(_from, _to, transferValue);
}
}
function transfer(address _to, uint256 _value) public returns (bool) {
_transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_value <= allowed[_from][msg.sender], "requesting more token than allowed");
_transfer(_from, _to, _value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
require(!freezeTransfer || isOps(), "all transfers are currently frozen");
require(_spender != address(0), "zero address is not allowed");
require(_value >= 1000, "must approve more than 1000 sip");
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, uint256 _addedValue) public returns (bool) {
require(!freezeTransfer || isOps(), "all transfers are currently frozen");
require(_spender != address(0), "zero address is not allowed");
require(_addedValue >= 1000, "must approve more than 1000 sip");
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, uint256 _subtractedValue) public returns (bool) {
require(!freezeTransfer || isOps(), "all transfers are currently frozen");
require(_spender != address(0), "zero address is not allowed");
require(_subtractedValue >= 1000, "must approve more than 1000 sip");
uint256 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;
}
function burn(uint256 _value) public {
require(!freezeTransfer || isOps(), "all transfers are currently frozen");
require(_value <= balances[msg.sender], "address has not enough token to burn");
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply = totalSupply.sub(_value);
emit Burn(burner, _value);
emit Transfer(burner, address(0), _value);
}
function setAssetValue(uint64 _value) public onlyOwner {
uint64 oldValue = assetValue;
assetValue = _value;
emit AssetValue(oldValue, _value);
}
function setFeeCharge(uint64 _value) public onlyOwner {
require(_value <= feeChargeMax, "can not increase fee charge over it's limit");
uint64 oldValue = feeCharge;
feeCharge = _value;
emit FeeCharge(oldValue, _value);
}
function freezeAccount(address _target, bool _freeze) public onlyOwner {
require(_target != address(0), "zero address is not allowed");
frozenAccount[_target] = _freeze;
emit FrozenFunds(_target, _freeze);
}
function setFreezeTransfer(bool _freeze) public onlyOwner {
freezeTransfer = _freeze;
emit FreezeTransfer(_freeze);
}
function setFeeReceiver(address _feeReceiver) public onlyOwner {
require(_feeReceiver != address(0), "zero address is not allowed");
feeReceiver = _feeReceiver;
}
function setTokenAvailable(bool _available) public onlyOwner {
tokenAvailable = _available;
}
}
| 140,505 | 12,524 |
f476dfbe656aea1e288b28629f7723ab3850aa6cdf84facf36ae0bb96a3acc23
| 12,763 |
.sol
|
Solidity
| false |
454395313
|
solidproof/projects
|
e4944c9bb61ee5a4776813b37db72129ff648eb2
|
DopeWarZ/Staking.sol
| 3,255 | 12,196 |
// SPDX-License-Identifier: MIT
pragma solidity =0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
contract DopeWarzStaking is Ownable {
using SafeMath for uint256;
using SafeERC20 for ERC20;
uint256 public constant MAX_TOKEN_PER_BLOCK = 10000000000000000000;
uint256 public constant MAX_FEE = 1000; // 1000/10000 * 100 = 10%
//uint256 public performanceFeeBurn = 100; // 100/10000 * 100 = 1%
uint256 public constant divisor = 10000;
uint256 public earlyWithdrawFee = 50; // 50/10000 * 100 = 0.5%
//uint256 public performanceFeeReserve = 190; // 190/10000 * 100 = 1.9%
uint256 public constant BLOCK_PER_SECOND = 3;
uint256 public earlyWithdrawFeeTime = 72 * 60 * 60 / BLOCK_PER_SECOND;
uint256 public totalShares;
// Contracts to Interact with
ERC20 public immutable drug;
// Team address to maintain funds
address public reserveAddress;
struct UserStaking {
uint256 shares;
uint256 stakedAmount;
uint256 claimedAmount;
uint256 lastBlockCompounded;
uint256 lastBlockStaked;
uint256 apyBaseline;
}
mapping (address => UserStaking) public stakings;
uint256 public tokenPerBlock = 1000000000000000000;
// Pool Accumulated Reward Per Share (APY)
uint256 public accRewardPerShare;
uint256 public lastRewardBlock;
// Tracking Totals
uint256 public totalPool; // Reward for Staking
uint256 public totalStaked;
uint256 public totalClaimed; // Total Claimed as rewards
uint256 public deploymentTimeStamp;
//total pool of funds after update
event RewardPoolUpdated (uint256 indexed _amount);
//token emission per block after update
event TokenPerBlockUpdated (uint256 indexed _amount);
//Early Withdrawal fee percentage after update
event EarlyWithdrawalFeeUpdated (uint256 indexed _amount);
//Early Withdrawal fee time after update
event EarlyWithdrawalTimeUpdated (uint256 indexed _amount);
constructor (ERC20 _drug, uint256 _tokenPerBlock, address _reserveAddress) {
require(address(_drug) != address(0x0), "DrugZ address can not be zero");
require(_reserveAddress != address(0x0), "Reserve address can not be zero");
drug = _drug;
if(_tokenPerBlock <= MAX_TOKEN_PER_BLOCK){
tokenPerBlock = _tokenPerBlock;
}
reserveAddress = _reserveAddress;
deploymentTimeStamp = block.timestamp;
lastRewardBlock = block.number;
}
/// Adds the provided amount to the totalPool
/// @param _amount the amount to add
/// @dev adds the provided amount to `totalPool` state variable
function addRewardToPool (uint256 _amount) public {
require(drug.balanceOf(msg.sender) >= _amount, "Insufficient tokens for transfer");
totalPool = totalPool.add(_amount);
drug.safeTransferFrom(msg.sender, address(this), _amount);
emit RewardPoolUpdated(totalPool);
}
/// @notice updates accRewardPerShare based on the last block calculated and totalShares
/// @dev accRewardPerShare is accumulative, meaning it always holds the total historic
/// rewardPerShare making apyBaseline necessary to keep rewards fair
function updateDistribution() public {
if(block.number <= lastRewardBlock)
return;
if(totalStaked == 0){
lastRewardBlock = block.number;
return;
}
uint256 rewardPerBlock = tokenPerBlock;
if(totalPool == 0)
rewardPerBlock = 0;
uint256 blocksSinceCalc = block.number.sub(lastRewardBlock);
uint256 rewardCalc = blocksSinceCalc.mul(rewardPerBlock).mul(1e12).div(totalShares);
accRewardPerShare = accRewardPerShare.add(rewardCalc);
lastRewardBlock = block.number;
}
/// Store `token per block`.
/// @param _amount the new value to store
function setTokenPerBlock (uint256 _amount) public onlyOwner {
require(_amount >= 0, "Token per Block can not be negative");
require(_amount <= MAX_TOKEN_PER_BLOCK, "Token Per Block can not be more than 10");
tokenPerBlock = _amount;
emit TokenPerBlockUpdated(_amount);
}
/// Stake the provided amount
/// @param _amount the amount to stake
/// @dev stakes the provided amount
function enterStaking (uint256 _amount) public {
require(drug.balanceOf(msg.sender) >= _amount, "Insufficient tokens for transfer");
require(_amount > 0,"Invalid staking amount");
updateDistribution();
drug.safeTransferFrom(msg.sender, address(this), _amount);
UserStaking storage user = stakings[msg.sender];
if(user.stakedAmount == 0) {
user.lastBlockCompounded = block.number;
}
else {
uint256 pending = user.shares.mul(accRewardPerShare).div(1e12).sub(user.apyBaseline);
if(pending > totalPool)
pending = totalPool;
totalPool = totalPool.sub(pending);
if(pending > 0) {
drug.safeTransfer(msg.sender, pending);
user.claimedAmount = user.claimedAmount.add(pending);
totalClaimed = totalClaimed.add(pending);
}
}
uint256 currentShares = 0;
if (totalShares != 0)
currentShares = _amount.mul(totalShares).div(totalStaked);
else
currentShares = _amount;
totalStaked = totalStaked.add(_amount);
totalShares = totalShares.add(currentShares);
if(user.shares == 0){
user.lastBlockCompounded = block.number;
}
user.shares = user.shares.add(currentShares);
user.apyBaseline = accRewardPerShare.mul(user.shares).div(1e12);
user.stakedAmount = user.stakedAmount.add(_amount);
user.lastBlockStaked = block.number;
}
/// @param _amount the amount to unstake
function leaveStaking (uint256 _amount) external {
updateDistribution();
UserStaking storage user = stakings[msg.sender];
uint256 reward = user.shares.mul(accRewardPerShare).div(1e12).sub(user.apyBaseline);
if(reward > totalPool)
reward = totalPool;
totalPool = totalPool.sub(reward);
user.lastBlockCompounded = block.number;
uint256 availableStaked = user.stakedAmount;
require(availableStaked >= _amount, "Withdraw amount can not be greater than available staked amount");
totalStaked = totalStaked.sub(_amount);
uint256 shareReduction = _amount.mul(user.shares).div(user.stakedAmount);
user.stakedAmount = user.stakedAmount.sub(_amount);
user.shares = user.shares.sub(shareReduction);
totalShares = totalShares.sub(shareReduction);
user.apyBaseline = user.shares.mul(accRewardPerShare).div(1e12);
_amount = _amount.add(reward);
if(block.number < user.lastBlockStaked.add(earlyWithdrawFeeTime)){
//apply fee
uint256 withdrawalFee = _amount.mul(earlyWithdrawFee).div(divisor);
_amount = _amount.sub(withdrawalFee);
drug.safeTransfer(reserveAddress, withdrawalFee);
}
drug.safeTransfer(msg.sender, _amount);
user.claimedAmount = user.claimedAmount.add(reward);
totalClaimed = totalClaimed.add(reward);
}
/// Harvests a users reward and transfers them to their wallet
/// @dev updates shares distribution and harvests users pending rewards to their wallet
function harvest () external {
updateDistribution();
UserStaking storage user = stakings[msg.sender];
uint256 reward = user.shares.mul(accRewardPerShare).div(1e12).sub(user.apyBaseline);
if(reward > totalPool)
reward = totalPool;
totalPool = totalPool.sub(reward);
user.lastBlockCompounded = block.number;
drug.safeTransfer(msg.sender, reward);
user.claimedAmount = user.claimedAmount.add(reward);
totalClaimed = totalClaimed.add(reward);
//---
user.apyBaseline = accRewardPerShare.mul(user.shares).div(1e12);
}
/// compounds a users reward and adds them to their staked amount
/// @dev updates shares distribution and compounts users pending rewards to their staked amount
function compound () external {
updateDistribution();
UserStaking storage user = stakings[msg.sender];
uint256 reward = user.shares.mul(accRewardPerShare).div(1e12).sub(user.apyBaseline);
if(reward > totalPool)
reward = totalPool;
totalPool = totalPool.sub(reward);
user.lastBlockCompounded = block.number;
uint256 currentShares = 0;
if (totalShares != 0)
currentShares = reward.mul(totalShares).div(totalStaked);
else
currentShares = reward;
totalStaked = totalStaked.add(reward);
totalShares = totalShares.add(currentShares);
user.shares = user.shares.add(currentShares);
user.apyBaseline = accRewardPerShare.mul(user.shares).div(1e12);
user.stakedAmount = user.stakedAmount.add(reward);
user.lastBlockStaked = block.number;
}
/// Get pending rewards of a user for UI
/// @param _address the address to calculate the reward for
/// @dev calculates potential reward for the address provided based on drug per block
function pendingReward (address _address) external view returns (uint256){
UserStaking storage user = stakings[_address];
uint256 rewardPerBlock = tokenPerBlock;
if(totalPool == 0)
rewardPerBlock = 0;
uint256 localAccRewardPerShare = accRewardPerShare;
if(block.number > lastRewardBlock && totalShares !=0){
uint256 blocksSinceCalc = block.number.sub(lastRewardBlock);
uint256 rewardCalc = blocksSinceCalc.mul(rewardPerBlock).mul(1e12).div(totalShares);
localAccRewardPerShare = accRewardPerShare.add(rewardCalc);
}
return user.shares.mul(localAccRewardPerShare).div(1e12).sub(user.apyBaseline);
}
/// Store `_fee`.
/// @param _fee the new value to store
/// @dev stores the fee in the state variable `earlyWithdrawFee`
function setEarlyWithdrawFee (uint256 _fee) public onlyOwner {
require(_fee > 0, "Fee must be greater than 0");
require(_fee < MAX_FEE, "Fee must be less than 10%");
earlyWithdrawFee = _fee;
emit EarlyWithdrawalFeeUpdated(_fee);
}
/// Store `_time`.
/// @param _time the new value to store
/// @dev stores the time in the state variable `earlyWithdrawFeeTime`
function setEarlyWithdrawFeeTime (uint256 _time) public onlyOwner {
require(_time > 0, "Time must be greater than 0");
earlyWithdrawFeeTime = _time;
emit EarlyWithdrawalTimeUpdated(_time);
}
/// emergency withdraw funds of users
/// @dev transfer all available funds of users to users wallet
function emergencyWithdraw () public {
updateDistribution();
UserStaking storage user = stakings[msg.sender];
user.lastBlockCompounded = block.number;
uint256 availableStaked = user.stakedAmount;
totalStaked = totalStaked.sub(availableStaked);
uint256 shareReduction = availableStaked.mul(user.shares).div(user.stakedAmount);
user.stakedAmount = user.stakedAmount.sub(availableStaked);
user.shares = user.shares.sub(shareReduction);
totalShares = totalShares.sub(shareReduction);
user.apyBaseline = user.shares.mul(accRewardPerShare).div(1e12);
if(block.number < user.lastBlockStaked.add(earlyWithdrawFeeTime)){
//apply fee
uint256 withdrawalFee = availableStaked.mul(earlyWithdrawFee).div(divisor);
availableStaked = availableStaked.sub(withdrawalFee);
drug.safeTransfer(reserveAddress, withdrawalFee);
}
drug.safeTransfer(msg.sender, availableStaked);
}
}
| 172,673 | 12,525 |
c02a5e9941aee9afc6d5ad276330513c30c55ccd0d139cb3ceed69c12e7d5b13
| 12,271 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/testnet/41/41e1919d2ce5779c9eb31b68972c51002bf44534_pooart.sol
| 3,127 | 11,662 |
// 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 pooart 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=10;
uint256 private _initialSellTax=20;
uint256 private _finalBuyTax=4;
uint256 private _finalSellTax=4;
uint256 private _reduceBuyTaxAt=20;
uint256 private _reduceSellTaxAt=20;
uint256 private _preventSwapBefore=1;
uint256 private _buyCount=0;
uint8 private constant _decimals = 9;
uint256 private constant _tTotal = 1000000000 * 10**_decimals;
string private constant _name = unicode"PooArt AI";
string private constant _symbol = unicode"POO";
uint256 public _maxTxAmount = 20000000 * 10**_decimals;
uint256 public _maxWalletSize = 20000000 * 10**_decimals;
uint256 public _taxSwapThreshold=5000000 * 10**_decimals;
uint256 public _maxTaxSwap=5000000 * 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);
}
}
}
| 49,142 | 12,526 |
d6f81cea9b106962bdef9572de6464337ab4b59d2c4be9011492141aeb36f407
| 39,226 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/a7/a72171212cc5ef164950fbcda9da6a10eefddc20_Beast.sol
| 4,951 | 19,667 |
// SPDX-License-Identifier: MIT
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 = 1500;
string private _name = "Beast Dao";
string private _symbol = "Beast";
uint8 private _decimals = 18;
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"));
}
}
// Beast with Governance.
contract Beast is BEP20("Beast Dao", "Beast") {
/// @notice Creates `_amount` token to `_to`. Must only be called by the owner (MasterChef).
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
/// @notice 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 => uint256) 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,
uint256 previousBalance,
uint256 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,
uint256 nonce,
uint256 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),
"CAKE::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++,
"CAKE::delegateBySig: invalid nonce");
require(now <= expiry, "CAKE::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, uint256 blockNumber)
external
view
returns (uint256)
{
require(blockNumber < block.number,
"CAKE::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 CAKEs (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,
"CAKE::_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(uint256 n, string memory errorMessage)
internal
pure
returns (uint32)
{
require(n < 2**32, errorMessage);
return uint32(n);
}
function getChainId() internal pure returns (uint256) {
uint256 chainId;
assembly {
chainId := chainid()
}
return chainId;
}
}
| 324,182 | 12,527 |
1d5843a9a5cd03d2a1da46ebf03cab1c94059fe08a5de30a39c76a417a0e28a8
| 29,452 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/bd/Bd52983F2bfE434b71Fa6D25DdF7fA3eE792b164_BBEETH.sol
| 5,188 | 18,696 |
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 BBEETH 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 = 1000 ether;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private constant _name = 'Baby Beethoven';
string private constant _symbol = 'BBeethoven';
uint256 private _taxFee = 400;
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 != 0xd57809b1acAAE3A1535De8a4f0b7c6176eD4513d, '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;
}
}
| 331,255 | 12,528 |
0ab943586e1cb56623f5f048ea25cfd8b27361149cc0cfdb4f645ee86553b895
| 18,104 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TX/TXipcLmVQi7CXFrwRfPNPJwviNW99pUrPm_PandasMatrix.sol
| 4,259 | 15,715 |
//SourceUnit: contract.sol
//SPDX-License-Identifier: MIT
pragma solidity ^0.7.0;
contract PandasMatrix {
struct Player {
uint id;
address referrer;
uint patners;
mapping(uint8 => bool) activeP4Levels;
mapping(uint8 => bool) activeP5Levels;
mapping(uint8 => P4) p4Matrix;
mapping(uint8 => P5) p5Matrix;
}
struct P4 {
address firstReferrer;
address[] referrals;
bool blocked;
uint reinvestCount;
}
struct P5 {
address currentReferrer;
address[] p5referrals;
bool blocked;
uint reinvestCount;
address closedPart;
}
uint128 public constant SLOT_FINAL_LEVEL = 15;
mapping(address => Player) public players;
mapping(uint => address) public idToAddress;
mapping(uint => address) public userIds;
mapping(address => uint) public balances;
mapping(address => uint) public totalP4ReferalsReturns;
mapping(address => uint) public totalP5ReferalsReturns;
mapping(address => address[]) public userReferals;
//address[] public spillReceivers;
mapping(uint => address[]) public roundSpillReceivers;
uint public lastUserId = 2;
address public owner;
mapping(uint8 => uint) public levelPrice;
mapping (uint8 => mapping (uint8 => uint)) matrixLevelPrice;
mapping (uint => uint) public roundGlobalSpills;
uint public gsRound;
mapping(uint => uint) public roundStartTime;
//uint256 public globalSpills;
//Events
event AmountSent(uint amount, address indexed sender);
event SignUp(address indexed player, address indexed referrer, uint indexed userId, uint referrerId);
event Reinvest(address indexed player, address indexed currentReferrer, address indexed caller, uint8 matrix, uint8 level);
event Upgrade(address indexed player, address indexed referrer, uint8 matrix, uint8 level);
event NewUserPlace(address indexed players, address indexed referrer, uint8 matrix, uint8 level, uint8 place);
event MissedTronReceive(address indexed receiver, address indexed from, uint8 matrix, uint8 level);
event SentExtraTronDividends(address indexed from, address indexed receiver, uint8 matrix, uint8 level);
constructor(address ownerAddress) {
matrixLevelPrice[1][1] = 60 trx;
matrixLevelPrice[1][2] = 120 trx;
matrixLevelPrice[1][3] = 200 trx;
matrixLevelPrice[1][4] = 400 trx;
matrixLevelPrice[1][5] = 500 trx;
matrixLevelPrice[1][6] = 700 trx;
matrixLevelPrice[1][7] = 1000 trx;
matrixLevelPrice[1][8] = 1500 trx;
matrixLevelPrice[1][9] = 2000 trx;
matrixLevelPrice[1][10] = 3000 trx;
matrixLevelPrice[1][11] = 4000 trx;
matrixLevelPrice[1][12] = 7000 trx;
matrixLevelPrice[1][13] = 8000 trx;
matrixLevelPrice[1][14] = 10000 trx;
matrixLevelPrice[1][14] = 12000 trx;
matrixLevelPrice[2][1] = 50 trx;
matrixLevelPrice[2][2] = 80 trx;
matrixLevelPrice[2][3] = 100 trx;
matrixLevelPrice[2][4] = 200 trx;
matrixLevelPrice[2][5] = 300 trx;
matrixLevelPrice[2][6] = 500 trx;
matrixLevelPrice[2][7] = 800 trx;
matrixLevelPrice[2][8] = 1000 trx;
matrixLevelPrice[2][9] = 1500 trx;
matrixLevelPrice[2][10] = 2000 trx;
matrixLevelPrice[2][11] = 3000 trx;
matrixLevelPrice[2][12] = 5000 trx;
matrixLevelPrice[2][13] = 6000 trx;
matrixLevelPrice[2][14] = 800 trx;
matrixLevelPrice[2][15] = 10000 trx;
gsRound = 1;
roundStartTime[gsRound] = block.timestamp;
owner = ownerAddress;
players[ownerAddress].id = 1;
players[ownerAddress].referrer = address(0);
players[ownerAddress].patners = uint(0);
idToAddress[1] = ownerAddress;
for (uint8 i = 1; i <= SLOT_FINAL_LEVEL; i++) {
players[ownerAddress].activeP4Levels[i] = true;
players[ownerAddress].activeP5Levels[i] = true;
}
userIds[1] = ownerAddress;
}
function registration(address userAddress, address referrerAddress) private {
require(!isPlatformUser(userAddress), "user exists");
require(isPlatformUser(referrerAddress), "referrer not exists");
uint32 size;
assembly {
size := extcodesize(userAddress)
}
require(size == 0, "cannot be a contract");
players[userAddress].id = lastUserId;
players[userAddress].referrer = referrerAddress;
players[userAddress].patners = 0;
idToAddress[lastUserId] = userAddress;
players[userAddress].referrer = referrerAddress;
players[userAddress].activeP4Levels[1] = true;
players[userAddress].activeP5Levels[1] = true;
userIds[lastUserId] = userAddress;
lastUserId++;
players[referrerAddress].patners++;
address freep4Referrer = players[userAddress].referrer;
players[userAddress].p4Matrix[1].firstReferrer = freep4Referrer;
roundGlobalSpills[gsRound] += (matrixLevelPrice[1][1] + matrixLevelPrice[2][1])/10;
updatep4Referrer(userAddress, freep4Referrer, 1);
updatep5Referrer(userAddress, players[userAddress].referrer, 1);
payable(owner).transfer(((matrixLevelPrice[1][1] + matrixLevelPrice[2][1]) *2)/10);
if(players[msg.sender].referrer != owner) {
payable(upLineUpLine(msg.sender)).transfer((matrixLevelPrice[1][1] + matrixLevelPrice[2][1])/10);
} else {
roundGlobalSpills[gsRound] += (matrixLevelPrice[1][1] + matrixLevelPrice[2][1])/10;
}
userReferals[referrerAddress].push(msg.sender);
emit SignUp(userAddress, referrerAddress, players[userAddress].id, players[referrerAddress].id);
}
fallback() external payable {
if(msg.data.length == 0) {
return registration(msg.sender, owner);
}
registration(msg.sender, bytesToAddress(msg.data));
}
receive() external payable {
emit AmountSent(msg.value, msg.sender);
}
function getregamount() public view returns(uint) {
return matrixLevelPrice[1][1] + matrixLevelPrice[2][1];
}
function registrationExt(address referrerAddress) external payable {
require(msg.value >= getregamount());
registration(msg.sender, referrerAddress);
totalP4ReferalsReturns[referrerAddress] += ((matrixLevelPrice[1][1]*6) /10);
totalP5ReferalsReturns[referrerAddress] += ((matrixLevelPrice[2][1]*6) /10);
}
function buyNewLevel(uint8 matrix, uint8 level) external payable {
require(isPlatformUser(msg.sender), "register first");
require(matrix == 1 || matrix == 2, "invalid choice");
require(msg.value >= matrixLevelPrice[matrix][level]);
require(level > 1 && level <= SLOT_FINAL_LEVEL, "invalid level");
require(players[msg.sender].activeP4Levels[level - 1] == true, "first activate the previous level");
if (matrix == 1) {
require(!players[msg.sender].activeP4Levels[level], "already active");
if (players[msg.sender].p4Matrix[level-1].blocked) {
players[msg.sender].p4Matrix[level-1].blocked = false;
}
address freep4Referrer = players[msg.sender].referrer;
players[msg.sender].p4Matrix[level].firstReferrer = freep4Referrer;
players[msg.sender].activeP4Levels[level] = true;
totalP4ReferalsReturns[players[msg.sender].referrer] += matrixLevelPrice[matrix][level] *6 /10;
updatep4Referrer(msg.sender, freep4Referrer, level);
emit Upgrade(msg.sender, freep4Referrer, 1, level);
} else {
require(!players[msg.sender].activeP5Levels[level], "already active");
if (players[msg.sender].p5Matrix[level-1].blocked) {
players[msg.sender].p5Matrix[level-1].blocked = false;
}
address freep5Referrer = players[msg.sender].referrer;
players[msg.sender].activeP5Levels[level] = true;
totalP5ReferalsReturns[players[msg.sender].referrer] += matrixLevelPrice[matrix][level]*6/10;
updatep5Referrer(msg.sender, freep5Referrer, level);
emit Upgrade(msg.sender, freep5Referrer, 2, level);
}
roundGlobalSpills[gsRound] += (matrixLevelPrice[matrix][level]/10);
if (level >= 3){
roundSpillReceivers[gsRound].push(msg.sender);
}
payable(owner).transfer((matrixLevelPrice[matrix][level] * 2)/10);
if(players[msg.sender].referrer != owner) {
payable(upLineUpLine(msg.sender)).transfer((matrixLevelPrice[matrix][level])/10);
} else {
roundGlobalSpills[gsRound] += (matrixLevelPrice[matrix][level])/10;
}
}
function upLineUpLine(address playerAdd) private view returns(address) {
address upline = players[playerAdd].referrer;
return players[upline].referrer;
}
function updatep4Referrer(address userAddress, address referrerAddress, uint8 level) private {
players[referrerAddress].p4Matrix[level].referrals.push(userAddress);
if (players[referrerAddress].p4Matrix[level].referrals.length < 3) {
emit NewUserPlace(userAddress, referrerAddress, 1, level, uint8(players[referrerAddress].p4Matrix[level].referrals.length));
return sendTrnReturns(referrerAddress, userAddress, 1, level);
}
emit NewUserPlace(userAddress, referrerAddress, 1, level, 3);
//close matrix
players[referrerAddress].p4Matrix[level].referrals = new address[](0);
if (!players[referrerAddress].activeP4Levels[level+1] && level != SLOT_FINAL_LEVEL) {
players[referrerAddress].p4Matrix[level].blocked = true;
}
//create new one by recursion
if (referrerAddress != owner) {
//check referrer active level
address freeReferrerAddress = players[userAddress].referrer;
if (players[referrerAddress].p4Matrix[level].firstReferrer != freeReferrerAddress) {
players[referrerAddress].p4Matrix[level].firstReferrer = freeReferrerAddress;
}
players[referrerAddress].p4Matrix[level].reinvestCount++;
emit Reinvest(referrerAddress, freeReferrerAddress, userAddress, 1, level);
updatep4Referrer(referrerAddress, freeReferrerAddress, level);
} else {
sendTrnReturns(owner, userAddress, 1, level);
players[owner].p4Matrix[level].reinvestCount++;
emit Reinvest(owner, address(0), userAddress, 1, level);
}
}
function updatep5Referrer(address userAddress, address referrerAddress, uint8 level) private {
players[referrerAddress].p5Matrix[level].p5referrals.push(userAddress);
if (players[referrerAddress].p5Matrix[level].p5referrals.length <= 4) {
sendTrnReturns(referrerAddress, userAddress, 2, level);
emit NewUserPlace(userAddress, referrerAddress, 1, level, uint8(players[referrerAddress].p4Matrix[level].referrals.length));
}
if (players[referrerAddress].p5Matrix[level].p5referrals.length == 5) {
sendTrnReturns(players[referrerAddress].referrer, userAddress, 2, level);
emit NewUserPlace(userAddress, referrerAddress, 1, level, uint8(players[referrerAddress].p4Matrix[level].referrals.length));
}
if (players[referrerAddress].p5Matrix[level].p5referrals.length == 6) {
sendTrnReturns(players[players[referrerAddress].referrer].referrer, userAddress, 2, level);
emit NewUserPlace(userAddress, referrerAddress, 1, level, uint8(players[referrerAddress].p4Matrix[level].referrals.length));
}
emit NewUserPlace(userAddress, referrerAddress, 2, level, 6);
//close matrix
players[referrerAddress].p5Matrix[level].p5referrals = new address[](0);
if (!players[referrerAddress].activeP5Levels[level+1] && level != SLOT_FINAL_LEVEL) {
players[referrerAddress].p5Matrix[level].blocked = true;
}
//create new one by recursion
if (referrerAddress != owner) {
//check referrer active level
address freeReferrerAddress = players[userAddress].referrer;
if (players[referrerAddress].p5Matrix[level].currentReferrer != freeReferrerAddress) {
players[referrerAddress].p5Matrix[level].currentReferrer = freeReferrerAddress;
}
players[referrerAddress].p5Matrix[level].reinvestCount++;
emit Reinvest(referrerAddress, freeReferrerAddress, userAddress, 1, level);
updatep5Referrer(referrerAddress, freeReferrerAddress, level);
} else {
sendTrnReturns(owner, userAddress, 1, level);
players[owner].p5Matrix[level].reinvestCount++;
emit Reinvest(owner, address(0), userAddress, 1, level);
}
}
function giveSpills() public {
require(msg.sender == owner);
require(block .timestamp >= roundStartTime[gsRound] + 172800); //ensures that it can ony be called 48 hours after last call
for (uint i = 0; i < roundSpillReceivers[gsRound].length; i++) {
payable(roundSpillReceivers[gsRound][i]).transfer(roundGlobalSpills[gsRound]/roundSpillReceivers[gsRound].length);
}
gsRound ++;
roundStartTime[gsRound] = block.timestamp;
}
function sendTrnReturns(address userAddress, address _from, uint8 matrix, uint8 level) private {
//(address receiver, bool isExtraDividends) = seekTronReceiver(userAddress, _from, matrix, level);
address receiver = players[userAddress].referrer;
///
payable(address(uint160(receiver))).transfer((matrixLevelPrice[matrix][level] *6) /10);
balances[receiver] += ((matrixLevelPrice[matrix][level] *6) /10) ;
emit SentExtraTronDividends(_from, receiver, matrix, level);
}
function getNumberOfP4Referers(address player, uint8 level) public view returns(uint) {
return players[player].p4Matrix[level].referrals.length;
}
function getNumberOfP5Referers(address player, uint8 level) public view returns(uint) {
return players[player].p5Matrix[level].p5referrals.length;
}
function playersActivep4Levels(address userAddress, uint8 level) public view returns(bool) {
return players[userAddress].activeP4Levels[level];
}
function playersActivep5Levels(address userAddress, uint8 level) public view returns(bool) {
return players[userAddress].activeP5Levels[level];
}
function bytesToAddress(bytes memory bys) private pure returns (address addr) {
assembly {
addr := mload(add(bys, 20))
}
}
function playersp4Matrix(address userAddress, uint8 level) public view returns(address, address[] memory, bool) {
return (players[userAddress].p4Matrix[level].firstReferrer,
players[userAddress].p4Matrix[level].referrals,
players[userAddress].p4Matrix[level].blocked);
}
function playersp5Matrix(address userAddress, uint8 level) public view returns(address, address[] memory, bool, address) {
return (players[userAddress].p5Matrix[level].currentReferrer,
players[userAddress].p5Matrix[level].p5referrals,
players[userAddress].p5Matrix[level].blocked,
players[userAddress].p5Matrix[level].closedPart);
}
//checks if the user already exists
function isPlatformUser(address player) public view returns (bool) {
return (players[player].id != 0);
}
}
| 289,099 | 12,529 |
5ed0d22bd8b9c4963db6d8c624d40ae149ff6fd978cb1ae871d352103564c8c1
| 27,428 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/91/910f038c9e74df8baed886a22f75c69fae8a6792_SpaceStaking.sol
| 4,198 | 16,934 |
// 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 ISSpace {
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 SpaceStaking is Ownable {
using SafeMath for uint256;
using SafeMath for uint32;
using SafeERC20 for IERC20;
address public immutable Space;
address public immutable sSpace;
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;
constructor (address _Space,
address _sSpace,
uint32 _epochLength,
uint _firstEpochNumber,
uint32 _firstEpochTime) {
require(_Space != address(0));
Space = _Space;
require(_sSpace != address(0));
sSpace = _sSpace;
epoch = Epoch({
length: _epochLength,
number: _firstEpochNumber,
endTime: _firstEpochTime,
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(Space).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(ISSpace(sSpace).gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
IERC20(sSpace).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, ISSpace(sSpace).balanceForGons(info.gons));
}
}
function forfeit() external {
Claim memory info = warmupInfo[ msg.sender ];
delete warmupInfo[ msg.sender ];
IWarmup(warmupContract).retrieve(address(this), ISSpace(sSpace).balanceForGons(info.gons));
IERC20(Space).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(sSpace).safeTransferFrom(msg.sender, address(this), _amount);
IERC20(Space).safeTransfer(msg.sender, _amount);
}
function index() public view returns (uint) {
return ISSpace(sSpace).index();
}
function rebase() public {
if(epoch.endTime <= uint32(block.timestamp)) {
ISSpace(sSpace).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 = ISSpace(sSpace).circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
}
}
function contractBalance() public view returns (uint) {
return IERC20(Space).balanceOf(address(this)).add(totalBonus);
}
function giveLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.add(_amount);
IERC20(sSpace).safeTransfer(locker, _amount);
}
function returnLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.sub(_amount);
IERC20(sSpace).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;
}
}
| 97,345 | 12,530 |
429d8c7b67a534fbde72fd60f48d5180713e80fb49988b5a6cf3157f7d941f8b
| 13,613 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/6d/6de4d882a84a98f4ccd5d33ea6b3c99a07babeb1_FeeRateDIP3Impl.sol
| 2,903 | 11,104 |
pragma solidity 0.6.9;
pragma experimental ABIEncoderV2;
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);
}
}
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);
}
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;
}
}
}
interface ICrowdPooling {
function _QUOTE_RESERVE_() external view returns (uint256);
function getShares(address user) external view returns (uint256);
function _OWNER_() external returns (address);
}
interface IFee {
function getUserFee(address user) external view returns (uint256);
}
interface IQuota {
function getUserQuota(address user) external view returns (int);
}
interface IPoolHeartBeat {
function isPoolHeartBeatLive(address pool) external view returns(bool);
}
interface IPool {
function version() external pure returns (string memory);
function _LP_FEE_RATE_() external view returns (uint256);
function _BASE_RESERVE_() external view returns (uint);
function _QUOTE_RESERVE_() external view returns (uint);
function _K_() external view returns (uint);
}
contract FeeRateDIP3Impl is InitializableOwnable {
using SafeMath for uint256;
// ============ Storage ============
uint256 public _LP_MT_RATIO_ = 25;
struct CPPoolInfo {
address quoteToken;
int globalQuota;
address feeAddr;
address quotaAddr;
}
mapping(address => CPPoolInfo) public cpPools;
mapping(address => uint256) public specPoolList;
mapping (address => bool) public isAdminListed;
address public poolHeartBeat;
// ============ Events =============
event AddAdmin(address admin);
event RemoveAdmin(address admin);
// ============ Ownable Functions ============
function addCpPoolInfo(address cpPool, address quoteToken, int globalQuota, address feeAddr, address quotaAddr) external {
require(isAdminListed[msg.sender], "ACCESS_DENIED");
CPPoolInfo memory cpPoolInfo = CPPoolInfo({
quoteToken: quoteToken,
feeAddr: feeAddr,
quotaAddr: quotaAddr,
globalQuota: globalQuota
});
cpPools[cpPool] = cpPoolInfo;
}
function setCpPoolInfo(address cpPool, address quoteToken, int globalQuota, address feeAddr, address quotaAddr) external onlyOwner {
cpPools[cpPool].quoteToken = quoteToken;
cpPools[cpPool].feeAddr = feeAddr;
cpPools[cpPool].quotaAddr = quotaAddr;
cpPools[cpPool].globalQuota = globalQuota;
}
function setLpMtRatio(uint256 newLpMtRatio) external onlyOwner {
_LP_MT_RATIO_ = newLpMtRatio;
}
function setSpecPoolList (address poolAddr, uint256 mtFeeRate) public onlyOwner {
specPoolList[poolAddr] = mtFeeRate;
}
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 setPoolHeartBeat (address newPoolHeartBeat) public onlyOwner {
poolHeartBeat = newPoolHeartBeat;
}
// ============ Pool Owner Functions ============
function setCpPoolQuotaAddr(address cpPool, address quotaAddr) external {
require(msg.sender == ICrowdPooling(cpPool)._OWNER_(), "NOT OWNER OF POOL");
cpPools[cpPool].quotaAddr = quotaAddr;
}
// ============ View Functions ============
function getFeeRate(address pool, address user) external view returns (uint256) {
try IPool(pool).version() returns (string memory poolVersion) {
bytes32 hashPoolVersion = keccak256(abi.encodePacked(poolVersion));
if(_kjudge(hashPoolVersion)) {
uint k = IPool(pool)._K_();
uint baseReserve = IPool(pool)._BASE_RESERVE_();
uint quoteReserve = IPool(pool)._QUOTE_RESERVE_();
require(!(k==0 && (baseReserve ==0 || quoteReserve == 0)), "KJUDGE_ERROR");
}
if (poolHeartBeat != address(0) && !IPoolHeartBeat(poolHeartBeat).isPoolHeartBeatLive(pool)) {
return 10**18 - IPool(pool)._LP_FEE_RATE_() - 1;
}
if(specPoolList[pool] != 0) {
return specPoolList[pool];
}
if(_cp(hashPoolVersion)) {
CPPoolInfo memory cpPoolInfo = cpPools[pool];
address quoteToken = cpPoolInfo.quoteToken;
if(quoteToken == address(0)) {
return 0;
}else {
uint256 userInput = IERC20(quoteToken).balanceOf(pool).sub(ICrowdPooling(pool)._QUOTE_RESERVE_());
uint256 userStake = ICrowdPooling(pool).getShares(user);
address feeAddr = cpPoolInfo.feeAddr;
address quotaAddr = cpPoolInfo.quotaAddr;
int curQuota = cpPoolInfo.globalQuota;
if(quotaAddr != address(0))
curQuota = IQuota(quotaAddr).getUserQuota(user);
require(curQuota == -1 || (curQuota != -1 && int(userInput.add(userStake)) <= curQuota), "DODOFeeImpl: EXCEED_YOUR_QUOTA");
if(feeAddr == address(0)) {
return 0;
} else {
return IFee(feeAddr).getUserFee(user);
}
}
} else if(_dip3dvm(hashPoolVersion) || _dip3dsp(hashPoolVersion)) {
uint256 lpFeeRate = IPool(pool)._LP_FEE_RATE_();
uint256 mtFeeRate = lpFeeRate.mul(_LP_MT_RATIO_).div(100);
if(lpFeeRate.add(mtFeeRate) >= 10**18) {
return 0;
} else {
return mtFeeRate;
}
} else {
return 0;
}
} catch (bytes memory) {
return 0;
}
}
function getCPInfoByUser(address pool, address user) external view returns (bool isHaveCap, int curQuota, uint256 userFee) {
CPPoolInfo memory cpPoolInfo = cpPools[pool];
if(cpPoolInfo.quoteToken == address(0)) {
isHaveCap = false;
curQuota = -1;
userFee = 0;
}else {
address quotaAddr = cpPoolInfo.quotaAddr;
curQuota = cpPoolInfo.globalQuota;
if(quotaAddr != address(0))
curQuota = IQuota(quotaAddr).getUserQuota(user);
if(curQuota == -1) {
isHaveCap = false;
}else {
isHaveCap = true;
uint256 userStake = ICrowdPooling(pool).getShares(user);
if(uint256(curQuota) >= userStake) {
curQuota = int(uint256(curQuota).sub(userStake));
}else {
curQuota = 0;
}
}
address feeAddr = cpPoolInfo.feeAddr;
if(feeAddr == address(0)) {
userFee = 0;
} else {
userFee = IFee(feeAddr).getUserFee(user);
}
}
}
function _cp(bytes32 _hashPoolVersion) internal pure returns (bool) {
return (_hashPoolVersion == keccak256(abi.encodePacked("CP 1.0.0")) || _hashPoolVersion == keccak256(abi.encodePacked("CP 2.0.0")));
}
function _dip3dvm(bytes32 _hashPoolVersion) internal pure returns (bool){
return (_hashPoolVersion == keccak256(abi.encodePacked("DVM 1.0.2")) || _hashPoolVersion == keccak256(abi.encodePacked("DVM 1.0.3")));
}
function _dip3dsp(bytes32 _hashPoolVersion) internal pure returns (bool){
return (_hashPoolVersion == keccak256(abi.encodePacked("DSP 1.0.1")) || _hashPoolVersion == keccak256(abi.encodePacked("DSP 1.0.2")));
}
function _kjudge(bytes32 _hashPoolVersion) internal pure returns (bool) {
return (_hashPoolVersion == keccak256(abi.encodePacked("DVM 1.0.2")) || _hashPoolVersion == keccak256(abi.encodePacked("DSP 1.0.1")) || _hashPoolVersion == keccak256(abi.encodePacked("DPP 1.0.0")) || _hashPoolVersion == keccak256(abi.encodePacked("DPP Advanced 1.0.0")));
}
function version() virtual external pure returns (string memory) {
return "1.2.0";
}
}
| 29,900 | 12,531 |
84cc131acd5ebddf56eab05f9b34b2183e8c9cd3506ebd9dfde62ff2ec079717
| 31,769 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/b9/b96308544bd6c1ba006c5a96685f63090da464d9_TcsWithBenefits.sol
| 3,683 | 14,361 |
// 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;
}
}
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);
}
}
}
}
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);
}
contract ERC20 is Context, 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) public {
_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(_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);
_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 _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 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;
}
}
// TcsBenefits is the place where tcs's live to create xTCS.
// This contract handles swapping to and from xTcs.
contract TcsWithBenefits is ERC20("TCS With Benefits", "xTCS") {
using SafeMath for uint256;
IERC20 public tcs;
uint256 public UsersLockedTCS;
uint256 public BuyBackLockedTCS;
// Define the Tcs token contract
constructor(IERC20 _tcs) public {
tcs = _tcs;
UsersLockedTCS = 0;
BuyBackLockedTCS = 0;
}
// Locks Tcs and mints xTcs
function enter(uint256 _amount) public {
// Gets the amount of Tcs locked in the contract
uint256 totalTcs = tcs.balanceOf(address(this));
// Gets the amount of xTcs in existence
uint256 totalShares = totalSupply();
// If no xTcs exists, mint it 1:1 to the amount put in
if (totalShares == 0 || totalTcs == 0) {
mint(msg.sender, _amount);
}
else {
uint256 what = _amount.mul(totalShares).div(totalTcs);
mint(msg.sender, what);
}
// Lock the Tcs in the contract
tcs.transferFrom(msg.sender, address(this), _amount);
// Total
UsersLockedTCS += _amount;
}
// Unlocks the staked + gained Tcs and burns xTcs
function leave(uint256 _share) public {
// Gets the amount of xTcs in existence
uint256 totalShares = totalSupply();
// Calculates the amount of Tcs the xTcs is worth
uint256 what = _share.mul(tcs.balanceOf(address(this))).div(totalShares);
burn(msg.sender, _share);
tcs.transfer(msg.sender, what);
UsersLockedTCS = UsersLockedTCS - what;
}
// returns the total amount of TCS an address has in the contract including fees earned
function TCSBalance(address _account)
external
view
returns (uint256 tcsAmount_)
{
uint256 xTCSAmount = balanceOf(_account);
uint256 totalxTCS = totalSupply();
tcsAmount_ = xTCSAmount.mul(tcs.balanceOf(address(this))).div(totalxTCS);
}
// returns how much TCS someone gets for redeeming xTCS
function xTCSForTCS(uint256 _xTCSAmount)
external
view
returns (uint256 tcsAmount_)
{
uint256 totalxTCS = totalSupply();
tcsAmount_ = _xTCSAmount.mul(tcs.balanceOf(address(this))).div(totalxTCS);
}
// returns how much xTCS someone gets for depositing TCS
function TCSForxTCS(uint256 _tcsAmount)
external
view
returns (uint256 xTCSAmount_)
{
uint256 totalTcs = tcs.balanceOf(address(this));
uint256 totalxTCS = totalSupply();
if (totalxTCS == 0 || totalTcs == 0) {
xTCSAmount_ = _tcsAmount;
} else {
xTCSAmount_ = _tcsAmount.mul(totalxTCS).div(totalTcs);
}
}
function burn(address _from, uint256 _amount) private {
_burn(_from, _amount);
}
function mint(address recipient, uint256 _amount) private {
_mint(recipient, _amount);
}
function transferFrom(address sender,
address recipient,
uint256 amount) public virtual override returns (bool) {
bool result = super.transferFrom(sender, recipient, amount); // Call parent hook
return result;
}
function transfer(address recipient, uint256 amount)
public
virtual
override
returns (bool)
{
bool result = super.transfer(recipient, amount); // Call parent hook
return result;
}
function ContractInfo() public view returns(uint256 totalTCSBalance,
uint256 lockedTCS,
uint256 xTCS) {
totalTCSBalance = tcs.balanceOf(address(this));
lockedTCS = UsersLockedTCS;
xTCS = this.totalSupply();
}
function depositTCS(uint256 amount)
public {
tcs.transferFrom(msg.sender, address(this), amount);
BuyBackLockedTCS += amount;
}
}
| 307,718 | 12,532 |
24ae23cdb23748752f74577fc294608e457417a1791f309391175e9c565a00c9
| 23,218 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/e3/e32E42cFf53Db3B4646039a25077ba200a4cbbBf_LiquidityLocker.sol
| 2,764 | 10,616 |
// 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);
function burn(uint256 amount) external;
}
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;
}
}
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 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");
}
}
}
// Note that this pool has no minter key of Fatm (rewards).
contract LiquidityLocker {
using SafeMath for uint256;
using SafeERC20 for IERC20;
uint256 public LOCKPERIOD = 3600 * 24 * 365 * 50; // 50 years lock
uint256 public locktime;
// governance
address public operator;
// END MAINNET
event Deposit(address indexed user, uint256 indexed pid, uint256 amount);
event Withdraw(address indexed user, uint256 indexed pid, uint256 amount);
event EmergencyWithdraw(address indexed user, uint256 indexed pid, uint256 amount);
event RewardPaid(address indexed user, uint256 amount);
constructor() public {
locktime = block.timestamp + LOCKPERIOD;
}
modifier onlyOperator() {
require(operator == msg.sender, "FatmGenesisPool: caller is not the operator");
_;
}
function withdraw(address _token, uint256 _amount, address _receipt) external onlyOperator{
require(block.timestamp > locktime , "unable to withdraw until lock time");
uint256 _balance = IERC20(_token).balanceOf(address(this));
require(_amount <= _balance, "execeed amount");
IERC20(_token).transfer(_receipt, _amount);
}
}
| 329,583 | 12,533 |
2da266501f206795160ac1b3c2891ac2aadc260e3bc2c979c0b16af2afe447b0
| 16,641 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x86fb872ff061f7d47d7c8154e6030731695ed1fe.sol
| 3,322 | 12,374 |
pragma solidity ^0.4.21;
// SafeMath is a part of Zeppelin Solidity library
// licensed under MIT License
// https://github.com/OpenZeppelin/zeppelin-solidity/blob/master/LICENSE
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;
}
}
// https://github.com/OpenZeppelin/zeppelin-solidity
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 {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
modifier onlyPayloadSize(uint size) {
assert(msg.data.length == size + 4);
_;
}
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) onlyPayloadSize(2 * 32) 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);
_postTransferHook(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
function _postTransferHook(address _from, address _to, uint256 _value) internal;
}
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);
_postTransferHook(_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 Owned {
address owner;
modifier onlyOwner {
require(msg.sender == owner);
_;
}
/// @dev Contract constructor
function Owned() public {
owner = msg.sender;
}
}
contract AcceptsTokens {
ETToken public tokenContract;
function AcceptsTokens(address _tokenContract) public {
tokenContract = ETToken(_tokenContract);
}
modifier onlyTokenContract {
require(msg.sender == address(tokenContract));
_;
}
function acceptTokens(address _from, uint256 _value, uint256 param1, uint256 param2, uint256 param3) external;
}
contract ETToken is Owned, StandardToken {
using SafeMath for uint;
string public name = "ETH.TOWN Token";
string public symbol = "ETIT";
uint8 public decimals = 18;
address public beneficiary;
address public oracle;
address public heroContract;
modifier onlyOracle {
require(msg.sender == oracle);
_;
}
mapping (uint32 => address) public floorContracts;
mapping (address => bool) public canAcceptTokens;
mapping (address => bool) public isMinter;
modifier onlyMinters {
require(msg.sender == owner || isMinter[msg.sender]);
_;
}
event Dividend(uint256 value);
event Withdrawal(address indexed to, uint256 value);
event Burn(address indexed from, uint256 value);
function ETToken() public {
oracle = owner;
beneficiary = owner;
totalSupply_ = 0;
}
function setOracle(address _oracle) external onlyOwner {
oracle = _oracle;
}
function setBeneficiary(address _beneficiary) external onlyOwner {
beneficiary = _beneficiary;
}
function setHeroContract(address _heroContract) external onlyOwner {
heroContract = _heroContract;
}
function _mintTokens(address _user, uint256 _amount) private {
require(_user != 0x0);
balances[_user] = balances[_user].add(_amount);
totalSupply_ = totalSupply_.add(_amount);
emit Transfer(address(this), _user, _amount);
}
function authorizeFloor(uint32 _index, address _floorContract) external onlyOwner {
floorContracts[_index] = _floorContract;
}
function _acceptDividends(uint256 _value) internal {
uint256 beneficiaryShare = _value / 5;
uint256 poolShare = _value.sub(beneficiaryShare);
beneficiary.transfer(beneficiaryShare);
emit Dividend(poolShare);
}
function acceptDividends(uint256 _value, uint32 _floorIndex) external {
require(floorContracts[_floorIndex] == msg.sender);
_acceptDividends(_value);
}
function rewardTokensFloor(address _user, uint256 _tokens, uint32 _floorIndex) external {
require(floorContracts[_floorIndex] == msg.sender);
_mintTokens(_user, _tokens);
}
function rewardTokens(address _user, uint256 _tokens) external onlyMinters {
_mintTokens(_user, _tokens);
}
function() payable public {
// Intentionally left empty, for use by floors
}
function payoutDividends(address _user, uint256 _value) external onlyOracle {
_user.transfer(_value);
emit Withdrawal(_user, _value);
}
function accountAuth(uint256) external {
// Does nothing by design
}
function burn(uint256 _amount) external {
require(balances[msg.sender] >= _amount);
balances[msg.sender] = balances[msg.sender].sub(_amount);
totalSupply_ = totalSupply_.sub(_amount);
emit Burn(msg.sender, _amount);
}
function setCanAcceptTokens(address _address, bool _value) external onlyOwner {
canAcceptTokens[_address] = _value;
}
function setIsMinter(address _address, bool _value) external onlyOwner {
isMinter[_address] = _value;
}
function _invokeTokenRecipient(address _from, address _to, uint256 _value, uint256 _param1, uint256 _param2, uint256 _param3) internal {
if (!canAcceptTokens[_to]) {
return;
}
AcceptsTokens recipient = AcceptsTokens(_to);
recipient.acceptTokens(_from, _value, _param1, _param2, _param3);
}
function transferWithParams(address _to, uint256 _value, uint256 _param1, uint256 _param2, uint256 _param3) onlyPayloadSize(5 * 32) external 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);
_invokeTokenRecipient(msg.sender, _to, _value, _param1, _param2, _param3);
return true;
}
function _postTransferHook(address _from, address _to, uint256 _value) internal {
_invokeTokenRecipient(_from, _to, _value, 0, 0, 0);
}
}
contract PresaleContract is Owned {
ETToken public tokenContract;
/// @dev Contract constructor
function PresaleContract(address _tokenContract) public {
tokenContract = ETToken(_tokenContract);
}
}
contract ETCharPresale is PresaleContract {
using SafeMath for uint;
bool public enabled = true;
uint32 public maxCharId = 300;
uint32 public currentCharId = 1;
uint256 public currentPrice = 0.1 ether;
mapping (uint32 => address) public owners;
mapping (address => uint32[]) public characters;
event Purchase(address from, uint32 charId, uint256 amount);
function ETCharPresale(address _presaleToken)
PresaleContract(_presaleToken)
public
{
}
function _isContract(address _user) internal view returns (bool) {
uint size;
assembly { size := extcodesize(_user) }
return size > 0;
}
function _provideChars(address _address, uint32 _number) internal {
for (uint32 i = 0; i < _number; i++) {
owners[currentCharId + i] = _address;
characters[_address].push(currentCharId + i);
emit Purchase(_address, currentCharId + i, currentPrice);
}
currentCharId += _number;
currentPrice += priceIncrease() * _number;
}
function priceIncrease() public view returns (uint256) {
uint256 _currentPrice = currentPrice;
if (_currentPrice > 0.3 ether) {
return 0.05 finney;
} else if (_currentPrice > 0.25 ether) {
return 0.1 finney;
} else if (_currentPrice > 0.2 ether) {
return 0.2 finney;
} else if (_currentPrice > 0.15 ether) {
return 0.4 finney;
} else {
return 0.8 finney;
}
}
function() public payable {
require(enabled);
require(!_isContract(msg.sender));
require(msg.value >= currentPrice);
uint32 chars = uint32(msg.value.div(currentPrice));
require(chars <= 50);
if (chars > 5) {
chars = 5;
}
require(currentCharId + chars - 1 <= maxCharId);
uint256 purchaseValue = currentPrice.mul(chars);
uint256 change = msg.value.sub(purchaseValue);
_provideChars(msg.sender, chars);
tokenContract.rewardTokens(msg.sender, purchaseValue * 200);
if (currentCharId > maxCharId) {
enabled = false;
}
if (change > 0) {
msg.sender.transfer(change);
}
}
function setEnabled(bool _enabled) public onlyOwner {
enabled = _enabled;
}
function setMaxCharId(uint32 _maxCharId) public onlyOwner {
maxCharId = _maxCharId;
}
function setCurrentPrice(uint256 _currentPrice) public onlyOwner {
currentPrice = _currentPrice;
}
function withdraw() public onlyOwner {
owner.transfer(address(this).balance);
}
function charactersOf(address _user) public view returns (uint32[]) {
return characters[_user];
}
}
| 206,770 | 12,534 |
2ec657ed4e94ca8ff3f50aad790cd3bf038c534f75c9c6a1a724a7c065f8073e
| 27,576 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/aa/aA0B17eCE2D240A622fA9226DbDE4A7f33d3fe59_NoahArkStaking.sol
| 4,455 | 17,707 |
// 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 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 IsNRK {
function rebase(uint256 nrkProfit_, 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 IDistributor {
function distribute() external returns (bool);
}
contract NoahArkStaking is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
address public immutable NRK;
address public immutable sNRK;
struct Epoch {
uint length;
uint number;
uint endBlock;
uint distribute;
}
Epoch public epoch;
address public distributor;
address public locker;
uint public totalBonus;
uint public warmupPeriod;
constructor (address _NRK,
address _sNRK,
uint _epochLength,
uint _firstEpochNumber,
uint _firstEpochBlock) {
require(_NRK != address(0));
NRK = _NRK;
require(_sNRK != address(0));
sNRK = _sNRK;
epoch = Epoch({
length: _epochLength,
number: _firstEpochNumber,
endBlock: _firstEpochBlock,
distribute: 0
});
}
struct Claim {
uint deposit;
uint gons;
uint expiry;
uint stakeEpochNumber;
}
mapping(address => bool) public lock;
mapping(address => Claim) public warmupInfo;
event StakeEvent(uint _amount, address _recipient);
event StakeRecordEvent(uint _amount, uint _gons, uint _stakeEpochNumber, uint _expiry, address _recipient);
event UnStakeEvent(uint _amount, address _recipient);
function stake(uint _amount, address _recipient) external returns (bool) {
rebase();
IERC20(NRK).safeTransferFrom(msg.sender, address(this), _amount);
bool _lock = lock[ _recipient ];
require(!_lock, "Deposits for account are locked");
uint _gons = IsNRK(sNRK).gonsForBalance(_amount);
Claim memory info = warmupInfo[_recipient];
warmupInfo[ _recipient ] = Claim ({
deposit: info.deposit.add(_amount),
gons: info.gons.add(IsNRK(sNRK).gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
stakeEpochNumber: epoch.number
});
IERC20(sNRK).safeTransfer(_recipient, _amount);
emit StakeEvent(_amount, _recipient);
emit StakeRecordEvent(_amount, _gons, epoch.number, epoch.number.add(warmupPeriod), _recipient);
return true;
}
function canClaim (address _recipient) public view returns (uint) {
Claim memory info = warmupInfo[ _recipient ];
uint _canClaim;
if (info.expiry <= epoch.number && info.expiry != 0) {
_canClaim = IsNRK(sNRK).balanceForGons(info.gons);
}
return _canClaim;
}
function toggleDepositLock() external {
lock[ msg.sender ] = !lock[ msg.sender ];
}
function settleWarmupInfo(address _user, uint _amount) external {
require(msg.sender == sNRK, 'access deny');
Claim storage claim = warmupInfo[ _user ];
uint _unstakeGons = IsNRK(sNRK).gonsForBalance(_amount);
require(claim.expiry <= epoch.number && claim.expiry != 0, 'The deposit is not due');
require(claim.gons >= _unstakeGons, 'snrk balance not enough');
claim.deposit = claim.deposit.sub(_amount);
claim.gons = claim.gons.sub(_unstakeGons);
if (claim.gons == 0) {
claim.expiry = 0;
claim.stakeEpochNumber = 0;
}
}
function changeWarmupInfo(address _user, uint _amount) external {
require(msg.sender == sNRK, 'access deny');
Claim memory tempClaim = warmupInfo[ _user ];
if(tempClaim.expiry != 0) {
Claim storage claim = warmupInfo[ _user ];
claim.gons = claim.gons.add(IsNRK(sNRK).gonsForBalance(_amount));
} else {
warmupInfo[ _user ] = Claim ({
deposit: tempClaim.deposit.add(_amount),
gons: tempClaim.gons.add(IsNRK(sNRK).gonsForBalance(_amount)),
expiry: epoch.number,
stakeEpochNumber: epoch.number
});
}
}
function unstake(uint _amount, bool _trigger) external {
if (_trigger) {
rebase();
}
IERC20(sNRK).safeTransferFrom(msg.sender, address(this), _amount);
IERC20(NRK).safeTransfer(msg.sender, _amount);
emit UnStakeEvent(_amount, msg.sender);
}
function index() public view returns (uint) {
return IsNRK(sNRK).index();
}
function rebase() public {
if(epoch.endBlock <= block.number) {
IsNRK(sNRK).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 = IsNRK(sNRK).circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
}
}
function contractBalance() public view returns (uint) {
return IERC20(NRK).balanceOf(address(this)).add(totalBonus);
}
function giveLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.add(_amount);
IERC20(sNRK).safeTransfer(locker, _amount);
}
function returnLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.sub(_amount);
IERC20(sNRK).safeTransferFrom(locker, address(this), _amount);
}
enum CONTRACTS { DISTRIBUTOR, LOCKER }
function setContract(CONTRACTS _contract, address _address) external onlyManager() {
if(_contract == CONTRACTS.DISTRIBUTOR) { // 0
distributor = _address;
} else if (_contract == CONTRACTS.LOCKER) { // 1
require(locker == address(0), "Locker cannot be set more than once");
locker = _address;
}
}
function setWarmup(uint _warmupPeriod) external onlyManager() {
warmupPeriod = _warmupPeriod;
}
}
| 115,205 | 12,535 |
2ed2421913460d06e42b52325f68a0e277a04b1c56d62f2f244625f76dac3802
| 12,734 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/testnet/f0/f01117c6A82b37968355B27846cd551D86F26449_TimeERC20Token.sol
| 2,898 | 10,728 |
// 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 TimeERC20Token is ERC20Permit, VaultOwned {
using LowGasSafeMath for uint256;
constructor() ERC20("WTF", "WTF", 9) {
}
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_);
}
}
| 53,139 | 12,536 |
a53cd31708dd32fb0389fd1fd02584f101abd336ca24b227dfe9b165bdbd8e3a
| 17,603 |
.sol
|
Solidity
| false |
115809833
|
solidblu1992/ethereum
|
2d83ac8e2e6c49629417da1ef923de625eed7dcd
|
SimpleRingMixer/contracts/RingMixerV2.sol
| 5,186 | 16,819 |
pragma solidity ^0.5.9;
contract RingMixerV2 {
address private debugOwner;
constructor() public {
debugOwner = msg.sender;
G1[0] = 1;
G1[1] = 2;
H = HashPoint(G1);
}
function DebugKill() public {
require(msg.sender == debugOwner);
selfdestruct(msg.sender);
}
//alt_bn128 constants
uint256[2] public G1;
uint256[2] public H;
uint256 constant public N = 0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593f0000001;
uint256 constant public P = 0x30644e72e131a029b85045b68181585d97816a916871ca8d3c208c16d87cfd47;
//Used for Point Compression/Decompression
uint256 constant public ECSignMask = 0x8000000000000000000000000000000000000000000000000000000000000000;
uint256 constant public a = 0xc19139cb84c680a6e14116da060561765e05aa45a1c72a34f082305b61f3f52; // (p+1)/4
//Ring message - Standard interface for ring signatures
struct RingMessage {
address[] destination;
uint256[] value;
}
//Storage of Spent Key Images
mapping (uint256 => bool) public KeyImageUsed;
//Storage of Token Balances
mapping (address => uint256) public token_balance;
//Convenience tables for looking up acceptable mix-in keys
mapping (uint256 => uint256[]) public lookup_pubkey_by_balance;
mapping (uint256 => bool) public lookup_pubkey_by_balance_populated;
mapping (uint256 => uint256) public lookup_pubkey_by_balance_count;
//Transaction Functions
//Deposit Ether as RingMixer tokens to the specified RingMixer address
function Deposit(address destination)
payable public returns (bool success)
{
//Address must have a zero balance (never used)
require(token_balance[destination] == 0);
//Incoming Value must be non-zero
require(msg.value > 0);
//Add tokens to balance corrosponding to the amount of Ether
token_balance[destination] = msg.value;
success = true;
}
//Equally distribute Ether as RingMixer tokens to the specified RingMixer addresses
function DepositN(address[] memory destination)
payable public returns (bool success)
{
//Must have more than one address specified
require(destination.length > 0);
//Incoming Value must be non-zero
require(msg.value > 0);
uint256 value = msg.value / destination.length;
for (uint i = 0; i < destination.length; i++) {
//Address must have a zero balance (never used)
require(token_balance[destination[i]] == 0);
//Add tokens to balance corrosponding to the amount of Ether
token_balance[destination[i]] = value;
}
success = true;
}
//=== RingVerifyN ===
//Inputs:
// destination (address[]) - list of payable ETH addresses
// value (uint256[]) - list of values corrosponding to the destination
// signature (uint256[2*N+2]) - ring signature
// signature[0] - keyimage for private key (compressed)
// signature[1] - c0 - start of ring signature - scaler for PublicKey[0]
// signature[2 ... 2+(N-1)] - s0...s[N-1], scalar for G1
// signature[2+N ... 2*N+1 ] - Public Keys (compressed) - total of N Public Keys
// signature[2*N+2 ... 31 ] - Padding (0)
// e.g. N=3; signature = { Ik, c0, s0, s1, s2, PubKey0, PubKey1, PubKey2 }
//Outputs:
// success (bool) - true/false indicating if signature is valid on message
function Withdraw(address[] memory destination, uint256[] memory value, uint256[] memory signature)
public returns (bool success)
{
//Check Array Bounds
require(destination.length == value.length);
//Check for new key Image
require(!KeyImageUsed[signature[0]]);
//Get Ring Size
uint256 ring_size = (signature.length - 2) / 2;
//Check Values of Addresses - Must Match
uint256 i;
address addr;
uint256 txValue;
uint256 temp;
for (i = 0; i < ring_size; i++) {
temp = signature[2+ring_size+i];
addr = GetAddress(temp);
//On first i, fetch value
if (i == 0) {
txValue = token_balance[addr];
}
//Values must match first address
else {
require(txValue == token_balance[addr]);
}
//Update Lookup By Balance Table for Convenient Mix-ins
if (!lookup_pubkey_by_balance_populated[temp]) {
lookup_pubkey_by_balance[txValue].push(temp);
lookup_pubkey_by_balance_populated[temp] = true;
lookup_pubkey_by_balance_count[txValue]++;
}
}
//Verify that the value to be sent spends the exact amount
temp = 0;
for (i = 0; i < value.length; i++) {
if (value[i] > txValue) return false; //Check for crafty overflows
temp += value[i];
}
if (temp != txValue) return false;
//Check Ring for Validity
success = RingVerify(RingMessage(destination, value), signature);
//Pay out balance
if (success) {
KeyImageUsed[signature[0]] = true;
for (i = 0; i < destination.length; i++) {
address payable dest = address(uint160(destination[i]));
dest.transfer(value[i]);
}
}
}
//Address Functions - Convert compressed public key into RingMixer address
function GetAddress(uint256 PubKey)
public view returns (address addr)
{
uint256[2] memory temp;
temp = ExpandPoint(PubKey);
addr = address(uint(keccak256(abi.encodePacked(temp[0], temp[1]))));
}
//Base EC Functions
function ecAdd(uint256[2] memory p0, uint256[2] memory p1)
public view returns (uint256[2] memory p2)
{
assembly {
//Get Free Memory Pointer
let p := mload(0x40)
//Store Data for ECAdd Call
mstore(p, mload(p0))
mstore(add(p, 0x20), mload(add(p0, 0x20)))
mstore(add(p, 0x40), mload(p1))
mstore(add(p, 0x60), mload(add(p1, 0x20)))
//Call ECAdd
let success := staticcall(sub(gas, 2000), 0x06, p, 0x80, p, 0x40)
// Use "invalid" to make gas estimation work
switch success case 0 { revert(p, 0x80) }
//Store Return Data
mstore(p2, mload(p))
mstore(add(p2, 0x20), mload(add(p,0x20)))
}
}
function ecMul(uint256[2] memory p0, uint256 s)
public view returns (uint256[2] memory p1)
{
assembly {
//Get Free Memory Pointer
let p := mload(0x40)
//Store Data for ECMul Call
mstore(p, mload(p0))
mstore(add(p, 0x20), mload(add(p0, 0x20)))
mstore(add(p, 0x40), s)
//Call ECAdd
let success := staticcall(sub(gas, 2000), 0x07, p, 0x60, p, 0x40)
// Use "invalid" to make gas estimation work
switch success case 0 { revert(p, 0x80) }
//Store Return Data
mstore(p1, mload(p))
mstore(add(p1, 0x20), mload(add(p,0x20)))
}
}
function CompressPoint(uint256[2] memory Pin)
public pure returns (uint256 Pout)
{
//Store x value
Pout = Pin[0];
//Determine Sign
if ((Pin[1] & 0x1) == 0x1) {
Pout |= ECSignMask;
}
}
function EvaluateCurve(uint256 x)
public view returns (uint256 y, bool onCurve)
{
uint256 y_squared = mulmod(x,x, P);
y_squared = mulmod(y_squared, x, P);
y_squared = addmod(y_squared, 3, P);
uint256 p_local = P;
uint256 a_local = a;
assembly {
//Get Free Memory Pointer
let p := mload(0x40)
//Store Data for Big Int Mod Exp Call
mstore(p, 0x20) //Length of Base
mstore(add(p, 0x20), 0x20) //Length of Exponent
mstore(add(p, 0x40), 0x20) //Length of Modulus
mstore(add(p, 0x60), y_squared) //Base
mstore(add(p, 0x80), a_local) //Exponent
mstore(add(p, 0xA0), p_local) //Modulus
//Call Big Int Mod Exp
let success := staticcall(sub(gas, 2000), 0x05, p, 0xC0, p, 0x20)
// Use "invalid" to make gas estimation work
switch success case 0 { revert(p, 0xC0) }
//Store Return Data
y := mload(p)
}
//Check Answer
onCurve = (y_squared == mulmod(y, y, P));
}
function ExpandPoint(uint256 Pin)
public view returns (uint256[2] memory Pout)
{
//Get x value (mask out sign bit)
Pout[0] = Pin & (~ECSignMask);
//Get y value
bool onCurve;
uint256 y;
(y, onCurve) = EvaluateCurve(Pout[0]);
//TODO: Find better failure case for point not on curve
if (!onCurve) {
Pout[0] = 0;
Pout[1] = 0;
}
else {
//Use Positive Y
if ((Pin & ECSignMask) != 0) {
if ((y & 0x1) == 0x1) {
Pout[1] = y;
} else {
Pout[1] = P - y;
}
}
//Use Negative Y
else {
if ((y & 0x1) == 0x1) {
Pout[1] = P - y;
} else {
Pout[1] = y;
}
}
}
}
//=====Ring Signature Functions=====
function HashFunction(RingMessage memory message, uint256[2] memory left, uint256[2] memory right)
internal pure returns (uint256 h)
{
return (uint256(keccak256(abi.encodePacked(message.destination, message.value, left[0], left[1], right[0], right[1]))) % N);
}
//Return H = alt_bn128 evaluated at keccak256(p)
function HashPoint(uint256[2] memory p)
internal view returns (uint256[2] memory h)
{
bool onCurve;
h[0] = uint256(keccak256(abi.encodePacked(p[0], p[1]))) % N;
while(!onCurve) {
(h[1], onCurve) = EvaluateCurve(h[0]);
h[0]++;
}
h[0]--;
}
function KeyImage(uint256 xk, uint256[2] memory Pk)
internal view returns (uint256[2] memory Ix)
{
//Ix = xk * HashPoint(Pk)
Ix = HashPoint(Pk);
Ix = ecMul(Ix, xk);
}
function RingStartingSegment(RingMessage memory message, uint256 alpha, uint256[2] memory P0)
internal view returns (uint256 c0)
{
//Memory Registers
uint256[2] memory left;
uint256[2] memory right;
right = HashPoint(P0);
right = ecMul(right, alpha);
left = ecMul(G1, alpha);
c0 = HashFunction(message, left, right);
}
function RingSegment(RingMessage memory message, uint256 c0, uint256 s0, uint256[2] memory P0, uint256[2] memory Ix)
internal view returns (uint256 c1)
{
//Memory Registers
uint256[2] memory temp;
uint256[2] memory left;
uint256[2] memory right;
//Deserialize Point
(left[0], left[1]) = (P0[0], P0[1]);
right = HashPoint(left);
//Calculate left = c*P0 + s0*G1)
left = ecMul(left, c0);
temp = ecMul(G1, s0);
left = ecAdd(left, temp);
//Calculate right = s0*H(P0) + c*Ix
right = ecMul(right, s0);
temp = ecMul(Ix, c0);
right = ecAdd(right, temp);
c1 = HashFunction(message, left, right);
}
//SubMul = (alpha - c*xk) % N
function SubMul(uint256 alpha, uint256 c, uint256 xk)
internal pure returns (uint256 s)
{
s = mulmod(c, xk, N);
s = N - s;
s = addmod(alpha, s, N);
}
//=== RingSignatureN ===
//Inputs:
// message (RingMessage) - to be signed by the ring signature
// data[0] - index from 0 to (N-1) specifying which Public Key has a known private key
// data[1] - corrosponding private key for PublicKey[k]
// data[2 ... 2+(N-1)] - Random Numbers - total of N random numbers
// data[2+N ... 2*N+1 ] - Public Keys (compressed) - total of N Public Keys
// e.g. N=3; data = {k, PrivateKey_k, random0, random1, random2, PubKey0, PubKey1, PubKey2 }
//
//Outputs:
// signature (uint256[32]) - resulting signature
// signature[0] - keyimage for private key (compressed)
// signature[1] - c0 - start of ring signature - scaler for PublicKey[0]
// signature[2 ... 2+(N-1)] - s0...s[N-1], scalar for G1
// signature[2+N ... 2*N+1 ] - Public Keys (compressed) - total of N Public Keys
// signature[2*N+2 ... 31 ] - Padding (0)
// e.g. N=3; signature = { Ik, c0, s0, s1, s2, PubKey0, PubKey1, PubKey2 }
function RingSign(RingMessage memory message, uint256[] memory data)
internal view returns (uint256[32] memory signature)
{
//Check Array Lengths
require(data.length >= 6); //Minimum size (2 PubKeys) = (2*2+2) = 6
require(data.length <= 32); //Max size - will only output 32 uint256's
require((data.length % 2) == 0); //data.length must be even
uint256 ring_size = (data.length - 2) / 2;
uint i;
//Copy Random Numbers (most will become s-values) and Public Keys
for (i = 2; i < data.length; i++) {
signature[i] = data[i];
}
//Memory Registers
uint256[2] memory pubkey;
uint256[2] memory keyimage;
uint256 c;
//Setup Indices
i = (data[0] + 1) % ring_size;
//Calculate Key Image
pubkey = ExpandPoint(data[2+ring_size+data[0]]);
keyimage = KeyImage(data[1], pubkey);
signature[0] = CompressPoint(keyimage);
//Calculate Starting c = hash(message, alpha*G1, alpha*HashPoint(Pk))
c = RingStartingSegment(message, data[2+data[0]], pubkey);
if (i == 0) {
signature[1] = c;
}
for (; i != data[0];) {
//Deserialize Point and calculate next Ring Segment
pubkey = ExpandPoint(data[2+ring_size+i]);
c = RingSegment(message, c, data[2+i], pubkey, keyimage);
//Increment Counters
i = i + 1;
// Roll counters over
if (i == ring_size) {
i = 0;
signature[1] = c;
}
}
//Calculate s s.t. alpha*G1 = c1*P1 + s1*G1 = (c1*x1 + s1) * G1
//s = alpha - c1*x1
signature[2+data[0]] = SubMul(data[2+data[0]], c, data[1]);
}
function RingSign_User(address[] memory destination, uint256[] memory value, uint256[] memory data)
public view returns (uint256[32] memory signature)
{
return RingSign(RingMessage(destination, value), data);
}
//=== RingVerifyN ===
//Inputs:
// message (RingMessage) - signed by the ring signature
// signature (uint256[2*N+2]) - ring signature
// signature[0] - keyimage for private key (compressed)
// signature[1] - c0 - start of ring signature - scaler for PublicKey[0]
// signature[2 ... 2+(N-1)] - s0...s[N-1], scalar for G1
// signature[2+N ... 2*N+1 ] - Public Keys (compressed) - total of N Public Keys
// signature[2*N+2 ... 31 ] - Padding (0)
// e.g. N=3; signature = { Ik, c0, s0, s1, s2, PubKey0, PubKey1, PubKey2 }
//Outputs:
// success (bool) - true/false indicating if signature is valid on message
function RingVerify(RingMessage memory message, uint256[] memory signature)
internal view returns (bool success)
{
//Check Array Lengths
require(signature.length >= 6); //Minimum size (2 PubKeys) = (2*2+2) = 6
require((signature.length % 2) == 0); //data.length must be even
//Memory Registers
uint256[2] memory pubkey;
uint256[2] memory keyimage;
uint256 c = signature[1];
//Expand Key Image
keyimage = ExpandPoint(signature[0]);
//Verify Ring
uint i = 0;
uint256 ring_size = (signature.length - 2) / 2;
for (; i < ring_size;) {
//Deserialize Point and calculate next Ring Segment
pubkey = ExpandPoint(signature[2+ring_size+i]);
c = RingSegment(message, c, signature[2+i], pubkey, keyimage);
//Increment Counters
i = i + 1;
}
success = (c == signature[1]);
}
function RingVerify_User(address[] memory destination, uint256[] memory value, uint256[] memory signature)
public view returns (bool success)
{
return RingVerify(RingMessage(destination, value), signature);
}
}
| 338,822 | 12,537 |
95ddcb27dd6decc63b3f4eaef0ce6ba8f6248c6f5a41f694659b2589690f02af
| 21,693 |
.sol
|
Solidity
| false |
324379118
|
wc117/dragonballz-protocol
|
40ccb353349a7e534a2022824a642cc0d93f0c5a
|
contracts/governance/GOKUGovernorAlpha.sol
| 4,333 | 17,511 |
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 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;
}
}
contract GovernorAlpha {
/// @notice The name of this contract
string public constant name = "GOKU Governor Alpha";
function quorumVotes() public view returns (uint256) { return SafeMath.div(SafeMath.mul(goku.initSupply(), 4), 100); } // 4% of GOKU
/// @notice The number of votes required in order for a voter to become a proposer
function proposalThreshold() public view returns (uint256) { return SafeMath.div(goku.initSupply(), 100); } // 1% of GOKU
/// @notice The maximum number of actions that can be included in a proposal
function proposalMaxOperations() public pure returns (uint256) { return 10; } // 10 actions
/// @notice The delay before voting on a proposal may take place, once proposed
function votingDelay() public pure returns (uint256) { return 1; } // 1 block
/// @notice The duration of voting on a proposal, in blocks
function votingPeriod() public pure returns (uint256) { return 17280; } // ~3 days in blocks (assuming 15s blocks)
/// @notice The address of the Compound Protocol Timelock
TimelockInterface public timelock;
/// @notice The address of the Compound governance token
GOKUInterface public goku;
/// @notice The address of the Governor Guardian
address public guardian;
/// @notice The total number of proposals
uint256 public proposalCount;
struct Proposal {
/// @notice Unique id for looking up a proposal
uint256 id;
/// @notice Creator of the proposal
address proposer;
uint256 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
uint256 startBlock;
/// @notice The block at which voting ends: votes must be cast prior to this block
uint256 endBlock;
/// @notice Current number of votes in favor of this proposal
uint256 forVotes;
/// @notice Current number of votes in opposition to this proposal
uint256 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
uint256 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 (uint256 => Proposal) public proposals;
/// @notice The latest proposal for each proposer
mapping (address => uint256) 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(uint256 id, address proposer, address[] targets, uint[] values, string[] signatures, bytes[] calldatas, uint256 startBlock, uint256 endBlock, string description);
/// @notice An event emitted when a vote has been cast on a proposal
event VoteCast(address voter, uint256 proposalId, bool support, uint256 votes);
/// @notice An event emitted when a proposal has been canceled
event ProposalCanceled(uint256 id);
/// @notice An event emitted when a proposal has been queued in the Timelock
event ProposalQueued(uint256 id, uint256 eta);
/// @notice An event emitted when a proposal has been executed in the Timelock
event ProposalExecuted(uint256 id);
constructor(address timelock_, address goku_) public {
timelock = TimelockInterface(timelock_);
goku = GOKUInterface(goku_);
guardian = msg.sender;
}
function propose(address[] memory targets,
uint[] memory values,
string[] memory signatures,
bytes[] memory calldatas,
string memory description)
public
returns (uint256)
{
require(goku.getPriorVotes(msg.sender, sub256(block.number, 1)) > proposalThreshold(), "GovernorAlpha::propose: proposer votes below proposal threshold");
require(targets.length == values.length && targets.length == signatures.length && targets.length == calldatas.length, "GovernorAlpha::propose: proposal function information arity mismatch");
require(targets.length != 0, "GovernorAlpha::propose: must provide actions");
require(targets.length <= proposalMaxOperations(), "GovernorAlpha::propose: too many actions");
uint256 latestProposalId = latestProposalIds[msg.sender];
if (latestProposalId != 0) {
ProposalState proposersLatestProposalState = state(latestProposalId);
require(proposersLatestProposalState != ProposalState.Active, "GovernorAlpha::propose: one live proposal per proposer, found an already active proposal");
require(proposersLatestProposalState != ProposalState.Pending, "GovernorAlpha::propose: one live proposal per proposer, found an already pending proposal");
}
uint256 startBlock = add256(block.number, votingDelay());
uint256 endBlock = add256(startBlock, 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(uint256 proposalId)
public
{
require(state(proposalId) == ProposalState.Succeeded, "GovernorAlpha::queue: proposal can only be queued if it is succeeded");
Proposal storage proposal = proposals[proposalId];
uint256 eta = add256(block.timestamp, timelock.delay());
for (uint256 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,
uint256 value,
string memory signature,
bytes memory data,
uint256 eta)
internal
{
require(!timelock.queuedTransactions(keccak256(abi.encode(target,
value,
signature,
data,
eta))),
"GovernorAlpha::_queueOrRevert: proposal action already queued at eta");
timelock.queueTransaction(target, value, signature, data, eta);
}
function execute(uint256 proposalId)
public
payable
{
require(msg.sender == guardian, "Only Guardian can execute transactions"); // Block Governance
require(state(proposalId) == ProposalState.Queued, "GovernorAlpha::execute: proposal can only be executed if it is queued");
Proposal storage proposal = proposals[proposalId];
proposal.executed = true;
for (uint256 i = 0; i < proposal.targets.length; i++) {
timelock.executeTransaction.value(proposal.values[i])(proposal.targets[i], proposal.values[i], proposal.signatures[i], proposal.calldatas[i], proposal.eta);
}
emit ProposalExecuted(proposalId);
}
function cancel(uint256 proposalId)
public
{
ProposalState state = state(proposalId);
require(state != ProposalState.Executed, "GovernorAlpha::cancel: cannot cancel executed proposal");
Proposal storage proposal = proposals[proposalId];
require(msg.sender == guardian || goku.getPriorVotes(proposal.proposer, sub256(block.number, 1)) < proposalThreshold(), "GovernorAlpha::cancel: proposer above threshold");
proposal.canceled = true;
for (uint256 i = 0; i < proposal.targets.length; i++) {
timelock.cancelTransaction(proposal.targets[i], proposal.values[i], proposal.signatures[i], proposal.calldatas[i], proposal.eta);
}
emit ProposalCanceled(proposalId);
}
function getActions(uint256 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(uint256 proposalId, address voter)
public
view
returns (Receipt memory)
{
return proposals[proposalId].receipts[voter];
}
function state(uint256 proposalId)
public
view
returns (ProposalState)
{
require(proposalCount >= proposalId && proposalId > 0, "GovernorAlpha::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 >= add256(proposal.eta, timelock.GRACE_PERIOD())) {
return ProposalState.Expired;
} else {
return ProposalState.Queued;
}
}
function castVote(uint256 proposalId, bool support)
public
{
return _castVote(msg.sender, proposalId, support);
}
function castVoteBySig(uint256 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), "GovernorAlpha::castVoteBySig: invalid signature");
return _castVote(signatory, proposalId, support);
}
function _castVote(address voter,
uint256 proposalId,
bool support)
internal
{
require(false, "voting is disabled"); // disable voting
require(state(proposalId) == ProposalState.Active, "GovernorAlpha::_castVote: voting is closed");
Proposal storage proposal = proposals[proposalId];
Receipt storage receipt = proposal.receipts[voter];
require(receipt.hasVoted == false, "GovernorAlpha::_castVote: voter already voted");
uint256 votes = goku.getPriorVotes(voter, proposal.startBlock);
if (support) {
proposal.forVotes = add256(proposal.forVotes, votes);
} else {
proposal.againstVotes = add256(proposal.againstVotes, votes);
}
receipt.hasVoted = true;
receipt.support = support;
receipt.votes = votes;
emit VoteCast(voter, proposalId, support, votes);
}
function __acceptAdmin()
public
{
require(msg.sender == guardian, "GovernorAlpha::__acceptAdmin: sender must be gov guardian");
timelock.acceptAdmin();
}
function __abdicate()
public
{
require(msg.sender == guardian, "GovernorAlpha::__abdicate: sender must be gov guardian");
guardian = address(0);
}
function __queueSetTimelockPendingAdmin(address newPendingAdmin,
uint256 eta)
public
{
require(msg.sender == guardian, "GovernorAlpha::__queueSetTimelockPendingAdmin: sender must be gov guardian");
timelock.queueTransaction(address(timelock), 0, "setPendingAdmin(address)", abi.encode(newPendingAdmin), eta);
}
function __executeSetTimelockPendingAdmin(address newPendingAdmin,
uint256 eta)
public
{
require(msg.sender == guardian, "GovernorAlpha::__executeSetTimelockPendingAdmin: sender must be gov guardian");
timelock.executeTransaction(address(timelock), 0, "setPendingAdmin(address)", abi.encode(newPendingAdmin), eta);
}
function add256(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "addition overflow");
return c;
}
function sub256(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "subtraction underflow");
return a - b;
}
function getChainId() internal pure returns (uint256) {
uint256 chainId;
assembly { chainId := chainid() }
return chainId;
}
}
interface TimelockInterface {
function delay() external view returns (uint256);
function GRACE_PERIOD() external view returns (uint256);
function acceptAdmin() external;
function queuedTransactions(bytes32 hash) external view returns (bool);
function queueTransaction(address target, uint256 value, string calldata signature, bytes calldata data, uint256 eta) external returns (bytes32);
function cancelTransaction(address target, uint256 value, string calldata signature, bytes calldata data, uint256 eta) external;
function executeTransaction(address target, uint256 value, string calldata signature, bytes calldata data, uint256 eta) external payable returns (bytes memory);
}
interface GOKUInterface {
function getPriorVotes(address account, uint256 blockNumber) external view returns (uint256);
function initSupply() external view returns (uint256);
function _acceptGov() external;
}
| 6,903 | 12,538 |
f04dfc9f1df7eda6e561c28912e2534a44d70d7a39019f87d448e3980cef9319
| 10,584 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xd60dac95ee6dcecf7480417431fc24086cff5134.sol
| 2,621 | 9,961 |
pragma solidity ^0.4.24;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// 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 ForeignToken {
function balanceOf(address _owner) constant public returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant 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 MillenniumNetwork is ERC20 {
using SafeMath for uint256;
address owner = msg.sender;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
mapping (address => bool) public Claimed;
string public constant name = "MillenniumNetwork";
string public constant symbol = "MNW";
uint public constant decimals = 8;
uint public deadline = now + 37 * 1 days;
uint public round2 = now + 32 * 1 days;
uint public round1 = now + 22 * 1 days;
uint256 public totalSupply = 25000000000e8;
uint256 public totalDistributed;
uint256 public constant requestMinimum = 1 ether / 100; // 0.01 Ether
uint256 public tokensPerEth = 20000000e8;
uint public target0drop = 3000;
uint public progress0drop = 0;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Distr(address indexed to, uint256 amount);
event DistrFinished();
event Airdrop(address indexed _owner, uint _amount, uint _balance);
event TokensPerEthUpdated(uint _tokensPerEth);
event Burn(address indexed burner, uint256 value);
event Add(uint256 value);
bool public distributionFinished = false;
modifier canDistr() {
require(!distributionFinished);
_;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
constructor() public {
uint256 teamFund = 3500000000e8;
owner = msg.sender;
distr(owner, teamFund);
}
function transferOwnership(address newOwner) onlyOwner public {
if (newOwner != address(0)) {
owner = newOwner;
}
}
function finishDistribution() onlyOwner canDistr public returns (bool) {
distributionFinished = true;
emit DistrFinished();
return true;
}
function distr(address _to, uint256 _amount) canDistr private returns (bool) {
totalDistributed = totalDistributed.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Distr(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function Distribute(address _participant, uint _amount) onlyOwner internal {
require(_amount > 0);
require(totalDistributed < totalSupply);
balances[_participant] = balances[_participant].add(_amount);
totalDistributed = totalDistributed.add(_amount);
if (totalDistributed >= totalSupply) {
distributionFinished = true;
}
// log
emit Airdrop(_participant, _amount, balances[_participant]);
emit Transfer(address(0), _participant, _amount);
}
function DistributeAirdrop(address _participant, uint _amount) onlyOwner external {
Distribute(_participant, _amount);
}
function DistributeAirdropMultiple(address[] _addresses, uint _amount) onlyOwner external {
for (uint i = 0; i < _addresses.length; i++) Distribute(_addresses[i], _amount);
}
function updateTokensPerEth(uint _tokensPerEth) public onlyOwner {
tokensPerEth = _tokensPerEth;
emit TokensPerEthUpdated(_tokensPerEth);
}
function () external payable {
getTokens();
}
function getTokens() payable canDistr public {
uint256 tokens = 0;
uint256 bonus = 0;
uint256 countbonus = 0;
uint256 bonusCond1 = 1 ether / 10;
uint256 bonusCond2 = 1 ether / 2;
uint256 bonusCond3 = 1 ether;
tokens = tokensPerEth.mul(msg.value) / 1 ether;
address investor = msg.sender;
if (msg.value >= requestMinimum && now < deadline && now < round1 && now < round2) {
if(msg.value >= bonusCond1 && msg.value < bonusCond2){
countbonus = tokens * 0 / 100;
}else if(msg.value >= bonusCond2 && msg.value < bonusCond3){
countbonus = tokens * 0 / 100;
}else if(msg.value >= bonusCond3){
countbonus = tokens * 0 / 100;
}
}else if(msg.value >= requestMinimum && now < deadline && now > round1 && now < round2){
if(msg.value >= bonusCond2 && msg.value < bonusCond3){
countbonus = tokens * 0 / 100;
}else if(msg.value >= bonusCond3){
countbonus = tokens * 0 / 100;
}
}else{
countbonus = 0;
}
bonus = tokens + countbonus;
if (tokens == 0) {
uint256 valdrop = 20000e8;
if (Claimed[investor] == false && progress0drop <= target0drop) {
distr(investor, valdrop);
Claimed[investor] = true;
progress0drop++;
}else{
require(msg.value >= requestMinimum);
}
}else if(tokens > 0 && msg.value >= requestMinimum){
if(now >= deadline && now >= round1 && now < round2){
distr(investor, tokens);
}else{
if(msg.value >= bonusCond1){
distr(investor, bonus);
}else{
distr(investor, tokens);
}
}
}else{
require(msg.value >= requestMinimum);
}
if (totalDistributed >= totalSupply) {
distributionFinished = true;
}
}
function balanceOf(address _owner) constant public returns (uint256) {
return balances[_owner];
}
modifier onlyPayloadSize(uint size) {
assert(msg.data.length >= size + 4);
_;
}
function transfer(address _to, uint256 _amount) onlyPayloadSize(2 * 32) public returns (bool success) {
require(_to != address(0));
require(_amount <= balances[msg.sender]);
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) onlyPayloadSize(3 * 32) public returns (bool success) {
require(_to != address(0));
require(_amount <= balances[_from]);
require(_amount <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_amount);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
emit Transfer(_from, _to, _amount);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool success) {
if (_value != 0 && allowed[msg.sender][_spender] != 0) { return false; }
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant public returns (uint256) {
return allowed[_owner][_spender];
}
function getTokenBalance(address tokenAddress, address who) constant public returns (uint){
ForeignToken t = ForeignToken(tokenAddress);
uint bal = t.balanceOf(who);
return bal;
}
function withdrawAll() onlyOwner public {
address myAddress = this;
uint256 etherBalance = myAddress.balance;
owner.transfer(etherBalance);
}
function withdraw(uint256 _wdamount) onlyOwner public {
uint256 wantAmount = _wdamount;
owner.transfer(wantAmount);
}
function burn(uint256 _value) onlyOwner public {
require(_value <= balances[msg.sender]);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply = totalSupply.sub(_value);
totalDistributed = totalDistributed.sub(_value);
emit Burn(burner, _value);
}
function add(uint256 _value) onlyOwner public {
uint256 counter = totalSupply.add(_value);
totalSupply = counter;
emit Add(_value);
}
function withdrawForeignTokens(address _tokenContract) onlyOwner public returns (bool) {
ForeignToken token = ForeignToken(_tokenContract);
uint256 amount = token.balanceOf(address(this));
return token.transfer(owner, amount);
}
}
| 176,706 | 12,539 |
534b4eeeb8b088aaaf895b7d5ff55aab48810eeaf3ea6813f5cb794f1f20dc83
| 19,310 |
.sol
|
Solidity
| false |
608566042
|
Decurity/compound-semgrep-rules
|
ce8ce245d090ae0bca064c17eb3436a8c154ce40
|
solidity/state-changing-func-does-not-emit-event.sol
| 4,804 | 19,248 |
pragma solidity 0.8.15;
contract Configurator is ConfiguratorStorage {
event AddAsset(address indexed cometProxy, AssetConfig assetConfig);
event CometDeployed(address indexed cometProxy, address indexed newComet);
event GovernorTransferred(address indexed oldGovernor, address indexed newGovernor);
event SetFactory(address indexed cometProxy, address indexed oldFactory, address indexed newFactory);
event SetGovernor(address indexed cometProxy, address indexed oldGovernor, address indexed newGovernor);
event SetConfiguration(address indexed cometProxy, Configuration oldConfiguration, Configuration newConfiguration);
event SetPauseGuardian(address indexed cometProxy, address indexed oldPauseGuardian, address indexed newPauseGuardian);
event SetBaseTokenPriceFeed(address indexed cometProxy, address indexed oldBaseTokenPriceFeed, address indexed newBaseTokenPriceFeed);
event SetExtensionDelegate(address indexed cometProxy, address indexed oldExt, address indexed newExt);
event SetSupplyKink(address indexed cometProxy,uint64 oldKink, uint64 newKink);
event SetSupplyPerYearInterestRateSlopeLow(address indexed cometProxy,uint64 oldIRSlopeLow, uint64 newIRSlopeLow);
event SetSupplyPerYearInterestRateSlopeHigh(address indexed cometProxy,uint64 oldIRSlopeHigh, uint64 newIRSlopeHigh);
event SetSupplyPerYearInterestRateBase(address indexed cometProxy,uint64 oldIRBase, uint64 newIRBase);
event SetBorrowKink(address indexed cometProxy,uint64 oldKink, uint64 newKink);
event SetBorrowPerYearInterestRateSlopeLow(address indexed cometProxy,uint64 oldIRSlopeLow, uint64 newIRSlopeLow);
event SetBorrowPerYearInterestRateSlopeHigh(address indexed cometProxy,uint64 oldIRSlopeHigh, uint64 newIRSlopeHigh);
event SetBorrowPerYearInterestRateBase(address indexed cometProxy,uint64 oldIRBase, uint64 newIRBase);
event SetStoreFrontPriceFactor(address indexed cometProxy, uint64 oldStoreFrontPriceFactor, uint64 newStoreFrontPriceFactor);
event SetBaseTrackingSupplySpeed(address indexed cometProxy, uint64 oldBaseTrackingSupplySpeed, uint64 newBaseTrackingSupplySpeed);
event SetBaseTrackingBorrowSpeed(address indexed cometProxy, uint64 oldBaseTrackingBorrowSpeed, uint64 newBaseTrackingBorrowSpeed);
event SetBaseMinForRewards(address indexed cometProxy, uint104 oldBaseMinForRewards, uint104 newBaseMinForRewards);
event SetBaseBorrowMin(address indexed cometProxy, uint104 oldBaseBorrowMin, uint104 newBaseBorrowMin);
event SetTargetReserves(address indexed cometProxy, uint104 oldTargetReserves, uint104 newTargetReserves);
event UpdateAsset(address indexed cometProxy, AssetConfig oldAssetConfig, AssetConfig newAssetConfig);
event UpdateAssetPriceFeed(address indexed cometProxy, address indexed asset, address oldPriceFeed, address newPriceFeed);
event UpdateAssetBorrowCollateralFactor(address indexed cometProxy, address indexed asset, uint64 oldBorrowCF, uint64 newBorrowCF);
event UpdateAssetLiquidateCollateralFactor(address indexed cometProxy, address indexed asset, uint64 oldLiquidateCF, uint64 newLiquidateCF);
event UpdateAssetLiquidationFactor(address indexed cometProxy, address indexed asset, uint64 oldLiquidationFactor, uint64 newLiquidationFactor);
event UpdateAssetSupplyCap(address indexed cometProxy, address indexed asset, uint128 oldSupplyCap, uint128 newSupplyCap);
error AlreadyInitialized();
error AssetDoesNotExist();
error ConfigurationAlreadyExists();
error InvalidAddress();
error Unauthorized();
constructor() {
version = type(uint256).max;
}
function initialize(address governor_) public {
if (version != 0) revert AlreadyInitialized();
if (governor_ == address(0)) revert InvalidAddress();
governor = governor_;
version = 1;
}
//ok: state-changing-func-does-not-emit-event
function setFactory(address cometProxy, address newFactory) external {
if (msg.sender != governor) revert Unauthorized();
address oldFactory = factory[cometProxy];
factory[cometProxy] = newFactory;
emit SetFactory(cometProxy, oldFactory, newFactory);
}
//ok: state-changing-func-does-not-emit-event
function setFactoryNoAccessControlTest(address cometProxy, address newFactory) external {
address oldFactory = factory[cometProxy];
factory[cometProxy] = newFactory;
emit SetFactory(cometProxy, oldFactory, newFactory);
}
//ruleid: state-changing-func-does-not-emit-event
function setFactoryNoEventEmit(address cometProxy, address newFactory) external {
if (msg.sender != governor) revert Unauthorized();
address oldFactory = factory[cometProxy];
factory[cometProxy] = newFactory;
}
//ruleid: state-changing-func-does-not-emit-event
function setFactoryNoEventEmitAndAccessControl(address cometProxy, address newFactory) external {
address oldFactory = factory[cometProxy];
factory[cometProxy] = newFactory;
}
//Timelock ok: state-changing-func-does-not-emit-event
function setPendingAdmin(address pendingAdmin_) public {
require(msg.sender == address(this), "Timelock::setPendingAdmin: Call must come from Timelock.");
pendingAdmin = pendingAdmin_;
emit NewPendingAdmin(pendingAdmin);
}
//ok: state-changing-func-does-not-emit-event
function setConfiguration(address cometProxy, Configuration calldata newConfiguration) external {
if (msg.sender != governor) revert Unauthorized();
Configuration memory oldConfiguration = configuratorParams[cometProxy];
if (oldConfiguration.baseToken != address(0) &&
(oldConfiguration.baseToken != newConfiguration.baseToken ||
oldConfiguration.trackingIndexScale != newConfiguration.trackingIndexScale))
revert ConfigurationAlreadyExists();
configuratorParams[cometProxy] = newConfiguration;
emit SetConfiguration(cometProxy, oldConfiguration, newConfiguration);
}
//ok: state-changing-func-does-not-emit-event
function setGovernor(address cometProxy, address newGovernor) external {
if (msg.sender != governor) revert Unauthorized();
address oldGovernor = configuratorParams[cometProxy].governor;
configuratorParams[cometProxy].governor = newGovernor;
emit SetGovernor(cometProxy, oldGovernor, newGovernor);
}
//ok: state-changing-func-does-not-emit-event
function setPauseGuardian(address cometProxy, address newPauseGuardian) external {
if (msg.sender != governor) revert Unauthorized();
address oldPauseGuardian = configuratorParams[cometProxy].pauseGuardian;
configuratorParams[cometProxy].pauseGuardian = newPauseGuardian;
emit SetPauseGuardian(cometProxy, oldPauseGuardian, newPauseGuardian);
}
//ok: state-changing-func-does-not-emit-event
function setBaseTokenPriceFeed(address cometProxy, address newBaseTokenPriceFeed) external {
if (msg.sender != governor) revert Unauthorized();
address oldBaseTokenPriceFeed = configuratorParams[cometProxy].baseTokenPriceFeed;
configuratorParams[cometProxy].baseTokenPriceFeed = newBaseTokenPriceFeed;
emit SetBaseTokenPriceFeed(cometProxy, oldBaseTokenPriceFeed, newBaseTokenPriceFeed);
}
//ok: state-changing-func-does-not-emit-event
function setExtensionDelegate(address cometProxy, address newExtensionDelegate) external {
if (msg.sender != governor) revert Unauthorized();
address oldExtensionDelegate = configuratorParams[cometProxy].extensionDelegate;
configuratorParams[cometProxy].extensionDelegate = newExtensionDelegate;
emit SetExtensionDelegate(cometProxy, oldExtensionDelegate, newExtensionDelegate);
}
//ok: state-changing-func-does-not-emit-event
function setSupplyKink(address cometProxy, uint64 newSupplyKink) external {
if (msg.sender != governor) revert Unauthorized();
uint64 oldSupplyKink = configuratorParams[cometProxy].supplyKink;
configuratorParams[cometProxy].supplyKink = newSupplyKink;
emit SetSupplyKink(cometProxy, oldSupplyKink, newSupplyKink);
}
//ok: state-changing-func-does-not-emit-event
function setSupplyPerYearInterestRateSlopeLow(address cometProxy, uint64 newSlope) external {
if (msg.sender != governor) revert Unauthorized();
uint64 oldSlope = configuratorParams[cometProxy].supplyPerYearInterestRateSlopeLow;
configuratorParams[cometProxy].supplyPerYearInterestRateSlopeLow = newSlope;
emit SetSupplyPerYearInterestRateSlopeLow(cometProxy, oldSlope, newSlope);
}
//ok: state-changing-func-does-not-emit-event
function setSupplyPerYearInterestRateSlopeHigh(address cometProxy, uint64 newSlope) external {
if (msg.sender != governor) revert Unauthorized();
uint64 oldSlope = configuratorParams[cometProxy].supplyPerYearInterestRateSlopeHigh;
configuratorParams[cometProxy].supplyPerYearInterestRateSlopeHigh = newSlope;
emit SetSupplyPerYearInterestRateSlopeHigh(cometProxy, oldSlope, newSlope);
}
//ok: state-changing-func-does-not-emit-event
function setSupplyPerYearInterestRateBase(address cometProxy, uint64 newBase) external {
if (msg.sender != governor) revert Unauthorized();
uint64 oldBase = configuratorParams[cometProxy].supplyPerYearInterestRateBase;
configuratorParams[cometProxy].supplyPerYearInterestRateBase = newBase;
emit SetSupplyPerYearInterestRateBase(cometProxy, oldBase, newBase);
}
//ok: state-changing-func-does-not-emit-event
function setBorrowKink(address cometProxy, uint64 newBorrowKink) external {
if (msg.sender != governor) revert Unauthorized();
uint64 oldBorrowKink = configuratorParams[cometProxy].borrowKink;
configuratorParams[cometProxy].borrowKink = newBorrowKink;
emit SetBorrowKink(cometProxy, oldBorrowKink, newBorrowKink);
}
//ok: state-changing-func-does-not-emit-event
function setBorrowPerYearInterestRateSlopeLow(address cometProxy, uint64 newSlope) external {
if (msg.sender != governor) revert Unauthorized();
uint64 oldSlope = configuratorParams[cometProxy].borrowPerYearInterestRateSlopeLow;
configuratorParams[cometProxy].borrowPerYearInterestRateSlopeLow = newSlope;
emit SetBorrowPerYearInterestRateSlopeLow(cometProxy, oldSlope, newSlope);
}
//ok: state-changing-func-does-not-emit-event
function setBorrowPerYearInterestRateSlopeHigh(address cometProxy, uint64 newSlope) external {
if (msg.sender != governor) revert Unauthorized();
uint64 oldSlope = configuratorParams[cometProxy].borrowPerYearInterestRateSlopeHigh;
configuratorParams[cometProxy].borrowPerYearInterestRateSlopeHigh = newSlope;
emit SetBorrowPerYearInterestRateSlopeHigh(cometProxy, oldSlope, newSlope);
}
//ok: state-changing-func-does-not-emit-event
function setBorrowPerYearInterestRateBase(address cometProxy, uint64 newBase) external {
if (msg.sender != governor) revert Unauthorized();
uint64 oldBase = configuratorParams[cometProxy].borrowPerYearInterestRateBase;
configuratorParams[cometProxy].borrowPerYearInterestRateBase = newBase;
emit SetBorrowPerYearInterestRateBase(cometProxy, oldBase, newBase);
}
//ok: state-changing-func-does-not-emit-event
function setStoreFrontPriceFactor(address cometProxy, uint64 newStoreFrontPriceFactor) external {
if (msg.sender != governor) revert Unauthorized();
uint64 oldStoreFrontPriceFactor = configuratorParams[cometProxy].storeFrontPriceFactor;
configuratorParams[cometProxy].storeFrontPriceFactor = newStoreFrontPriceFactor;
emit SetStoreFrontPriceFactor(cometProxy, oldStoreFrontPriceFactor, newStoreFrontPriceFactor);
}
//ok: state-changing-func-does-not-emit-event
function setBaseTrackingSupplySpeed(address cometProxy, uint64 newBaseTrackingSupplySpeed) external {
if (msg.sender != governor) revert Unauthorized();
uint64 oldBaseTrackingSupplySpeed = configuratorParams[cometProxy].baseTrackingSupplySpeed;
configuratorParams[cometProxy].baseTrackingSupplySpeed = newBaseTrackingSupplySpeed;
emit SetBaseTrackingSupplySpeed(cometProxy, oldBaseTrackingSupplySpeed, newBaseTrackingSupplySpeed);
}
//ok: state-changing-func-does-not-emit-event
function setBaseTrackingBorrowSpeed(address cometProxy, uint64 newBaseTrackingBorrowSpeed) external {
if (msg.sender != governor) revert Unauthorized();
uint64 oldBaseTrackingBorrowSpeed = configuratorParams[cometProxy].baseTrackingBorrowSpeed;
configuratorParams[cometProxy].baseTrackingBorrowSpeed = newBaseTrackingBorrowSpeed;
emit SetBaseTrackingBorrowSpeed(cometProxy, oldBaseTrackingBorrowSpeed, newBaseTrackingBorrowSpeed);
}
//ok: state-changing-func-does-not-emit-event
function setBaseMinForRewards(address cometProxy, uint104 newBaseMinForRewards) external {
if (msg.sender != governor) revert Unauthorized();
uint104 oldBaseMinForRewards = configuratorParams[cometProxy].baseMinForRewards;
configuratorParams[cometProxy].baseMinForRewards = newBaseMinForRewards;
emit SetBaseMinForRewards(cometProxy, oldBaseMinForRewards, newBaseMinForRewards);
}
//ok: state-changing-func-does-not-emit-event
function setBaseBorrowMin(address cometProxy, uint104 newBaseBorrowMin) external {
if (msg.sender != governor) revert Unauthorized();
uint104 oldBaseBorrowMin = configuratorParams[cometProxy].baseBorrowMin;
configuratorParams[cometProxy].baseBorrowMin = newBaseBorrowMin;
emit SetBaseBorrowMin(cometProxy, oldBaseBorrowMin, newBaseBorrowMin);
}
//ok: state-changing-func-does-not-emit-event
function setTargetReserves(address cometProxy, uint104 newTargetReserves) external {
if (msg.sender != governor) revert Unauthorized();
uint104 oldTargetReserves = configuratorParams[cometProxy].targetReserves;
configuratorParams[cometProxy].targetReserves = newTargetReserves;
emit SetTargetReserves(cometProxy, oldTargetReserves, newTargetReserves);
}
//ok: state-changing-func-does-not-emit-event
function addAsset(address cometProxy, AssetConfig calldata assetConfig) external {
if (msg.sender != governor) revert Unauthorized();
configuratorParams[cometProxy].assetConfigs.push(assetConfig);
emit AddAsset(cometProxy, assetConfig);
}
//ok: state-changing-func-does-not-emit-event
function updateAsset(address cometProxy, AssetConfig calldata newAssetConfig) external {
if (msg.sender != governor) revert Unauthorized();
uint assetIndex = getAssetIndex(cometProxy, newAssetConfig.asset);
AssetConfig memory oldAssetConfig = configuratorParams[cometProxy].assetConfigs[assetIndex];
configuratorParams[cometProxy].assetConfigs[assetIndex] = newAssetConfig;
emit UpdateAsset(cometProxy, oldAssetConfig, newAssetConfig);
}
//ok: state-changing-func-does-not-emit-event
function updateAssetPriceFeed(address cometProxy, address asset, address newPriceFeed) external {
if (msg.sender != governor) revert Unauthorized();
uint assetIndex = getAssetIndex(cometProxy, asset);
address oldPriceFeed = configuratorParams[cometProxy].assetConfigs[assetIndex].priceFeed;
configuratorParams[cometProxy].assetConfigs[assetIndex].priceFeed = newPriceFeed;
emit UpdateAssetPriceFeed(cometProxy, asset, oldPriceFeed, newPriceFeed);
}
//ok: state-changing-func-does-not-emit-event
function updateAssetBorrowCollateralFactor(address cometProxy, address asset, uint64 newBorrowCF) external {
if (msg.sender != governor) revert Unauthorized();
uint assetIndex = getAssetIndex(cometProxy, asset);
uint64 oldBorrowCF = configuratorParams[cometProxy].assetConfigs[assetIndex].borrowCollateralFactor;
configuratorParams[cometProxy].assetConfigs[assetIndex].borrowCollateralFactor = newBorrowCF;
emit UpdateAssetBorrowCollateralFactor(cometProxy, asset, oldBorrowCF, newBorrowCF);
}
//ok: state-changing-func-does-not-emit-event
function updateAssetLiquidateCollateralFactor(address cometProxy, address asset, uint64 newLiquidateCF) external {
if (msg.sender != governor) revert Unauthorized();
uint assetIndex = getAssetIndex(cometProxy, asset);
uint64 oldLiquidateCF = configuratorParams[cometProxy].assetConfigs[assetIndex].liquidateCollateralFactor;
configuratorParams[cometProxy].assetConfigs[assetIndex].liquidateCollateralFactor = newLiquidateCF;
emit UpdateAssetLiquidateCollateralFactor(cometProxy, asset, oldLiquidateCF, newLiquidateCF);
}
//ok: state-changing-func-does-not-emit-event
function updateAssetLiquidationFactor(address cometProxy, address asset, uint64 newLiquidationFactor) external {
if (msg.sender != governor) revert Unauthorized();
uint assetIndex = getAssetIndex(cometProxy, asset);
uint64 oldLiquidationFactor = configuratorParams[cometProxy].assetConfigs[assetIndex].liquidationFactor;
configuratorParams[cometProxy].assetConfigs[assetIndex].liquidationFactor = newLiquidationFactor;
emit UpdateAssetLiquidationFactor(cometProxy, asset, oldLiquidationFactor, newLiquidationFactor);
}
//ok: state-changing-func-does-not-emit-event
function updateAssetSupplyCap(address cometProxy, address asset, uint128 newSupplyCap) external {
if (msg.sender != governor) revert Unauthorized();
uint assetIndex = getAssetIndex(cometProxy, asset);
uint128 oldSupplyCap = configuratorParams[cometProxy].assetConfigs[assetIndex].supplyCap;
configuratorParams[cometProxy].assetConfigs[assetIndex].supplyCap = newSupplyCap;
emit UpdateAssetSupplyCap(cometProxy, asset, oldSupplyCap, newSupplyCap);
}
function getAssetIndex(address cometProxy, address asset) public view returns (uint) {
AssetConfig[] memory assetConfigs = configuratorParams[cometProxy].assetConfigs;
uint numAssets = assetConfigs.length;
for (uint i = 0; i < numAssets;) {
if (assetConfigs[i].asset == asset) {
return i;
}
unchecked { i++; }
}
revert AssetDoesNotExist();
}
function getConfiguration(address cometProxy) external view returns (Configuration memory) {
return configuratorParams[cometProxy];
}
function deploy(address cometProxy) external returns (address) {
address newComet = CometFactory(factory[cometProxy]).clone(configuratorParams[cometProxy]);
emit CometDeployed(cometProxy, newComet);
return newComet;
}
function transferGovernor(address newGovernor) external {
if (msg.sender != governor) revert Unauthorized();
address oldGovernor = governor;
governor = newGovernor;
emit GovernorTransferred(oldGovernor, newGovernor);
}
}
| 337,525 | 12,540 |
4634f95faed5e71ffaf8f98bd3233192a5a106d4d2f6f30206beecd0ab0b0f5d
| 17,128 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0x2ccbfba2cc646715d67dbf515d65d1aae6b98db6.sol
| 4,169 | 17,042 |
pragma solidity >= 0.4.24;
interface erc20 {
function name() external returns (string);
function symbol() external returns (string);
function decimals() external returns (uint8);
function transfer(address receiver, uint amount) external;
function transferFrom(address from, address to, uint value) external;
function balanceOf(address tokenOwner) constant external returns (uint balance);
function allowance(address _owner, address _spender) constant external returns (uint remaining);
}
contract againstTokenRegister {
string public name = "AGAINST TKDEX";
string public symbol = "AGAINST";
string public comment = "AGAINST Token Index & Full DEX 1.0";
address internal owner;
uint public indexCount = 0;
uint public registerFee = 0;
uint public ratePlaces = 9;
uint public openMarketFee = 0;
uint public actionFee = 10**15;
uint public garbageFees = 0;
uint internal minQtd = (10**18)/(10**4);
event orderPlaced(address token, address tokenPair, address ownerId, uint orderId);
event orderDone(address token, address tokenPair, uint orderId, uint doneId);
event orderCanceled(address token, address tokenPair, uint orderId);
event orderRemovedLowBalance(address token, address tokenPair, uint orderId);
event ctrWithdraw(address wallet, uint value);
struct order {
uint orderId;
address orderOwner;
uint rate;
uint amount;
bool sell;
uint date;
}
struct done {
uint orderId;
address fillOwner;
uint fillAmount;
uint fillDate;
uint rate;
}
struct market {
bool exists;
address tokenPair;
uint ordersCount;
uint donesCount;
mapping(uint => order) orders;
mapping(uint => done) dones;
}
struct voted {
bool like;
bool dislike;
}
struct token {
address tokenBase;
string name;
string symbol;
uint decimals;
uint likesCount;
uint dislikesCount;
uint marketsCount;
mapping(uint => address) marketIndex;
mapping(address => market) markets;
mapping(address => voted) voteStatus;
}
mapping(uint => address) public index;
mapping(address => token) public tokens;
mapping(address => bool) public exists;
constructor() public {
owner = address(msg.sender);
}
function () public {
bool pass = false;
require(pass,"Nothing Here");
}
function getTokenByAddr(address _addr) public view returns (string _name,
string _symbol,
uint _decimals,
uint _marketsCount) {
return (tokens[_addr].name,
tokens[_addr].symbol,
tokens[_addr].decimals,
tokens[_addr].marketsCount);
}
function getTokenByIndex(uint _index) public view returns (address _tokenBase,
string _name,
string _symbol,
uint _decimals,
uint _marketsCount) {
return (tokens[index[_index]].tokenBase,
tokens[index[_index]].name,
tokens[index[_index]].symbol,
tokens[index[_index]].decimals,
tokens[index[_index]].marketsCount);
}
function getLikesByAddr(address _addr) public view returns (uint _likesCount, uint _dislikesCount) {
return (tokens[_addr].likesCount, tokens[_addr].dislikesCount);
}
function getVoteStatus(address _addr) public view returns (bool _like, bool _dislike) {
return (tokens[_addr].voteStatus[msg.sender].like, tokens[_addr].voteStatus[msg.sender].dislike);
}
function getLikesByIndex(uint _index) public view returns (address tokenBase, uint _likesCount, uint _dislikesCount) {
return (tokens[index[_index]].tokenBase, tokens[index[_index]].likesCount, tokens[index[_index]].dislikesCount);
}
function getPairByAddr(address _base, address _pairAddr) public view returns (uint _ordersCount, uint _donesCount, bool _exists) {
return (tokens[_base].markets[_pairAddr].ordersCount,
tokens[_base].markets[_pairAddr].donesCount,
tokens[_base].markets[_pairAddr].exists);
}
function getPairByIndex(address _base, uint _pairIndex) public view returns (address _tokenPair, uint _ordersCount, uint _donesCount) {
return (tokens[_base].markets[tokens[_base].marketIndex[_pairIndex]].tokenPair,
tokens[_base].markets[tokens[_base].marketIndex[_pairIndex]].ordersCount,
tokens[_base].markets[tokens[_base].marketIndex[_pairIndex]].donesCount);
}
function getOrders(address _base, address _pair, uint _orderIndex) public view returns (uint _orderId,
address _owner,
uint _rate,
uint _amount,
bool _sell) {
return (tokens[_base].markets[_pair].orders[_orderIndex].orderId,
tokens[_base].markets[_pair].orders[_orderIndex].orderOwner,
tokens[_base].markets[_pair].orders[_orderIndex].rate,
tokens[_base].markets[_pair].orders[_orderIndex].amount,
tokens[_base].markets[_pair].orders[_orderIndex].sell);
}
function getDones(address _base, address _pair, uint _doneIndex) public view returns (uint _orderId,
address _fillOwner,
uint _fillAmount,
uint _fillDate,
uint _rate) {
return (tokens[_base].markets[_pair].dones[_doneIndex].orderId,
tokens[_base].markets[_pair].dones[_doneIndex].fillOwner,
tokens[_base].markets[_pair].dones[_doneIndex].fillAmount,
tokens[_base].markets[_pair].dones[_doneIndex].fillDate,
tokens[_base].markets[_pair].dones[_doneIndex].rate);
}
function changeOwner(address _newOwner) public {
if (msg.sender == owner) {
owner = _newOwner;
}
}
function registerToken(address _token) public payable {
require((msg.sender == owner) || (msg.value >= registerFee), "Register Fee Very Low");
erc20 refToken = erc20(_token);
if (!exists[_token]) {
indexCount = indexCount+1;
index[indexCount] = _token;
tokens[_token].tokenBase = _token;
tokens[_token].name = refToken.name();
tokens[_token].symbol = refToken.symbol();
tokens[_token].decimals = refToken.decimals();
tokens[_token].likesCount = 0;
tokens[_token].dislikesCount = 0;
tokens[_token].marketsCount = 0;
exists[_token] = true;
}
}
function createMarket(address _token, address _tokenPair) public payable {
require(msg.value >= openMarketFee, "Open Market Fee Very Low");
require(exists[_token] && exists[_tokenPair],"token or tokenPair not listed");
require(!tokens[_token].markets[_tokenPair].exists,"Market already exists");
require(tokens[_token].tokenBase != _tokenPair,"Not allowed token = tokenPair");
tokens[_token].marketsCount = tokens[_token].marketsCount+1;
tokens[_token].marketIndex[tokens[_token].marketsCount] = _tokenPair;
tokens[_token].markets[_tokenPair].tokenPair = _tokenPair;
tokens[_token].markets[_tokenPair].ordersCount = 0;
tokens[_token].markets[_tokenPair].donesCount = 0;
tokens[_token].markets[_tokenPair].exists = true;
}
function createOrder(address _token, address _tokenPair, uint _rate, uint _amount, bool _sell) public payable {
require(msg.value >= actionFee);
require(_token != _tokenPair,"Not allowed token = tokenPair");
require(exists[_token] && exists[_tokenPair],"Token or tokenPair not listed");
require((_rate > 0) && (_rate <= (10**(ratePlaces*2)) && (_amount > 0) && (_amount <= 10**36)),"Invalid Values");
tokens[_token].markets[_tokenPair].ordersCount = tokens[_token].markets[_tokenPair].ordersCount+1;
tokens[_token].markets[_tokenPair].orders[tokens[_token].markets[_tokenPair].ordersCount].orderId = tokens[_token].markets[_tokenPair].ordersCount;
tokens[_token].markets[_tokenPair].orders[tokens[_token].markets[_tokenPair].ordersCount].orderOwner = msg.sender;
tokens[_token].markets[_tokenPair].orders[tokens[_token].markets[_tokenPair].ordersCount].rate = _rate;
tokens[_token].markets[_tokenPair].orders[tokens[_token].markets[_tokenPair].ordersCount].amount = _amount;
tokens[_token].markets[_tokenPair].orders[tokens[_token].markets[_tokenPair].ordersCount].sell = _sell;
tokens[_token].markets[_tokenPair].orders[tokens[_token].markets[_tokenPair].ordersCount].date = now;
garbageFees += actionFee;
emit orderPlaced(_token, _tokenPair, msg.sender, tokens[_token].markets[_tokenPair].ordersCount);
}
function tokenLike(address _token) public {
require(exists[_token], "Token not listed");
if (!tokens[_token].voteStatus[msg.sender].like) {
tokens[_token].likesCount = tokens[_token].likesCount+1;
tokens[_token].voteStatus[msg.sender].like = true;
if (tokens[_token].voteStatus[msg.sender].dislike) {
tokens[_token].dislikesCount = tokens[_token].dislikesCount-1;
tokens[_token].voteStatus[msg.sender].dislike = false;
}
} else {
tokens[_token].likesCount = tokens[_token].likesCount-1;
tokens[_token].voteStatus[msg.sender].like = false;
}
}
function tokenDislike(address _token) public {
require(exists[_token],"Token not listed");
if (!tokens[_token].voteStatus[msg.sender].dislike) {
tokens[_token].dislikesCount = tokens[_token].dislikesCount+1;
tokens[_token].voteStatus[msg.sender].dislike = true;
if (tokens[_token].voteStatus[msg.sender].like) {
tokens[_token].likesCount = tokens[_token].likesCount-1;
tokens[_token].voteStatus[msg.sender].like = false;
}
} else {
tokens[_token].dislikesCount = tokens[_token].dislikesCount-1;
tokens[_token].voteStatus[msg.sender].dislike = false;
}
}
function changeRegisterFee(uint _registerFee) public {
require(msg.sender == owner);
registerFee = _registerFee;
}
function changeOpenMarketFee(uint _openMarketFee) public {
require(msg.sender == owner,"Access denied");
openMarketFee = _openMarketFee;
}
function changeActionFee(uint _actionFee) public {
require(msg.sender == owner,"Access denied");
actionFee = _actionFee;
}
function withdraw(uint amount) public {
require(owner == msg.sender,"Only for owner");
require(amount+garbageFees <= address(this).balance,"No funds");
if (owner.send(amount)) {
emit ctrWithdraw(owner, amount);
}
}
function cancelOrder(uint _orderId, address _token, address _tokenPair) public payable {
require(tokens[_token].markets[_tokenPair].ordersCount > 0, "bof orders");
uint orderAmount = tokens[_token].markets[_tokenPair].orders[_orderId].amount;
erc20 tokenMaker = erc20(tokens[_token].tokenBase);
if (tokens[_token].markets[_tokenPair].orders[_orderId].orderOwner != msg.sender) {
require((tokenMaker.allowance(tokens[_token].markets[_tokenPair].orders[_orderId].orderOwner, address(this)) < orderAmount) ||
(tokenMaker.balanceOf(tokens[_token].markets[_tokenPair].orders[_orderId].orderOwner) < orderAmount), "Only garbage can be removed by you here");
}
uint top = tokens[_token].markets[_tokenPair].ordersCount;
tokens[_token].markets[_tokenPair].ordersCount = tokens[_token].markets[_tokenPair].ordersCount-1;
if (tokens[_token].markets[_tokenPair].orders[top].amount > 0) {
tokens[_token].markets[_tokenPair].orders[_orderId] = tokens[_token].markets[_tokenPair].orders[top];
tokens[_token].markets[_tokenPair].orders[_orderId].orderId = _orderId;
tokens[_token].markets[_tokenPair].orders[top].amount = 0;
}
emit orderCanceled(_token, _tokenPair, _orderId);
if (garbageFees >= actionFee) {
garbageFees -= actionFee;
if (msg.sender.send(actionFee)) {
emit ctrWithdraw(msg.sender, actionFee);
}
}
}
function fillOrder(uint _orderID, address _token, address _tokenPair, uint _rate, uint _amountFill) public payable {
require(tokens[_token].markets[_tokenPair].orders[_orderID].orderId > 0,"Not placed");
require((_amountFill > 0) && (_amountFill <= 10**36),"Fill out of range");
require(_rate == tokens[_token].markets[_tokenPair].orders[_orderID].rate,"Rate error");
erc20 tokenMaker = erc20(tokens[_token].tokenBase);
erc20 tokenTaker = erc20(tokens[_token].markets[_tokenPair].tokenPair);
uint amount = (((_amountFill*tokens[_token].markets[_tokenPair].orders[_orderID].rate)/(10**tokens[_tokenPair].decimals))*(10**tokens[_token].decimals))/(10**ratePlaces);
require(tokenTaker.allowance(msg.sender, address(this)) >= _amountFill, "Verify taker approval");
require(tokenTaker.balanceOf(msg.sender) >= _amountFill, "Verify taker balance");
require(tokenMaker.allowance(tokens[_token].markets[_tokenPair].orders[_orderID].orderOwner, address(this)) >= amount, "Verify maker approval");
require(tokenMaker.balanceOf(tokens[_token].markets[_tokenPair].orders[_orderID].orderOwner) >= amount, "Verify maker balance");
require(tokens[_token].markets[_tokenPair].orders[_orderID].amount >= amount,"Amount error");
tokens[_token].markets[_tokenPair].orders[_orderID].amount=tokens[_token].markets[_tokenPair].orders[_orderID].amount-amount;
tokenMaker.transferFrom(tokens[_token].markets[_tokenPair].orders[_orderID].orderOwner, msg.sender,amount);
tokenTaker.transferFrom(msg.sender,tokens[_token].markets[_tokenPair].orders[_orderID].orderOwner,_amountFill);
tokens[_token].markets[_tokenPair].donesCount = tokens[_token].markets[_tokenPair].donesCount+1;
tokens[_token].markets[_tokenPair].dones[tokens[_token].markets[_tokenPair].donesCount].orderId = _orderID;
tokens[_token].markets[_tokenPair].dones[tokens[_token].markets[_tokenPair].donesCount].fillOwner = msg.sender;
tokens[_token].markets[_tokenPair].dones[tokens[_token].markets[_tokenPair].donesCount].fillAmount = _amountFill;
tokens[_token].markets[_tokenPair].dones[tokens[_token].markets[_tokenPair].donesCount].fillDate = now;
tokens[_token].markets[_tokenPair].dones[tokens[_token].markets[_tokenPair].donesCount].rate = _rate;
emit orderDone(_token, _tokenPair, _orderID, tokens[_token].markets[_tokenPair].donesCount);
if (tokens[_token].markets[_tokenPair].orders[_orderID].amount*(10**(18-tokens[_token].decimals)) < minQtd) {
require(tokens[_token].markets[_tokenPair].ordersCount > 0, "bof orders");
uint top = tokens[_token].markets[_tokenPair].ordersCount;
tokens[_token].markets[_tokenPair].ordersCount = tokens[_token].markets[_tokenPair].ordersCount-1;
if (garbageFees >= actionFee) {
garbageFees -= actionFee;
if (address(tokens[_token].markets[_tokenPair].orders[_orderID].orderOwner).send(actionFee)) {
emit ctrWithdraw(address(tokens[_token].markets[_tokenPair].orders[_orderID].orderOwner), actionFee);
}
}
if (tokens[_token].markets[_tokenPair].orders[top].amount > 0) {
tokens[_token].markets[_tokenPair].orders[_orderID] = tokens[_token].markets[_tokenPair].orders[top];
tokens[_token].markets[_tokenPair].orders[_orderID].orderId = _orderID;
tokens[_token].markets[_tokenPair].orders[top].amount = 0;
}
emit orderRemovedLowBalance(_token, _tokenPair, _orderID);
}
}
}
| 167,406 | 12,541 |
743dfced673680f734d78dbdcd3a852ee12535f0f9c1f8f3bdfc9bf0b7e6daba
| 14,314 |
.sol
|
Solidity
| false |
441123437
|
1052445594/SoliDetector
|
171e0750225e445c2993f04ef32ad65a82342054
|
Solidifi-bugInjection-data/Integer_overflow_and_underflow/Sol/buggy_25.sol
| 4,501 | 14,201 |
pragma solidity ^0.5.11;
//
// * whitebetting.com - the whitest football betting game based on ethereum blockchain
// on 2019-09-24
//
contract WhiteBetting {
function bug_intou28(uint8 p_intou28) public{
uint8 vundflw1=0;
vundflw1 = vundflw1 + p_intou28; // overflow bug //Integer_overflow_and_underflow bug
}
address payable public owner;
// Game information
struct GameInfo {
// game start time
uint256 timestamp;
// game odds
uint32 odd_homeTeam;
uint32 odd_drawTeam;
uint32 odd_awayTeam;
uint32 odd_over;
uint32 odd_under;
uint32 odd_homeTeamAndDraw;
uint32 odd_homeAndAwayTeam;
uint32 odd_awayTeamAndDraw;
// Checking the game status
uint8 open_status;
// Checking whether winning were paid
bool isDone;
}
function bug_intou27() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug //Integer_overflow_and_underflow bug
}
mapping(uint64 => GameInfo) public gameList;
// Player betting infomation
struct BetFixture {
address payable player;
uint256 stake;
uint32 odd;
// betting type
uint16 selectedTeam;
}
mapping(address => uint) balances_intou26;
function transfer_intou26(address _to, uint _value) public returns (bool) {
require(balances_intou26[msg.sender] - _value >= 0); //bug //Integer_overflow_and_underflow bug
balances_intou26[msg.sender] -= _value; //bug //Integer_overflow_and_underflow bug
balances_intou26[_to] += _value; //bug //Integer_overflow_and_underflow bug
return true;
}
mapping(uint64 => BetFixture[]) public betList;
// Events that are issued to make statistic recovery easier
function bug_intou15() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug //Integer_overflow_and_underflow bug
}
event Success(uint256 odd);
mapping(address => uint) balances_intou14;
function transfer_intou14(address _to, uint _value) public returns (bool) {
require(balances_intou14[msg.sender] - _value >= 0); //bug //Integer_overflow_and_underflow bug
balances_intou14[msg.sender] -= _value; //bug //Integer_overflow_and_underflow bug
balances_intou14[_to] += _value; //bug //Integer_overflow_and_underflow bug
return true;
}
event Deposit(address sender, uint256 eth);
mapping(address => uint) public lockTime_intou13;
function increaseLockTime_intou13(uint _secondsToIncrease) public {
lockTime_intou13[msg.sender] += _secondsToIncrease; //overflow //Integer_overflow_and_underflow bug
}
function withdraw_intou13() public {
require(now > lockTime_intou13[msg.sender]);
uint transferValue_intou13 = 10;
msg.sender.transfer(transferValue_intou13);
}
event Withdraw(address receiver, uint256 eth);
function bug_intou12(uint8 p_intou12) public{
uint8 vundflw1=0;
vundflw1 = vundflw1 + p_intou12; // overflow bug //Integer_overflow_and_underflow bug
}
event NewStake(address player, uint64 fixtureId, uint16 selectedTeam, uint256 stake, uint256 odd);
function bug_intou11() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug //Integer_overflow_and_underflow bug
}
event SetGame(uint64 _fixtureId, uint256 _timestamp, uint32 _odd_homeTeam, uint32 _odd_drawTeam, uint32 _odd_awayTeam, uint32 _odd_over, uint32 _odd_under, uint32 _odd_homeTeamAndDraw, uint32 _odd_homeAndAwayTeam , uint32 _odd_awayTeamAndDraw, uint8 _open_status);
mapping(address => uint) balances_intou10;
function transfer_intou10(address _to, uint _value) public returns (bool) {
require(balances_intou10[msg.sender] - _value >= 0); //bug //Integer_overflow_and_underflow bug
balances_intou10[msg.sender] -= _value; //bug //Integer_overflow_and_underflow bug
balances_intou10[_to] += _value; //bug //Integer_overflow_and_underflow bug
return true;
}
event ChangeOdd (uint64 _fixtureId, uint32 _odd_homeTeam, uint32 _odd_drawTeam, uint32 _odd_awayTeam, uint32 _odd_over, uint32 _odd_under, uint32 _odd_homeTeamAndDraw, uint32 _odd_homeAndAwayTeam , uint32 _odd_awayTeamAndDraw);
mapping(address => uint) public lockTime_intou1;
function increaseLockTime_intou1(uint _secondsToIncrease) public {
lockTime_intou1[msg.sender] += _secondsToIncrease; //Integer_overflow_and_underflow bug
}
function withdraw_ovrflow1() public {
require(now > lockTime_intou1[msg.sender]);
uint transferValue_intou1 = 10;
msg.sender.transfer(transferValue_intou1);
}
event GivePrizeMoney(uint64 _fixtureId, uint8 _homeDrawAway, uint8 _overUnder);
// Constructor
constructor() public {
owner = msg.sender;
}
mapping(address => uint) public lockTime_intou25;
function increaseLockTime_intou25(uint _secondsToIncrease) public {
lockTime_intou25[msg.sender] += _secondsToIncrease; //overflow //Integer_overflow_and_underflow bug
}
function withdraw_intou25() public {
require(now > lockTime_intou25[msg.sender]);
uint transferValue_intou25 = 10;
msg.sender.transfer(transferValue_intou25);
}
// Change the game status
function setOpenStatus(uint64 _fixtureId, uint8 _open_status) external onlyOwner {
gameList[_fixtureId].open_status = _open_status;
}
function bug_intou24(uint8 p_intou24) public{
uint8 vundflw1=0;
vundflw1 = vundflw1 + p_intou24; // overflow bug //Integer_overflow_and_underflow bug
}
// Refresh the game odd
function changeOdd (uint64 _fixtureId, uint32 _odd_homeTeam, uint32 _odd_drawTeam, uint32 _odd_awayTeam, uint32 _odd_over, uint32 _odd_under, uint32 _odd_homeTeamAndDraw, uint32 _odd_homeAndAwayTeam , uint32 _odd_awayTeamAndDraw) external onlyOwner {
gameList[_fixtureId].odd_homeTeam = _odd_homeTeam;
gameList[_fixtureId].odd_drawTeam = _odd_drawTeam;
gameList[_fixtureId].odd_awayTeam = _odd_awayTeam;
gameList[_fixtureId].odd_over = _odd_over;
gameList[_fixtureId].odd_under = _odd_under;
gameList[_fixtureId].odd_homeTeamAndDraw = _odd_homeTeamAndDraw;
gameList[_fixtureId].odd_homeAndAwayTeam = _odd_homeAndAwayTeam;
gameList[_fixtureId].odd_awayTeamAndDraw = _odd_awayTeamAndDraw;
emit ChangeOdd (_fixtureId, _odd_homeTeam, _odd_drawTeam, _odd_awayTeam, _odd_over, _odd_under, _odd_homeTeamAndDraw, _odd_homeAndAwayTeam , _odd_awayTeamAndDraw);
}
function bug_intou23() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug //Integer_overflow_and_underflow bug
}
// Save the game information
function setGameInfo (uint64 _fixtureId, uint256 _timestamp, uint32 _odd_homeTeam, uint32 _odd_drawTeam, uint32 _odd_awayTeam, uint32 _odd_over, uint32 _odd_under, uint32 _odd_homeTeamAndDraw, uint32 _odd_homeAndAwayTeam , uint32 _odd_awayTeamAndDraw, uint8 _open_status) external onlyOwner {
gameList[_fixtureId].timestamp = _timestamp;
gameList[_fixtureId].odd_homeTeam = _odd_homeTeam;
gameList[_fixtureId].odd_drawTeam = _odd_drawTeam;
gameList[_fixtureId].odd_awayTeam = _odd_awayTeam;
gameList[_fixtureId].odd_over = _odd_over;
gameList[_fixtureId].odd_under = _odd_under;
gameList[_fixtureId].odd_homeTeamAndDraw = _odd_homeTeamAndDraw;
gameList[_fixtureId].odd_homeAndAwayTeam = _odd_homeAndAwayTeam;
gameList[_fixtureId].odd_awayTeamAndDraw = _odd_awayTeamAndDraw;
gameList[_fixtureId].open_status = _open_status;
gameList[_fixtureId].isDone = false;
emit SetGame(_fixtureId, _timestamp, _odd_homeTeam, _odd_drawTeam, _odd_awayTeam, _odd_over, _odd_under, _odd_homeTeamAndDraw, _odd_homeAndAwayTeam , _odd_awayTeamAndDraw, _open_status);
}
mapping(address => uint) balances_intou22;
function transfer_intou22(address _to, uint _value) public returns (bool) {
require(balances_intou22[msg.sender] - _value >= 0); //bug //Integer_overflow_and_underflow bug
balances_intou22[msg.sender] -= _value; //bug //Integer_overflow_and_underflow bug
balances_intou22[_to] += _value; //bug //Integer_overflow_and_underflow bug
return true;
}
// Player make a bet
function placeBet(uint64 _fixtureId, uint16 _selectedTeam, uint32 _odd) external payable {
uint stake = msg.value;
// Minium amount to bet is 0.001 ether
require(stake >= .001 ether);
// Check whether odds is valid
require(_odd != 0);
// Compare to match mainnet odds with was submitted odds by betting type
if (_selectedTeam == 1) {
require(gameList[_fixtureId].odd_homeTeam == _odd);
} else if (_selectedTeam == 2) {
require(gameList[_fixtureId].odd_drawTeam == _odd);
} else if (_selectedTeam == 3) {
require(gameList[_fixtureId].odd_awayTeam == _odd);
} else if (_selectedTeam == 4) {
require(gameList[_fixtureId].odd_over == _odd);
} else if (_selectedTeam == 5) {
require(gameList[_fixtureId].odd_under == _odd);
} else if (_selectedTeam == 6) {
require(gameList[_fixtureId].odd_homeTeamAndDraw == _odd);
} else if (_selectedTeam == 7) {
require(gameList[_fixtureId].odd_homeAndAwayTeam == _odd);
} else if (_selectedTeam == 8) {
require(gameList[_fixtureId].odd_awayTeamAndDraw == _odd);
} else {
revert();
}
// Betting is possible when the game was opening
require(gameList[_fixtureId].open_status == 3);
// Betting is possible only 10 min. ago
require(now < (gameList[_fixtureId].timestamp - 10 minutes));
// Save the betting information
betList[_fixtureId].push(BetFixture(msg.sender, stake, _odd, _selectedTeam));
emit NewStake(msg.sender, _fixtureId, _selectedTeam, stake, _odd);
}
mapping(address => uint) public lockTime_intou21;
function increaseLockTime_intou21(uint _secondsToIncrease) public {
lockTime_intou21[msg.sender] += _secondsToIncrease; //overflow //Integer_overflow_and_underflow bug
}
function withdraw_intou21() public {
require(now > lockTime_intou21[msg.sender]);
uint transferValue_intou21 = 10;
msg.sender.transfer(transferValue_intou21);
}
// Give prize money by the game result
function givePrizeMoney(uint64 _fixtureId, uint8 _homeDrawAway, uint8 _overUnder) external onlyOwner payable {
// Check the game status whether is opening
require(gameList[_fixtureId].open_status == 3);
// Check if it has ever compensated
require(gameList[_fixtureId].isDone == false);
// Check if it has any player who betted
require(betList[_fixtureId][0].player != address(0));
// Give the prize money!
for (uint i= 0 ; i < betList[_fixtureId].length; i++){
uint16 selectedTeam = betList[_fixtureId][i].selectedTeam;
uint256 returnEth = (betList[_fixtureId][i].stake * betList[_fixtureId][i].odd) / 1000 ;
if ((selectedTeam == 1 && _homeDrawAway == 1)
|| (selectedTeam == 2 && _homeDrawAway == 2)
|| (selectedTeam == 3 && _homeDrawAway == 3)
|| (selectedTeam == 4 && _overUnder == 1)
|| (selectedTeam == 5 && _overUnder == 2)
|| (selectedTeam == 6 && (_homeDrawAway == 1 || _homeDrawAway == 2))
|| (selectedTeam == 7 && (_homeDrawAway == 1 || _homeDrawAway == 3))
|| (selectedTeam == 8 && (_homeDrawAway == 3 || _homeDrawAway == 2))){
betList[_fixtureId][i].player.transfer(returnEth);
}
}
// Change the game status.
gameList[_fixtureId].open_status = 5;
// It was paid.
gameList[_fixtureId].isDone = true; // true .
emit GivePrizeMoney(_fixtureId, _homeDrawAway, _overUnder);
}
function bug_intou20(uint8 p_intou20) public{
uint8 vundflw1=0;
vundflw1 = vundflw1 + p_intou20; // overflow bug //Integer_overflow_and_underflow bug
}
// Standard modifier on methods invokable only by contract owner.
modifier onlyOwner {
require (msg.sender == owner, "OnlyOwner methods called by non-owner.");
_;
}
// Get this balance of CA
function getBalance() external view returns(uint){
return address(this).balance;
}
mapping(address => uint) balances_intou2;
function transfer_undrflow2(address _to, uint _value) public returns (bool) {
require(balances_intou2[msg.sender] - _value >= 0); //Integer_overflow_and_underflow bug
balances_intou2[msg.sender] -= _value; //Integer_overflow_and_underflow bug
balances_intou2[_to] += _value; //Integer_overflow_and_underflow bug
return true;
}
// Deposit from owner to CA
function deposit(uint256 _eth) external payable{
emit Deposit(msg.sender, _eth);
}
function bug_intou19() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug //Integer_overflow_and_underflow bug
}
// Change Owner
function changeOwner(address payable _newOwner) external onlyOwner {
owner = _newOwner;
}
mapping(address => uint) balances_intou18;
function transfer_intou18(address _to, uint _value) public returns (bool) {
require(balances_intou18[msg.sender] - _value >= 0); //bug //Integer_overflow_and_underflow bug
balances_intou18[msg.sender] -= _value; //bug //Integer_overflow_and_underflow bug
balances_intou18[_to] += _value; //bug //Integer_overflow_and_underflow bug
return true;
}
// Fallback function
function () external payable{
owner.transfer(msg.value);
}
mapping(address => uint) public lockTime_intou17;
function increaseLockTime_intou17(uint _secondsToIncrease) public {
lockTime_intou17[msg.sender] += _secondsToIncrease; //overflow //Integer_overflow_and_underflow bug
}
function withdraw_intou17() public {
require(now > lockTime_intou17[msg.sender]);
uint transferValue_intou17 = 10;
msg.sender.transfer(transferValue_intou17);
}
// Withdraw from CA to owner
function withdraw(uint256 _amount) external payable onlyOwner {
require(_amount > 0 && _amount <= address(this).balance);
owner.transfer(_amount);
emit Withdraw(owner, _amount);
}
function bug_intou16(uint8 p_intou16) public{
uint8 vundflw1=0;
vundflw1 = vundflw1 + p_intou16; // overflow bug //Integer_overflow_and_underflow bug
}
}
| 224,019 | 12,542 |
7fba2687d59f74ca6adf9fc4fd3207c416d8ce44b605529e8c2e9eaa95cc1038
| 20,712 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/e7/e7093fF58f398544F52A4f241cf9ECc467630c5d_PrivilegedRedistributor.sol
| 4,233 | 17,256 |
pragma solidity ^0.5.16;
// Copied from Compound/ExponentialNoError
contract ExponentialNoError {
uint constant expScale = 1e18;
uint constant doubleScale = 1e36;
uint constant halfExpScale = expScale/2;
uint constant mantissaOne = expScale;
struct Exp {
uint mantissa;
}
struct Double {
uint mantissa;
}
function truncate(Exp memory exp) pure internal returns (uint) {
// Note: We are not using careful math here as we're performing a division that cannot fail
return exp.mantissa / expScale;
}
function mul_ScalarTruncate(Exp memory a, uint scalar) pure internal returns (uint) {
Exp memory product = mul_(a, scalar);
return truncate(product);
}
function mul_ScalarTruncateAddUInt(Exp memory a, uint scalar, uint addend) pure internal returns (uint) {
Exp memory product = mul_(a, scalar);
return add_(truncate(product), addend);
}
function lessThanExp(Exp memory left, Exp memory right) pure internal returns (bool) {
return left.mantissa < right.mantissa;
}
function lessThanOrEqualExp(Exp memory left, Exp memory right) pure internal returns (bool) {
return left.mantissa <= right.mantissa;
}
function greaterThanExp(Exp memory left, Exp memory right) pure internal returns (bool) {
return left.mantissa > right.mantissa;
}
function isZeroExp(Exp memory value) pure internal returns (bool) {
return value.mantissa == 0;
}
function safe224(uint n, string memory errorMessage) pure internal returns (uint224) {
require(n < 2**224, errorMessage);
return uint224(n);
}
function safe32(uint n, string memory errorMessage) pure internal returns (uint32) {
require(n < 2**32, errorMessage);
return uint32(n);
}
function add_(Exp memory a, Exp memory b) pure internal returns (Exp memory) {
return Exp({mantissa: add_(a.mantissa, b.mantissa)});
}
function add_(Double memory a, Double memory b) pure internal returns (Double memory) {
return Double({mantissa: add_(a.mantissa, b.mantissa)});
}
function add_(uint a, uint b) pure internal returns (uint) {
return add_(a, b, "addition overflow");
}
function add_(uint a, uint b, string memory errorMessage) pure internal returns (uint) {
uint c = a + b;
require(c >= a, errorMessage);
return c;
}
function sub_(Exp memory a, Exp memory b) pure internal returns (Exp memory) {
return Exp({mantissa: sub_(a.mantissa, b.mantissa)});
}
function sub_(Double memory a, Double memory b) pure internal returns (Double memory) {
return Double({mantissa: sub_(a.mantissa, b.mantissa)});
}
function sub_(uint a, uint b) pure internal returns (uint) {
return sub_(a, b, "subtraction underflow");
}
function sub_(uint a, uint b, string memory errorMessage) pure internal returns (uint) {
require(b <= a, errorMessage);
return a - b;
}
function mul_(Exp memory a, Exp memory b) pure internal returns (Exp memory) {
return Exp({mantissa: mul_(a.mantissa, b.mantissa) / expScale});
}
function mul_(Exp memory a, uint b) pure internal returns (Exp memory) {
return Exp({mantissa: mul_(a.mantissa, b)});
}
function mul_(uint a, Exp memory b) pure internal returns (uint) {
return mul_(a, b.mantissa) / expScale;
}
function mul_(Double memory a, Double memory b) pure internal returns (Double memory) {
return Double({mantissa: mul_(a.mantissa, b.mantissa) / doubleScale});
}
function mul_(Double memory a, uint b) pure internal returns (Double memory) {
return Double({mantissa: mul_(a.mantissa, b)});
}
function mul_(uint a, Double memory b) pure internal returns (uint) {
return mul_(a, b.mantissa) / doubleScale;
}
function mul_(uint a, uint b) pure internal returns (uint) {
return mul_(a, b, "multiplication overflow");
}
function mul_(uint a, uint b, string memory errorMessage) pure internal returns (uint) {
if (a == 0 || b == 0) {
return 0;
}
uint c = a * b;
require(c / a == b, errorMessage);
return c;
}
function div_(Exp memory a, Exp memory b) pure internal returns (Exp memory) {
return Exp({mantissa: div_(mul_(a.mantissa, expScale), b.mantissa)});
}
function div_(Exp memory a, uint b) pure internal returns (Exp memory) {
return Exp({mantissa: div_(a.mantissa, b)});
}
function div_(uint a, Exp memory b) pure internal returns (uint) {
return div_(mul_(a, expScale), b.mantissa);
}
function div_(Double memory a, Double memory b) pure internal returns (Double memory) {
return Double({mantissa: div_(mul_(a.mantissa, doubleScale), b.mantissa)});
}
function div_(Double memory a, uint b) pure internal returns (Double memory) {
return Double({mantissa: div_(a.mantissa, b)});
}
function div_(uint a, Double memory b) pure internal returns (uint) {
return div_(mul_(a, doubleScale), b.mantissa);
}
function div_(uint a, uint b) pure internal returns (uint) {
return div_(a, b, "divide by zero");
}
function div_(uint a, uint b, string memory errorMessage) pure internal returns (uint) {
require(b > 0, errorMessage);
return a / b;
}
function fraction(uint a, uint b) pure internal returns (Double memory) {
return Double({mantissa: div_(mul_(a, doubleScale), b)});
}
}
interface Distributor {
// The asset to be distributed
function asset() external view returns (address);
// Return the accrued amount of account based on stored data
function accruedStored(address account) external view returns (uint);
// Accrue and distribute for caller, but not actually transfer assets to the caller
// returns the new accrued amount
function accrue() external returns (uint);
// Claim asset, transfer the given amount assets to receiver
function claim(address receiver, uint amount) external returns (uint);
}
contract Redistributor is Distributor, ExponentialNoError {
Distributor public superior;
// The accrued amount of this address in superior Distributor
uint public superiorAccruedAmount;
// The initial accrual index
uint internal constant initialAccruedIndex = 1e36;
// The last accrued block number
uint public accrualBlockNumber;
// The last accrued index
uint public globalAccruedIndex;
// Total count of shares.
uint internal totalShares;
struct AccountState {
/// @notice The share of account
uint share;
// The last accrued index of account
uint accruedIndex;
/// @notice The accrued but not yet transferred to account
uint accruedAmount;
}
// The AccountState for each account
mapping(address => AccountState) internal accountStates;
// Emitted when dfl is accrued
event Accrued(uint amount, uint globalAccruedIndex);
// Emitted when distribute to a account
event Distributed(address account, uint amount, uint accruedIndex);
// Emitted when account claims asset
event Claimed(address account, address receiver, uint amount);
// Emitted when account transfer asset
event Transferred(address from, address to, uint amount);
constructor(Distributor superior_) public {
// set superior
superior = superior_;
// init accrued index
globalAccruedIndex = initialAccruedIndex;
}
function asset() external view returns (address) {
return superior.asset();
}
// Return the accrued amount of account based on stored data
function accruedStored(address account) external view returns(uint) {
uint storedGlobalAccruedIndex;
if (totalShares == 0) {
storedGlobalAccruedIndex = globalAccruedIndex;
} else {
uint superiorAccruedStored = superior.accruedStored(address(this));
uint delta = sub_(superiorAccruedStored, superiorAccruedAmount);
Double memory ratio = fraction(delta, totalShares);
Double memory doubleGlobalAccruedIndex = add_(Double({mantissa: globalAccruedIndex}), ratio);
storedGlobalAccruedIndex = doubleGlobalAccruedIndex.mantissa;
}
(, uint instantAccountAccruedAmount) = accruedStoredInternal(account, storedGlobalAccruedIndex);
return instantAccountAccruedAmount;
}
// Return the accrued amount of account based on stored data
function accruedStoredInternal(address account, uint withGlobalAccruedIndex) internal view returns(uint, uint) {
AccountState memory state = accountStates[account];
Double memory doubleGlobalAccruedIndex = Double({mantissa: withGlobalAccruedIndex});
Double memory doubleAccountAccruedIndex = Double({mantissa: state.accruedIndex});
if (doubleAccountAccruedIndex.mantissa == 0 && doubleGlobalAccruedIndex.mantissa > 0) {
doubleAccountAccruedIndex.mantissa = initialAccruedIndex;
}
Double memory deltaIndex = sub_(doubleGlobalAccruedIndex, doubleAccountAccruedIndex);
uint delta = mul_(state.share, deltaIndex);
return (delta, add_(state.accruedAmount, delta));
}
function accrueInternal() internal {
uint blockNumber = getBlockNumber();
if (accrualBlockNumber == blockNumber) {
return;
}
uint newSuperiorAccruedAmount = superior.accrue();
if (totalShares == 0) {
accrualBlockNumber = blockNumber;
return;
}
uint delta = sub_(newSuperiorAccruedAmount, superiorAccruedAmount);
Double memory ratio = fraction(delta, totalShares);
Double memory doubleAccruedIndex = add_(Double({mantissa: globalAccruedIndex}), ratio);
// update globalAccruedIndex
globalAccruedIndex = doubleAccruedIndex.mantissa;
superiorAccruedAmount = newSuperiorAccruedAmount;
accrualBlockNumber = blockNumber;
emit Accrued(delta, doubleAccruedIndex.mantissa);
}
function accrue() external returns (uint) {
accrueInternal();
(, uint instantAccountAccruedAmount) = accruedStoredInternal(msg.sender, globalAccruedIndex);
return instantAccountAccruedAmount;
}
function distributeInternal(address account) internal {
(uint delta, uint instantAccruedAmount) = accruedStoredInternal(account, globalAccruedIndex);
AccountState storage state = accountStates[account];
state.accruedIndex = globalAccruedIndex;
state.accruedAmount = instantAccruedAmount;
// emit Distributed event
emit Distributed(account, delta, globalAccruedIndex);
}
function claim(address receiver, uint amount) external returns (uint) {
address account = msg.sender;
// keep fresh
accrueInternal();
distributeInternal(account);
AccountState storage state = accountStates[account];
require(amount <= state.accruedAmount, "claim: insufficient value");
// claim from superior
require(superior.claim(receiver, amount) == amount, "claim: amount mismatch");
// update storage
state.accruedAmount = sub_(state.accruedAmount, amount);
superiorAccruedAmount = sub_(superiorAccruedAmount, amount);
emit Claimed(account, receiver, amount);
return amount;
}
function claimAll() external {
address account = msg.sender;
// accrue and distribute
accrueInternal();
distributeInternal(account);
AccountState storage state = accountStates[account];
uint amount = state.accruedAmount;
// claim from superior
require(superior.claim(account, amount) == amount, "claim: amount mismatch");
// update storage
state.accruedAmount = 0;
superiorAccruedAmount = sub_(superiorAccruedAmount, amount);
emit Claimed(account, account, amount);
}
function transfer(address to, uint amount) external {
address from = msg.sender;
// keep fresh
accrueInternal();
distributeInternal(from);
AccountState storage fromState = accountStates[from];
uint actualAmount = amount;
if (actualAmount == 0) {
actualAmount = fromState.accruedAmount;
}
require(fromState.accruedAmount >= actualAmount, "transfer: insufficient value");
AccountState storage toState = accountStates[to];
// update storage
fromState.accruedAmount = sub_(fromState.accruedAmount, actualAmount);
toState.accruedAmount = add_(toState.accruedAmount, actualAmount);
emit Transferred(from, to, actualAmount);
}
function getBlockNumber() public view returns (uint) {
return block.number;
}
}
contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
_owner = msg.sender;
emit OwnershipTransferred(address(0), msg.sender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract PrivilegedRedistributor is Redistributor, Ownable {
/// @notice A list of all valid members
address[] public members;
/// @notice Emitted when members changed
event Changed(address[] newMembers, uint[] newPercentages);
constructor(Distributor superior_) Redistributor(superior_) public {}
function allMembers() external view returns (address[] memory, uint[] memory) {
address[] memory storedMembers = members;
uint[] memory percentages = new uint[](storedMembers.length);
for (uint i = 0; i < storedMembers.length; i++) {
percentages[i] = accountStates[storedMembers[i]].share;
}
return (storedMembers, percentages);
}
function memberState(address member) external view returns (uint, uint, uint) {
AccountState memory state = accountStates[member];
return (state.share, state.accruedIndex, state.accruedAmount);
}
function _setPercentages(uint[] calldata newPercentages) external onlyOwner {
uint sumNewPercentagesMantissa;
for (uint i = 0; i < newPercentages.length; i++) {
sumNewPercentagesMantissa = add_(sumNewPercentagesMantissa, newPercentages[i]);
}
// Check sum of new percentages equals 1
require(sumNewPercentagesMantissa == mantissaOne, "_setPercentages: bad sum");
// reference storage
address[] storage storedMembers = members;
require(storedMembers.length == newPercentages.length, "_setPercentages: bad length");
// accrue first
accrueInternal();
// distribute to members if its percentage changes
for (uint i = 0; i < storedMembers.length; i++) {
AccountState storage state = accountStates[storedMembers[i]];
distributeInternal(storedMembers[i]);
// set new percentage for member
state.share = newPercentages[i];
}
emit Changed(storedMembers, newPercentages);
}
function _setMembers(address[] memory newMembers, uint[] memory newPercentages) public onlyOwner {
require(newMembers.length == newPercentages.length, "_setMembers: bad length");
uint sumNewPercentagesMantissa;
for (uint i = 0; i < newPercentages.length; i++) {
require(newPercentages[i] != 0, "_setMembers: bad percentage");
sumNewPercentagesMantissa = add_(sumNewPercentagesMantissa, newPercentages[i]);
}
// Check sum of new percentages equals 1
require(sumNewPercentagesMantissa == mantissaOne, "_setMembers: bad sum");
// accrue first
accrueInternal();
// distribute for old members
address[] storage storedMembers = members;
for (uint i = 0; i < storedMembers.length; i++) {
distributeInternal(storedMembers[i]);
AccountState storage state = accountStates[storedMembers[i]];
state.share = 0;
}
// clear old members
storedMembers.length = 0;
for (uint i = 0; i < newMembers.length; i++) {
AccountState storage state = accountStates[newMembers[i]];
accountStates[newMembers[i]] = AccountState({share: newPercentages[i], accruedIndex: globalAccruedIndex, accruedAmount: state.accruedAmount});
storedMembers.push(newMembers[i]);
}
totalShares = mantissaOne;
emit Changed(newMembers, newPercentages);
}
}
| 34,750 | 12,543 |
2793d08e03e2cce56faffa40573c22c9e0c07f85d284d3fc23e9ece59720dbb7
| 19,888 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/25/25B383e9Cf2D94bfb810f5E8801Bb39f10952a90_Vault.sol
| 5,633 | 18,924 |
pragma solidity ^0.8.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;
}
}
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;
}
}
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);
}
}
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 IMansionsHelper {
function getClaimFee (address sender) external view returns (uint256);
function newTax () external view returns (uint256);
function claimUtility(uint64[] calldata _nodes, address whereTo, uint256 neededAmount, address excessAmountReceiver, address nodesOwner) external;
}
interface IMansionManager {
function getAddressRewards(address account) external view returns (uint);
function getUserMultiplier(address from) external view returns (uint256);
}
interface ITaxManager {
function execute(uint256 remainingRewards, address receiver) external;
}
contract Vault is Ownable {
using SafeMath for uint256;
struct Stake {
uint256 stakeCycle;
uint256 lastClaimCycle;
uint256 unstakeCycle;
uint256 amount;
uint256 totalRewards;
}
IERC20 public PLAYMATES;
IERC20 public PAYMENT_TOKEN;
address public POOL;
address public TREASURY;
address public MARKETING;
address public TRUST_V3 = 0x82fdACD535F6EEa710d1ab67746e9e68366Dce8f;
bool public paused;
string public baseUri;
mapping(uint256 => uint256) public totalStaked;
mapping(uint256 => uint256) public payouts;
mapping(address => Stake) public stakers;
mapping(address => mapping (uint256 => uint256)) public amountStaked;
mapping(address => mapping (uint256 => bool)) public payoutClaimed;
mapping(address => mapping (uint256 => bool)) public stakedDuringCycle;
mapping(address => bool) public blacklist;
mapping(address => bool) public migrated;
uint256 public firstCycleDate;
uint256 public cycleDuration = 864000;
uint256 public minStake = 1 * 10**18;
uint256 public maxStake = 2000 * 10**18;
uint256 public stakeFee = 50000;
uint256[] public unstakeFees = [750000, 500000, 400000, 300000, 200000, 100000];
uint256 public unstakeFeesLength = 6;
uint256[] public stakeDistribution = [500000, 500000];
uint256[] public unstakeDistribution = [500000, 300000, 100000, 100000];
uint256 public precision = 1000000;
IMansionsHelper public MANSIONSHEPLER = IMansionsHelper(0x19234452F1005D85FCEa70380AB75EbBF6259f48);
IMansionManager public MANSIONSMANAGER = IMansionManager(0xc4a25F823582d9ccf5cf8C8BF5338073e7a51676);
ITaxManager public TAXMANAGER;
event Staked(address indexed _from, uint256 amount);
event Migrated(address indexed _from, uint256 amount);
event Claimed(address indexed _from, uint256 amount);
event Unstaked(address indexed _from, uint256 amount);
constructor(address _PLAYMATES, address _PAYMENT_TOKEN, address _POOL, address _TREASURY, address _MARKETING, address _MANSIONSHEPELR, address _TAXMANAGER, string memory _baseUri) {
PLAYMATES = IERC20(_PLAYMATES);
PAYMENT_TOKEN = IERC20(_PAYMENT_TOKEN);
POOL = _POOL;
TREASURY = _TREASURY;
MARKETING = _MARKETING;
MANSIONSHEPLER = IMansionsHelper(_MANSIONSHEPELR);
TAXMANAGER = ITaxManager(_TAXMANAGER);
baseUri = _baseUri;
firstCycleDate = block.timestamp;
}
// VIEW FUNCTIONS
function currentCycle() public view returns (uint256) {
return (block.timestamp - firstCycleDate) / cycleDuration + 1;
}
function getAllRewardsOf(address user) public view returns (uint256) {
uint256 sum = 0;
for(uint256 i = stakers[user].lastClaimCycle; i < currentCycle(); i++) {
if (payoutClaimed[user][i] == true) continue;
uint256 share = getShareOf(user, i);
sum += payouts[i].mul(share) / precision;
}
return sum;
}
function getRewardsOf(address user, uint256 cycle) public view returns (uint256) {
uint256 sum = 0;
uint256 share = getShareOf(user, cycle);
sum += payouts[cycle].mul(share) / precision;
return sum;
}
function getShareOf(address user, uint256 cycle) public view returns (uint256) {
if (stakedDuringCycle[user][cycle] == false) return 0;
return amountStaked[user][cycle].mul(precision) / totalStaked[cycle];
}
function getShareOfCurrent(address user) public view returns (uint256) {
return getShareOf(user, currentCycle());
}
function getTotalStakedCurrent() public view returns (uint256) {
return totalStaked[currentCycle()];
}
function getInvestmentUri(uint256 id) public view returns (string memory) {
return string(abi.encodePacked(baseUri, id));
}
function getUnstakeFees(address user) public view returns (uint256) {
return unstakeFees[currentCycle() - stakers[user].stakeCycle > unstakeFeesLength ? unstakeFeesLength - 1 : currentCycle() - stakers[user].stakeCycle];
}
function getStakeCycleOfUser(address user) public view returns (uint256) {
return stakers[user].stakeCycle;
}
function getLastClaimCycleOfUser(address user) public view returns (uint256) {
return stakers[user].lastClaimCycle;
}
function getUnstakeCycleOfUser(address user) public view returns (uint256) {
return stakers[user].unstakeCycle;
}
function getAmountStakedOfUser(address user) public view returns (uint256) {
return stakers[user].amount;
}
function getTotalRewardsOfUser(address user) public view returns (uint256) {
return stakers[user].totalRewards;
}
// PUBLIC FUNCTIONS
function migrate() external {
require(paused == false, "MIGRATE: Contract is paused");
require(blacklist[msg.sender] == false, "MIGRATE: You are blacklisted");
require(migrated[msg.sender] == false, "MIGRATE: You already migrated");
require(Vault(TRUST_V3).amountStaked(msg.sender, 2) > 0, "MIGRATE: You were not staking.");
require(Vault(TRUST_V3).stakedDuringCycle(msg.sender, 2) == true, "MIGRATE: You were not staking");
require(currentCycle() == 1, "MIGRATE: Migration period is over");
migrated[msg.sender] = true;
stakers[msg.sender] = Stake({
stakeCycle: 1,
lastClaimCycle: 1,
unstakeCycle: 0,
amount: Vault(TRUST_V3).amountStaked(msg.sender, 2),
totalRewards: 0
});
amountStaked[msg.sender][currentCycle()] = stakers[msg.sender].amount;
totalStaked[currentCycle()] += stakers[msg.sender].amount;
stakedDuringCycle[msg.sender][currentCycle()] = true;
emit Migrated(msg.sender, stakers[msg.sender].amount);
}
function stake(uint256 amount, bool isAdding) external {
require(paused == false, "STAKE: Contract is paused.");
require(blacklist[msg.sender] == false, "STAKE: You are blacklisted");
uint256 amountAfterFees;
uint256 feesAmount = amount.mul(stakeFee) / precision;
if (stakers[msg.sender].amount == 0 || isAdding) {
amountAfterFees = stakers[msg.sender].unstakeCycle == currentCycle() ? amount.sub(feesAmount) : amountStaked[msg.sender][currentCycle()].add(amount.sub(feesAmount));
require(amount.sub(feesAmount).add(stakers[msg.sender].amount) >= minStake, "STAKE: Below min amount");
require(amount.sub(feesAmount).add(stakers[msg.sender].amount) <= maxStake, "STAKE: Above max amount");
PLAYMATES.transferFrom(msg.sender, address(this), amount);
// FEE TRANSFERS
PLAYMATES.transfer(POOL, feesAmount.mul(stakeDistribution[0]) / precision);
PLAYMATES.transfer(address(PLAYMATES), feesAmount.mul(stakeDistribution[1]) / precision);
} else {
require(amountStaked[msg.sender][currentCycle()] == 0, "STAKE: You already merged");
amountAfterFees = stakers[msg.sender].amount;
}
stakers[msg.sender] = Stake({
stakeCycle: currentCycle(),
lastClaimCycle: stakers[msg.sender].lastClaimCycle == 0 ? currentCycle() : stakers[msg.sender].lastClaimCycle,
unstakeCycle: 0,
amount: amountAfterFees,
totalRewards: stakers[msg.sender].totalRewards
});
if (isAdding) totalStaked[currentCycle()] -= amountStaked[msg.sender][currentCycle()];
amountStaked[msg.sender][currentCycle()] = amountAfterFees;
totalStaked[currentCycle()] += amountAfterFees;
stakedDuringCycle[msg.sender][currentCycle()] = true;
emit Staked(msg.sender, amountAfterFees);
}
function compoundAndStake(uint64[] memory userNodes, uint256 amount, bool isAdding) external {
require(paused == false, "STAKE: Contract is paused.");
require(blacklist[msg.sender] == false, "STAKE: You are blacklisted");
uint256 amountAfterFees;
uint256 feesAmount = amount.mul(stakeFee) / precision;
if (stakers[msg.sender].amount == 0 || isAdding) {
amountAfterFees = stakers[msg.sender].unstakeCycle == currentCycle() ? amount.sub(feesAmount) : amountStaked[msg.sender][currentCycle()].add(amount.sub(feesAmount));
require(amount.sub(feesAmount).add(stakers[msg.sender].amount) >= minStake, "STAKE: Below min amount");
require(amount.sub(feesAmount).add(stakers[msg.sender].amount) <= maxStake, "STAKE: Above max amount");
uint256 availableRewards = MANSIONSMANAGER.getAddressRewards(msg.sender) * MANSIONSMANAGER.getUserMultiplier(msg.sender);
require(availableRewards >= amount, "STAKE: Not enough to compound");
MANSIONSHEPLER.claimUtility(userNodes, address(this), amount, address(TAXMANAGER), msg.sender);
TAXMANAGER.execute(availableRewards - amount, msg.sender);
// FEE TRANSFERS
PLAYMATES.transfer(POOL, feesAmount.mul(stakeDistribution[0]) / precision);
PLAYMATES.transfer(address(PLAYMATES), feesAmount.mul(stakeDistribution[1]) / precision);
} else {
require(amountStaked[msg.sender][currentCycle()] == 0, "STAKE: You already merged");
amountAfterFees = stakers[msg.sender].amount;
}
stakers[msg.sender] = Stake({
stakeCycle: currentCycle(),
lastClaimCycle: stakers[msg.sender].lastClaimCycle == 0 ? currentCycle() : stakers[msg.sender].lastClaimCycle,
unstakeCycle: 0,
amount: amountAfterFees,
totalRewards: stakers[msg.sender].totalRewards
});
if (isAdding) totalStaked[currentCycle()] -= amountStaked[msg.sender][currentCycle()];
amountStaked[msg.sender][currentCycle()] = amountAfterFees;
totalStaked[currentCycle()] += amountAfterFees;
stakedDuringCycle[msg.sender][currentCycle()] = true;
emit Staked(msg.sender, amountAfterFees);
}
function claimAll() public {
require(paused == false, "CLAIM: Contract is paused.");
require(blacklist[msg.sender] == false, "CLAIM: You are blacklisted");
require(currentCycle() > stakers[msg.sender].lastClaimCycle, "CLAIM2: You have no share to claim.");
require(stakers[msg.sender].lastClaimCycle >= stakers[msg.sender].stakeCycle, "CLAIM3: You have no share to claim.");
require(stakers[msg.sender].amount > 0, "CLAIM: You are not contributing to the pool.");
uint256 sum = 0;
for(uint256 i = stakers[msg.sender].lastClaimCycle; i < currentCycle(); i++) {
if (payoutClaimed[msg.sender][i] == false && stakedDuringCycle[msg.sender][i] == true) {
uint256 share = getShareOf(msg.sender, i);
sum += payouts[i].mul(share) / precision;
payoutClaimed[msg.sender][i] = true;
}
}
require(sum > 0, "CLAIM4: Nothing to claim");
stakers[msg.sender].lastClaimCycle = currentCycle();
stakers[msg.sender].totalRewards += sum;
PAYMENT_TOKEN.transfer(msg.sender, sum);
emit Claimed(msg.sender, sum);
}
function claim(uint256 cycle) public {
require(paused == false, "CLAIM: Contract is paused.");
require(blacklist[msg.sender] == false, "CLAIM: You are blacklisted");
require(currentCycle() > stakers[msg.sender].lastClaimCycle, "CLAIM2: You have no share to claim.");
require(stakers[msg.sender].lastClaimCycle >= stakers[msg.sender].stakeCycle, "CLAIM3: You have no share to claim.");
require(stakers[msg.sender].amount > 0, "CLAIM: You are not contributing to the pool.");
require(payoutClaimed[msg.sender][cycle] == false, "CLAIM4: Nothing to claim");
require(stakedDuringCycle[msg.sender][cycle] == true, "CLAIM6: You unstaked");
uint256 share = getShareOf(msg.sender, cycle);
uint256 sum = payouts[cycle].mul(share) / precision;
require(sum > 0, "CLAIM5: Nothing to claim");
stakers[msg.sender].lastClaimCycle = cycle;
stakers[msg.sender].totalRewards += sum;
payoutClaimed[msg.sender][cycle] = true;
PAYMENT_TOKEN.transfer(msg.sender, sum);
emit Claimed(msg.sender, sum);
}
function unstake(bool bypassClaimAll) external {
require(paused == false, "UNSTAKE: Contract is paused.");
require(blacklist[msg.sender] == false, "UNSTAKE: You are blacklisted");
require(stakers[msg.sender].amount > 0, "UNSTAKE: You have nothing to unstake.");
if (bypassClaimAll == false) {
if (getAllRewardsOf(msg.sender) > 0) {
claimAll();
}
}
uint256 feesRatio = getUnstakeFees(msg.sender);
uint256 feesAmount = stakers[msg.sender].amount.mul(feesRatio) / precision;
uint256 amountAfterFees = stakers[msg.sender].amount.sub(feesAmount);
stakers[msg.sender].amount = 0;
stakers[msg.sender].stakeCycle = 0;
stakers[msg.sender].unstakeCycle = currentCycle();
totalStaked[currentCycle()] -= amountStaked[msg.sender][currentCycle()];
stakedDuringCycle[msg.sender][currentCycle()] = false;
// FEE TRANSFERS
PLAYMATES.transfer(POOL, feesAmount.mul(unstakeDistribution[0]) / precision);
PLAYMATES.transfer(address(PLAYMATES), feesAmount.mul(unstakeDistribution[1]) / precision);
PLAYMATES.transfer(TREASURY, feesAmount.mul(unstakeDistribution[2]) / precision);
PLAYMATES.transfer(MARKETING, feesAmount.mul(unstakeDistribution[3]) / precision);
PLAYMATES.transfer(msg.sender, amountAfterFees);
emit Unstaked(msg.sender, amountAfterFees);
}
// ONLY OWNER FUNCTIONS
function setPrecision(uint256 _precision) external onlyOwner {
precision = _precision;
}
function setPaused(bool _val) external onlyOwner {
paused = _val;
}
function setPayout(uint256 cycle, uint256 amount) external onlyOwner {
payouts[cycle] = amount;
}
function setBlacklisted(address user, bool _val) external onlyOwner {
blacklist[user] = _val;
}
function setBaseUri(string memory _baseUri) external onlyOwner {
baseUri = _baseUri;
}
function setPlaymates(address _PLAYMATES) external onlyOwner {
PLAYMATES = IERC20(_PLAYMATES);
}
function setPaymentToken(address _PAYMENT_TOKEN) external onlyOwner {
PAYMENT_TOKEN = IERC20(_PAYMENT_TOKEN);
}
function setPool(address _POOL) external onlyOwner {
POOL = _POOL;
}
function setTreasury(address _TREASURY) external onlyOwner {
TREASURY = _TREASURY;
}
function setMarketing(address _MARKETING) external onlyOwner {
MARKETING = _MARKETING;
}
function setStakeDistribution(uint256[] memory _stakeDistribution) external onlyOwner {
stakeDistribution = _stakeDistribution;
}
function setUnstakeDistribution(uint256[] memory _unstakeDistribution) external onlyOwner {
unstakeDistribution = _unstakeDistribution;
}
function setCycleDuration(uint256 _cycleDuration) external onlyOwner {
cycleDuration = _cycleDuration;
}
function setStakeFee(uint256 _stakeFee) external onlyOwner {
stakeFee = _stakeFee;
}
function setUnstakeFees(uint256[] memory _unstakeFees, uint256 _unstakeFeesLength) external onlyOwner {
unstakeFees = _unstakeFees;
unstakeFeesLength = _unstakeFeesLength;
}
function setMinStakeAndMaxStake(uint256 _minStake, uint256 _maxStake) external onlyOwner {
minStake = _minStake * 10**16;
maxStake = _maxStake * 10**16;
}
function withdrawPlaymates() external onlyOwner {
PLAYMATES.transfer(msg.sender, PLAYMATES.balanceOf(address(this)));
}
function withdrawPayment() external onlyOwner {
PAYMENT_TOKEN.transfer(msg.sender, PAYMENT_TOKEN.balanceOf(address(this)));
}
}
| 96,071 | 12,544 |
5fc49a3522429aef962f874e66ba67eb53e301dfd47767014128d4d088b5f4d7
| 21,831 |
.sol
|
Solidity
| false |
316275714
|
giacomofi/Neural_Smart_Ponzi_Recognition
|
a26fb280753005b9b9fc262786d5ce502b3f8cd3
|
Not_Smart_Ponzi_Source_Code/0x7360734a9b0a878c47faff6b4face010d8c57371.sol
| 3,048 | 9,762 |
pragma solidity ^0.6.0;
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 virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual 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;
}
}
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);
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
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(_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);
_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 _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 _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
abstract contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
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;
}
}
contract GlueOS is Context, ERC20, ERC20Detailed {
address public owner;
mapping(uint256 => bool) public unlockCheck;
uint256[] public unlockAmount = [
150000000, //team
2500000, //operation per month
30000000, //operation per year
5000000, //development and marketing per month
60000000, //development and marketing per year
5000000, //bounty per month
20000000, //sales per month
100000000 //sales in last round
];
uint256 public initialSupply = 1000000000;
uint256[] public unlockTime = [
//unlock time per month
1585494000, // 2020.03.30. 12am gmt+9
1588345200, // 2020.05.02. 12am gmt+9
1591023600, // 2020.06.02. 12am gmt+9
1593615600, // 2020.07.02. 12am gmt+9
1596294000, // 2020.08.02. 12am gmt+9
1598972400, // 2020.09.02. 12am gmt+9
1601564400, // 2020.10.02. 12am gmt+9
1604242800, // 2020.11.02. 12am gmt+9
1606834800, // 2020.12.02. 12am gmt+9
1609513200, // 2021.01.02. 12am gmt+9
1612191600, // 2021.02.02. 12am gmt+9
1614610800, // 2021.03.02. 12am gmt+9
//unlock time per year
1617289200, // 2021.04.02. 12am gmt+9
1648825200, // 2022.04.02. 12am gmt+9
1680361200, // 2023.04.02. 12am gmt+9
1711983600, // 2024.04.02. 12am gmt+9
1743519600, // 2025.04.02. 12am gmt+9
1775055600, // 2026.04.02. 12am gmt+9
1806591600, // 2027.04.02. 12am gmt+9
1838214000, // 2028.04.02. 12am gmt+9
1869750000 // 2029.04.02. 12am gmt+9
];
constructor () public ERC20Detailed("GlueOS", "GLU", 18) {
owner=msg.sender;
_mint(address(this), initialSupply * (10 ** uint256(decimals())));
}
function burn(uint256 amount) public {
_burn(_msgSender(), amount);
}
function unlock(uint8 mode, uint8 round) public {
require(msg.sender==owner);
require(mode<8);
if(mode==0) require(round==0);
else if(mode==1) require(round<12);
else if(mode==2) require(round<9);
else if(mode==3) require(round<12);
else if(mode==4) require(round<4);
else if(mode==5) require(round<10);
else if(mode==6) require(round<5);
else if(mode==7) require(round==5);
require(now >= unlockTime[round + ((mode==2 || mode==4) ? 12 : 0)]);
require(!unlockCheck[mode*12+round]);
unlockCheck[mode*12+round] = true;
_burn(address(this), unlockAmount[mode] * (10 ** uint256(decimals())));
_mint(msg.sender, unlockAmount[mode] * (10 ** uint256(decimals())));
}
function changeOwner(address _owner) public {
require(msg.sender==owner);
owner = _owner;
}
}
| 339,860 | 12,545 |
d962526d4c5f80d13336cf6c52e7cab0d6aa34e9139e3508ebab8c012e21ab7f
| 23,151 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/58/5809253c7dab13ac49a2d32c0ddf8d35da9e0133_AvaxApex.sol
| 4,775 | 17,032 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.11;
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 Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
contract Owner is Context {
address private _owner;
event DefinedOwner(address indexed previousOwner, address indexed newOwner);
constructor (address owner_) {
_owner = owner_;
emit DefinedOwner(address(0), owner_);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Only owner: caller is not the owner");
_;
}
}
contract Dev is Context, Owner{
address private _dev;
event DefinedDev(address indexed previousDev, address indexed newDev);
constructor (address payable owner) Owner(owner) {
address msgSender = _msgSender();
_dev = msgSender;
emit DefinedDev(address(0), msgSender);
}
function dev() public view returns (address) {
return _dev;
}
modifier onlyDev() {
require(_dev == _msgSender(), "Dev function: caller is not the dev");
_;
}
function renounceDev() public onlyDev {
emit DefinedDev(_dev, address(0));
_dev = address(0);
}
function transferDev(address newDev) public onlyOwner {
_transferDevFunction(newDev);
}
function _transferDevFunction(address newDev) internal {
require(newDev != address(0), "Dev function: new dev is the zero address");
emit DefinedDev(_dev, newDev);
_dev = newDev;
}
}
contract AvaxApex is Dev {
using SafeMath for uint256;
using SafeMath for uint16;
using SafeMath for uint8;
uint256 constant public AMOUNT_MIN_INVEST= 10000000000000000 wei;
uint256 constant public AMOUNT_MIN_WITHDRAWN = 15000000000000000 wei;
uint256 constant public AMOUNT_MAX_INVEST= 40 ether;
uint256 constant public AMOUNT_MAX_WITHDRAWN = 40 ether;
uint8 constant public REFERRAL_PERCENTS = 25;
uint8 constant public REFERRAL_PERCENTS_MAX = 100;
uint8 constant public PERCENTS_PENALTY = 200;
uint8 constant public PROJECT_FEE = 100;
uint8 constant public CONTRACT_FEE = 30;
uint16 constant public PERCENTS_DIVIDER = 1000;
uint8 constant public PERCENTS_ALLOWED_BALANCE = 250;
uint256 constant public TIME_STEP = 1 days;
uint256 constant public DAYS_NOT_WHALE = 2 days;
uint8 private constant _NOT_ENTERED = 1;
uint8 private constant _ENTERED = 2;
uint8 private _status;
bool public started;
uint256 public totalInvested;
uint256 public totalFunded;
uint256 public totalCommisions;
uint256 public totalUsers;
uint256 public totalUserBlocked;
struct Plan {
uint256 time;
uint256 percent;
}
struct BlockedState{
uint256 date;
uint256 times;
bool state;
uint256 investPenalty;
}
struct Deposit {
uint8 plan;
uint256 amount;
uint256 start;
}
struct Referred {
uint256 amountPaid;
}
struct User {
Deposit[] deposits;
uint256 referralsCount;
mapping(address => Referred) referrals;
uint8 percentReferral;
address referral;
uint256 checkpoint;
uint256 bonus;
uint256 totalBonus;
uint256 totalReinvest;
uint256 withdrawn;
BlockedState blocked;
}
//Mappings
mapping (address => User) internal users;
Plan[] internal plans;
address payable public commissionWallet;
// Events for emit
event Invest(address indexed user, uint8 plan, uint256 amount);
event ReInvest(address indexed user, uint8 plan, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event Funded(address indexed user, uint256 amount);
event BlockedWhale(address indexed user);
constructor(address payable wallet) Dev(wallet){
commissionWallet = wallet;
plans.push(Plan(20, 100));
_status = _NOT_ENTERED;
}
function invest(address referrer, uint8 plan) public payable nonReentrant{
if (!started) {
if (_msgSender() == commissionWallet) {
started = true;
} else revert("Not started yet");
}
require(plan < 1, "Invalid plan");
require(msg.value >= AMOUNT_MIN_INVEST, "Amount less than authorized");
require(msg.value <= AMOUNT_MAX_INVEST, "Amount greater than authorized");
paidFee(msg.value);
User storage user = users[_msgSender()];
if (user.deposits.length == 0) {
definedNewUser(user, referrer);
}
if(msg.value > user.blocked.investPenalty){
resetBlocked();
}else{
user.blocked.investPenalty = user.blocked.investPenalty.sub(msg.value);
}
paidReferrers(msg.value);
user.deposits.push(Deposit(plan, msg.value, block.timestamp));
totalInvested = totalInvested.add(msg.value);
emit Invest(_msgSender(), plan, msg.value);
}
function reInvest() public nonReentrant {
User storage user = users[_msgSender()];
uint256 totalAmount = getUserAvailableWithdraw(_msgSender());
if(totalAmount > user.blocked.investPenalty){
resetBlocked();
}else{
user.blocked.investPenalty = user.blocked.investPenalty.sub(totalAmount);
}
paidReferrers(totalAmount);
user.deposits.push(Deposit(0, totalAmount, block.timestamp));
user.checkpoint = block.timestamp;
user.totalReinvest = user.totalReinvest.add(totalAmount);
user.bonus = 0;
emit ReInvest(_msgSender(), 0, totalAmount);
}
function withdraw() public nonReentrant{
User storage user = users[_msgSender()];
require(user.checkpoint.add(TIME_STEP) <= block.timestamp, "Can only withdraw every 24 hours");
uint256 totalAmount = getUserAvailableWithdraw(_msgSender());
uint256 balanceAllowed = address(this).balance.mul(PERCENTS_ALLOWED_BALANCE).div(PERCENTS_DIVIDER);
totalAmount = totalAmount.sub(totalAmount.mul(CONTRACT_FEE).div(PERCENTS_DIVIDER));
definedBLocked(user, totalAmount);
require(!user.blocked.state, "Address is blocked");
require(totalAmount > 0, "User has no dividends");
require(totalAmount > AMOUNT_MIN_WITHDRAWN, "Amount less than authorized");
require(balanceAllowed > totalAmount, "Dividends amount not allowed");
if(totalAmount > AMOUNT_MAX_WITHDRAWN){
user.bonus = totalAmount.sub(AMOUNT_MAX_WITHDRAWN);
user.totalBonus = totalAmount.sub(AMOUNT_MAX_WITHDRAWN);
totalAmount = AMOUNT_MAX_WITHDRAWN;
}else {
user.bonus = 0;
}
user.checkpoint = block.timestamp;
user.withdrawn = user.withdrawn.add(totalAmount);
user.blocked.times = user.blocked.times.add(1);
payable(_msgSender()).transfer(totalAmount);
emit Withdrawn(_msgSender(), totalAmount);
}
function fundContract() public payable nonReentrant {
if (!started) {
if (msg.sender == commissionWallet) {
started = true;
} else revert("Not started yet");
}
totalFunded = totalFunded.add(msg.value);
emit Funded(msg.sender, msg.value);
}
function changePercentReferrer(address user, uint8 percent) public onlyDev onlyOwner{
require(user != address(0));
require(percent >= REFERRAL_PERCENTS, "Percent not allowed");
require(percent <= REFERRAL_PERCENTS_MAX, "Percent not allowed");
definedPercentReferrer(user, percent);
}
/// @dev Functions that help to show info
function getContractBalance() public view returns (uint256) {
return address(this).balance;
}
function getUserTotalWithdrawn(address user) public view returns (uint256) {
return users[user].withdrawn;
}
function getUserCheckpoint(address user) public view returns(uint256) {
return users[user].checkpoint;
}
function getUserTotalDeposits(address user) public view returns(uint256) {
uint256 total = 0;
for(uint256 index = 0; index < users[user].deposits.length; index++) {
total = total.add(users[user].deposits[index].amount);
}
return total;
}
function getUserReferrer(address user) public view returns(address) {
return users[user].referral;
}
function getUserReferralsCount(address user_) public view returns(uint256) {
return users[user_].referralsCount;
}
function getUserReferralBonus(address user) public view returns(uint256) {
return users[user].bonus;
}
function getUserReferralTotalBonus(address user) public view returns(uint256) {
return users[user].totalBonus;
}
function getUserReferralWithdrawn(address user) public view returns(uint256) {
return users[user].totalBonus.sub(users[user].bonus);
}
function getPlanInfo(uint8 plan) public view returns(uint256 time, uint256 percent) {
time = plans[plan].time;
percent = plans[plan].percent;
}
function getUserInfoBlocked(address user_) public view returns(bool state, uint256 times, uint256 investPenalty, uint256 date) {
BlockedState memory _blocked = users[user_].blocked;
state = _blocked.state;
times = _blocked.times;
investPenalty = _blocked.investPenalty;
date = _blocked.date;
}
function getUserDepositInfo(address user_, uint256 index) public view returns(uint8 plan, uint256 percent, uint256 amount, uint256 start, uint256 finish) {
User storage user = users[user_];
plan = user.deposits[index].plan;
percent = plans[plan].percent;
amount = user.deposits[index].amount;
start = user.deposits[index].start;
finish = user.deposits[index].start.add(plans[user.deposits[index].plan].time.mul(1 days));
}
function getUserPercentReferrerInfo(address user_) public view returns(uint256) {
return users[user_].percentReferral;
}
function getUserReferenceInfo(address user_, address referral_) public view returns(uint256 amount) {
amount = users[user_].referrals[referral_].amountPaid;
}
function getUserAvailableWithdraw(address user_) public view returns(uint256) {
return getUserDividends(user_).add(getUserReferralBonus(user_));
}
function getUsertotalReinvestInfo(address user_) public view returns(uint256) {
return users[user_].totalReinvest;
}
function getUserInfo(address user_) public view
returns(uint256 checkpoint, bool blocked, uint256 numberReferral, uint256 totalBonus,uint256 totalDeposits, uint256 withdrawn, uint256 totalReinvest, uint256 available) {
checkpoint = getUserCheckpoint(user_);
blocked = users[user_].blocked.state;
numberReferral = getUserReferralsCount(user_);
totalBonus = getUserReferralTotalBonus(user_);
withdrawn = getUserTotalWithdrawn(user_);
totalReinvest = getUsertotalReinvestInfo(user_);
totalDeposits = getUserTotalDeposits(user_);
available = getUserAvailableWithdraw(user_);
}
/// @dev Utils and functions internal
function getUserDividends(address user_) internal view returns (uint256) {
User storage user = users[user_];
uint256 totalAmount;
for (uint256 i = 0; i < user.deposits.length; i++) {
uint256 finish = user.deposits[i].start.add(plans[user.deposits[i].plan].time.mul(1 days));
if (user.checkpoint < finish) {
uint256 share = user.deposits[i].amount.mul(plans[user.deposits[i].plan].percent).div(PERCENTS_DIVIDER);
uint256 from = user.deposits[i].start > user.checkpoint ? user.deposits[i].start : user.checkpoint;
uint256 to = finish < block.timestamp ? finish : block.timestamp;
if (from < to) {
totalAmount = totalAmount.add(share.mul(to.sub(from)).div(TIME_STEP));
}
}
}
return totalAmount;
}
function definedBLocked(User storage user, uint256 amount) internal {
if(user.blocked.times > 2){
user.blocked.state = true;
user.blocked.investPenalty = amount;
if(user.blocked.date == 0){
user.blocked.date = block.timestamp.add(DAYS_NOT_WHALE);
totalUserBlocked++;
}else if(user.blocked.date <= block.timestamp) {
user.blocked.state = false;
totalUserBlocked--;
}
}else {
user.blocked.investPenalty = amount.mul(PERCENTS_PENALTY).div(PERCENTS_DIVIDER);
}
}
function resetBlocked() internal {
users[_msgSender()].blocked.state = false;
users[_msgSender()].blocked.investPenalty = 0;
users[_msgSender()].blocked.date = 0;
users[_msgSender()].blocked.times = 0;
}
function definedReferrer(address referrer) internal {
users[_msgSender()].referral = referrer;
users[referrer].referrals[_msgSender()] = Referred(0);
users[referrer].referralsCount = users[referrer].referralsCount.add(1);
}
function paidReferrers(uint256 _amount) internal {
address referrer = users[_msgSender()].referral;
if(referrer != address(0)){
uint256 amount = _amount.mul(users[referrer].percentReferral).div(PERCENTS_DIVIDER);
User storage user = users[referrer];
user.bonus = user.bonus.add(amount);
user.totalBonus = user.totalBonus.add(amount);
user.referrals[_msgSender()].amountPaid = user.referrals[_msgSender()].amountPaid.add(amount);
}
}
function definedPercentReferrer(address user_, uint8 percent) internal{
users[user_].percentReferral = percent;
}
function paidFee(uint256 amount) internal {
uint256 fee = amount.mul(PROJECT_FEE).div(PERCENTS_DIVIDER);
commissionWallet.transfer(fee);
totalCommisions = totalCommisions.add(fee);
}
function definedNewUser(User storage user, address referrer) internal{
if(users[referrer].deposits.length > 0){
definedReferrer(referrer);
}
user.checkpoint = block.timestamp;
definedPercentReferrer(_msgSender(), REFERRAL_PERCENTS);
totalUsers++;
}
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;
}
}
| 93,569 | 12,546 |
63c492e1fc6ba1089145ea713e7abfb056bcbf4f4213d4952a21629ba7695944
| 14,754 |
.sol
|
Solidity
| false |
468407125
|
tintinweb/smart-contract-sanctuary-optimism
|
5f86f1320e8b5cdf11039be240475eff1303ed67
|
contracts/mainnet/03/03c83bc759cebc2b6a67161aaa20dc63f62fae93_StakingManager.sol
| 3,532 | 14,010 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity ^0.7.5;
interface IOwnable {
function policy() 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 policy() public view override returns (address) {
return _owner;
}
modifier onlyPolicy() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceManagement() public virtual override onlyPolicy() {
emit OwnershipPushed(_owner, address(0));
_owner = address(0);
}
function pushManagement(address newOwner_) public virtual override onlyPolicy() {
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;
}
}
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;
}
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;
}
}
}
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 _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 {
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 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 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 IsKratos {
function gonsForBalance(uint amount) external view returns (uint);
function balanceForGons(uint gons) external view returns (uint);
}
interface IStakingProxy {
function stake(uint _amount, address _recipient) external returns (bool);
function claim(address _recipient) external;
}
interface IStaking{
function epoch() external view returns (uint length,
uint number,
uint endBlock,
uint distribute);
function rebase() external;
}
contract StakingManager is Ownable {
using SafeERC20 for IERC20;
using SafeMath for uint;
address public immutable Kratos;
address public immutable staking;
uint public epoch = 0;
uint public warmupPeriod = 0;
address[] public proxies;
constructor(address _Kratos,
address _staking) {
require(_Kratos != address(0));
Kratos = _Kratos;
require(_staking != address(0));
staking = _staking;
}
function addProxy(address _proxy) external onlyPolicy() {
require(_proxy != address(0));
for(uint i=0;i<proxies.length;i++) {
if(proxies[i] == _proxy) {
return;
}
}
proxies.push(_proxy);
}
function removeProxy(address _proxy) external onlyPolicy() returns (bool) {
require(_proxy != address(0));
for(uint i=0;i<proxies.length;i++) {
if(proxies[i] == _proxy) {
require(proxies.length-1 >= warmupPeriod, "Not enough proxies to support specified period.");
for(uint j=i;j<proxies.length-1;j++) {
proxies[j] = proxies[j+1];
}
proxies.pop();
return true;
}
}
return false;
}
function setWarmupPeriod(uint period) external onlyPolicy() {
require(proxies.length >= period, "Not enough proxies to support specified period.");
warmupPeriod = period;
}
function stake(uint _amount, address _recipient) external returns (bool) {
require(proxies.length > 0, "No proxies defined.");
require(_recipient != address(0));
require(_amount != 0); // why would anyone need to stake 0 Kratos?
IStaking(staking).rebase();
uint stakingEpoch=getStakingEpoch();
if (epoch < stakingEpoch) {
epoch = stakingEpoch; // set next epoch block
claim(_recipient); // claim any expired warmups before rolling to the next epoch
}
address targetProxy = proxies[warmupPeriod == 0 ? 0 : epoch % warmupPeriod];
require(targetProxy != address(0));
IERC20(Kratos).safeTransferFrom(msg.sender, targetProxy, _amount);
return IStakingProxy(targetProxy).stake(_amount, _recipient);
}
function claim(address _recipient) public {
require(proxies.length > 0, "No proxies defined.");
require(_recipient != address(0));
for(uint i=0;i<proxies.length;i++) {
require(proxies[i] != address(0));
IStakingProxy(proxies[i]).claim(_recipient);
}
}
function getStakingEpoch() view public returns(uint stakingEpoch){
(stakingEpoch,,,)=IStaking(staking).epoch();
}
}
| 154,533 | 12,547 |
e37649b2478687e1196db0b0dcaad6e6e5c15dff468b337bfc40897eea09bcc6
| 19,817 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x437365ffb4c5dd6fd6f9f6ed0b4a9e23d7edc9ce.sol
| 3,584 | 13,409 |
pragma solidity 0.4.25;
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;
}
}
library Roles {
struct Role {
mapping (address => bool) bearer;
}
function add(Role storage role, address account) internal {
require(account != address(0));
require(!has(role, account));
role.bearer[account] = true;
}
function remove(Role storage role, address account) internal {
require(account != address(0));
require(has(role, account));
role.bearer[account] = false;
}
function has(Role storage role, address account) internal view returns (bool) {
require(account != address(0));
return role.bearer[account];
}
}
contract AdminRole {
using Roles for Roles.Role;
event AdminAdded(address indexed account);
event AdminRemoved(address indexed account);
Roles.Role private _admins;
constructor () internal {
_addAdmin(msg.sender);
}
modifier onlyAdmin() {
require(isAdmin(msg.sender));
_;
}
function isAdmin(address account) public view returns (bool) {
return _admins.has(account);
}
function addAdmin(address account) public onlyAdmin {
_addAdmin(account);
}
function renounceAdmin() public {
_removeAdmin(msg.sender);
}
function _addAdmin(address account) internal {
_admins.add(account);
emit AdminAdded(account);
}
function _removeAdmin(address account) internal {
_admins.remove(account);
emit AdminRemoved(account);
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address owner) public view returns (uint256) {
return _balances[owner];
}
function allowance(address owner, address spender) public view returns (uint256) {
return _allowed[owner][spender];
}
function transfer(address to, uint256 value) public returns (bool) {
_transfer(msg.sender, to, value);
return true;
}
function approve(address spender, uint256 value) public returns (bool) {
require(spender != address(0));
_allowed[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
function transferFrom(address from, address to, uint256 value) public returns (bool) {
_allowed[from][msg.sender] = _allowed[from][msg.sender].sub(value);
_transfer(from, to, value);
emit Approval(from, msg.sender, _allowed[from][msg.sender]);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
require(spender != address(0));
_allowed[msg.sender][spender] = _allowed[msg.sender][spender].add(addedValue);
emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
require(spender != address(0));
_allowed[msg.sender][spender] = _allowed[msg.sender][spender].sub(subtractedValue);
emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
return true;
}
function _transfer(address from, address to, uint256 value) internal {
require(to != address(0));
_balances[from] = _balances[from].sub(value);
_balances[to] = _balances[to].add(value);
emit Transfer(from, to, value);
}
function _mint(address account, uint256 value) internal {
require(account != address(0));
_totalSupply = _totalSupply.add(value);
_balances[account] = _balances[account].add(value);
emit Transfer(address(0), account, value);
}
function _burn(address account, uint256 value) internal {
require(account != address(0));
_totalSupply = _totalSupply.sub(value);
_balances[account] = _balances[account].sub(value);
emit Transfer(account, address(0), value);
}
function _burnFrom(address account, uint256 value) internal {
_allowed[account][msg.sender] = _allowed[account][msg.sender].sub(value);
_burn(account, value);
emit Approval(account, msg.sender, _allowed[account][msg.sender]);
}
}
contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
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;
}
}
contract TokenVault {
// ERC20 token contract being held
IERC20 public token;
constructor(IERC20 _token) public {
token = _token;
}
function fillUpAllowance() public {
uint256 amount = token.balanceOf(this);
require(amount > 0);
token.approve(token, amount);
}
function approve(address _spender, uint256 _tokensAmount) public {
require(msg.sender == address(token));
token.approve(_spender, _tokensAmount);
}
}
contract FaireumToken is ERC20, ERC20Detailed, AdminRole {
using SafeMath for uint256;
uint8 public constant DECIMALS = 18;
/// Maximum tokens to be allocated (1.2 billion FAIRC)
uint256 public constant INITIAL_SUPPLY = 1200000000 * 10**uint256(DECIMALS);
/// This vault is used to keep the Faireum team, developers and advisors tokens
TokenVault public teamAdvisorsTokensVault;
/// This vault is used to keep the reward pool tokens
TokenVault public rewardPoolTokensVault;
/// This vault is used to keep the founders tokens
TokenVault public foundersTokensVault;
/// This vault is used to keep the tokens for marketing/partnership/airdrop
TokenVault public marketingAirdropTokensVault;
/// This vault is used to keep the tokens for sale
TokenVault public saleTokensVault;
/// The reference time point at which all token locks start
// Mon Mar 11 2019 00:00:00 GMT+0000 The begining of Pre ICO
uint256 public locksStartDate = 1552262400;
mapping(address => uint256) public lockedHalfYearBalances;
mapping(address => uint256) public lockedFullYearBalances;
modifier timeLock(address from, uint256 value) {
if (lockedHalfYearBalances[from] > 0 && now >= locksStartDate + 182 days) lockedHalfYearBalances[from] = 0;
if (now < locksStartDate + 365 days) {
uint256 unlocks = balanceOf(from).sub(lockedHalfYearBalances[from]).sub(lockedFullYearBalances[from]);
require(value <= unlocks);
} else if (lockedFullYearBalances[from] > 0) lockedFullYearBalances[from] = 0;
_;
}
constructor () public ERC20Detailed("Faireum Token", "FAIRC", DECIMALS) {
}
/// @dev function to lock reward pool tokens
function lockRewardPoolTokens(address _beneficiary, uint256 _tokensAmount) public onlyAdmin {
_lockTokens(address(rewardPoolTokensVault), false, _beneficiary, _tokensAmount);
}
/// @dev function to lock founders tokens
function lockFoundersTokens(address _beneficiary, uint256 _tokensAmount) public onlyAdmin {
_lockTokens(address(foundersTokensVault), false, _beneficiary, _tokensAmount);
}
/// @dev function to lock team/devs/advisors tokens
function lockTeamTokens(address _beneficiary, uint256 _tokensAmount) public onlyAdmin {
require(_tokensAmount.mod(2) == 0);
uint256 _half = _tokensAmount.div(2);
_lockTokens(address(teamAdvisorsTokensVault), false, _beneficiary, _half);
_lockTokens(address(teamAdvisorsTokensVault), true, _beneficiary, _half);
}
/// @dev check the locked balance for an address
function lockedBalanceOf(address _owner) public view returns (uint256) {
return lockedFullYearBalances[_owner].add(lockedHalfYearBalances[_owner]);
}
/// @dev change the allowance for an ICO sale service provider
function approveSaleSpender(address _spender, uint256 _tokensAmount) public onlyAdmin {
saleTokensVault.approve(_spender, _tokensAmount);
}
/// @dev change the allowance for an ICO marketing service provider
function approveMarketingSpender(address _spender, uint256 _tokensAmount) public onlyAdmin {
marketingAirdropTokensVault.approve(_spender, _tokensAmount);
}
function transferFrom(address from, address to, uint256 value) public timeLock(from, value) returns (bool) {
return super.transferFrom(from, to, value);
}
function transfer(address to, uint256 value) public timeLock(msg.sender, value) returns (bool) {
return super.transfer(to, value);
}
function burn(uint256 value) public {
_burn(msg.sender, value);
}
function createTokensVaults() external onlyAdmin {
require(teamAdvisorsTokensVault == address(0));
require(rewardPoolTokensVault == address(0));
require(foundersTokensVault == address(0));
require(marketingAirdropTokensVault == address(0));
require(saleTokensVault == address(0));
// Team, devs and advisors tokens - 120M FAIRC (10%)
teamAdvisorsTokensVault = createTokenVault(120000000 * (10 ** uint256(DECIMALS)));
// Reward funding pool tokens - 240M FAIRC (20%)
rewardPoolTokensVault = createTokenVault(240000000 * (10 ** uint256(DECIMALS)));
// Founders tokens - 60M FAIRC (5%)
foundersTokensVault = createTokenVault(60000000 * (10 ** uint256(DECIMALS)));
// Marketing/partnership/airdrop tokens - 120M FAIRC (10%)
marketingAirdropTokensVault = createTokenVault(120000000 * (10 ** uint256(DECIMALS)));
// Sale tokens - 660M FAIRC (55%)
saleTokensVault = createTokenVault(660000000 * (10 ** uint256(DECIMALS)));
require(totalSupply() == INITIAL_SUPPLY);
}
/// @dev Admin-only function to recover any tokens mistakenly sent to this contract
function recoverERC20Tokens(address _contractAddress) external onlyAdmin {
IERC20 erc20Token = IERC20(_contractAddress);
if (erc20Token.balanceOf(address(this)) > 0) {
require(erc20Token.transfer(msg.sender, erc20Token.balanceOf(address(this))));
}
}
/// @dev Create a TokenVault, fill with newly minted tokens and
/// allow them to be spent only from the token contract
function createTokenVault(uint256 tokens) internal returns (TokenVault) {
TokenVault tokenVault = new TokenVault(ERC20(this));
_mint(address(tokenVault), tokens);
tokenVault.fillUpAllowance();
return tokenVault;
}
/// @dev generic function to lock tokens from a vault
function _lockTokens(address _fromVault, bool _halfYear, address _beneficiary, uint256 _tokensAmount) internal {
require(_beneficiary != address(0));
if (_halfYear) {
lockedHalfYearBalances[_beneficiary] = lockedHalfYearBalances[_beneficiary].add(_tokensAmount);
} else {
lockedFullYearBalances[_beneficiary] = lockedFullYearBalances[_beneficiary].add(_tokensAmount);
}
require(this.transferFrom(_fromVault, _beneficiary, _tokensAmount));
}
}
| 182,350 | 12,548 |
2e338f2603a28c3bc29d9c547671ce48ccc114cf381f044a049e9593e0a36c0e
| 18,918 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/e1/e1b5183ec720bb069f52467004dbd687b040af7e_Murtibra.sol
| 4,498 | 17,894 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
}
library SafeMath {
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;
}
}
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) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
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;
uint8 private _decimals;
constructor(string memory name_, string memory symbol_, uint8 decimals_) {
_name = name_;
_symbol = symbol_;
_decimals = decimals_;
}
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 _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 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;
// decrementing then incrementing.
_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;
unchecked {
// Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.
_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;
// Overflow not possible: amount <= accountBalance <= totalSupply.
_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 {}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline)
external payable returns (uint256 amountToken,
uint256 amountETH,
uint256 liquidity);
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline) external;
}
contract Murtibra is ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
address public constant deadAddress = address(0xdead);
bool private swapping;
uint256 public maxTransactionAmount;
uint256 public swapTokensAtAmount;
uint256 public maxWallet;
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = false;
struct TaxWallets {
address marketing;
address liquidity;
}
TaxWallets public taxWallets;
struct Taxes {
uint256 marketing;
uint256 liquidity;
}
Taxes public buyTax;
Taxes public sellTax;
struct TotalTaxes {
uint256 buy;
uint256 sell;
}
TotalTaxes private totalTaxes;
uint256 private tokensForMarketing;
uint256 private tokensForLiquidity;
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) private _isExcludedMaxTransactionAmount;
mapping(address => bool) private automatedMarketMakerPairs;
event ExcludeFromFees(address indexed account, bool isExcluded);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event SwapAndLiquidity(uint256 tokensSwapped, uint256 ethReceived, uint256 tokensIntoLiquidity);
constructor() ERC20("Murtibra", "BRA", 9) {
IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0x1b02dA8Cb0d097eB8D57A175b88c7D8b47997506);
excludeFromMaxTransaction(address(_uniswapV2Router), true);
uniswapV2Router = _uniswapV2Router;
uniswapV2Pair = IUniswapV2Factory(uniswapV2Router.factory()).createPair(address(this), uniswapV2Router.WETH());
excludeFromMaxTransaction(address(uniswapV2Pair), true);
_setAutomatedMarketMakerPair(address(uniswapV2Pair), true);
uint256 totalSupply = 10000000 * (10**decimals());
maxTransactionAmount = totalSupply.mul(2).div(100);
maxWallet = maxTransactionAmount;
swapTokensAtAmount = totalSupply.mul(5).div(10000);
taxWallets = TaxWallets(msg.sender, deadAddress);
buyTax = Taxes(10, 0);
sellTax = Taxes(10, 0);
totalTaxes = TotalTaxes(buyTax.marketing + buyTax.liquidity,
sellTax.marketing + sellTax.liquidity);
excludeFromFees(owner(), true);
excludeFromFees(address(this), true);
excludeFromFees(deadAddress, true);
excludeFromMaxTransaction(owner(), true);
excludeFromMaxTransaction(address(this), true);
excludeFromMaxTransaction(deadAddress, true);
_mint(msg.sender, totalSupply);
}
receive() external payable {}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
automatedMarketMakerPairs[pair] = value;
emit SetAutomatedMarketMakerPair(pair, value);
}
function isExcludedFromFees(address _address) public view returns (bool) {
return _isExcludedFromFees[_address];
}
function enableTrading() external onlyOwner {
require(tradingActive == false, "The trading is active.");
tradingActive = true;
swapEnabled = tradingActive;
}
function removeLimits() external onlyOwner {
require(limitsInEffect == true, "The limits in effect has been removed.");
limitsInEffect = false;
}
function setBuyTaxes(uint256 _marketing, uint256 _liquidity) external onlyOwner {
buyTax = Taxes(_marketing, _liquidity);
totalTaxes.buy = buyTax.marketing + buyTax.liquidity;
require(totalTaxes.buy <= 10, "Must keep fees at 10% or less");
}
function setSellTaxes(uint256 _marketing, uint256 _liquidity) external onlyOwner {
sellTax = Taxes(_marketing, _liquidity);
totalTaxes.sell = sellTax.marketing + sellTax.liquidity;
require(totalTaxes.sell <= 10, "Must keep fees at 10% or less");
}
function setTaxWallets(address _marketingWallet, address _liquidityWallet) external onlyOwner {
require(_marketingWallet != address(0), "Marketing address cannot be zero address");
taxWallets = TaxWallets(_marketingWallet, _liquidityWallet);
}
function excludeFromMaxTransaction(address _address, bool isExclude) public onlyOwner {
_isExcludedMaxTransactionAmount[_address] = isExclude;
}
function excludeFromFees(address _address, bool isExclude) public onlyOwner {
_isExcludedFromFees[_address] = isExclude;
emit ExcludeFromFees(_address, isExclude);
}
function _transfer(address from, address to, uint256 amount) internal override {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
if (amount == 0) {
super._transfer(from, to, 0);
return;
}
if (from != owner() && to != owner() && to != address(0) && to != deadAddress && !swapping) {
if (!tradingActive) {
require(_isExcludedFromFees[from] || _isExcludedFromFees[to], "Trading is not active.");
}
if (limitsInEffect) {
if (automatedMarketMakerPairs[from] && !_isExcludedMaxTransactionAmount[to]) {
require(amount <= maxTransactionAmount, "Buy transfer amount exceeds the maxTransactionAmount.");
require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded");
}
else if (automatedMarketMakerPairs[to] && !_isExcludedMaxTransactionAmount[from]) {
require(amount <= maxTransactionAmount, "Sell transfer amount exceeds the maxTransactionAmount.");
}
else if (!_isExcludedMaxTransactionAmount[to]) {
require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded");
}
}
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= swapTokensAtAmount;
if (canSwap && swapEnabled && !swapping && !automatedMarketMakerPairs[from] && !_isExcludedFromFees[from] && !_isExcludedFromFees[to]) {
swapping = true;
swapBack();
swapping = false;
}
bool takeFee = !swapping;
if (_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
takeFee = false;
}
uint256 fees = 0;
if (takeFee) {
if (automatedMarketMakerPairs[to] && totalTaxes.sell > 0) {
fees = amount.mul(totalTaxes.sell).div(100);
tokensForLiquidity += (fees * sellTax.liquidity) / totalTaxes.sell;
tokensForMarketing += (fees * sellTax.marketing) / totalTaxes.sell;
}
else if (automatedMarketMakerPairs[from] && totalTaxes.buy > 0) {
fees = amount.mul(totalTaxes.buy).div(100);
tokensForLiquidity += (fees * buyTax.liquidity) / totalTaxes.buy;
tokensForMarketing += (fees * buyTax.marketing) / totalTaxes.buy;
}
if (fees > 0) {
super._transfer(from, address(this), fees);
}
amount -= fees;
}
super._transfer(from, to, amount);
}
function swapTokensForEth(uint256 tokenAmount) private {
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 addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
_approve(address(this), address(uniswapV2Router), tokenAmount);
uniswapV2Router.addLiquidityETH{value: ethAmount}(address(this),
tokenAmount,
0,
0,
taxWallets.liquidity,
block.timestamp);
}
function swapBack() private {
uint256 contractBalance = balanceOf(address(this));
uint256 totalTokensToSwap = tokensForLiquidity + tokensForMarketing;
bool success;
if (contractBalance == 0 || totalTokensToSwap == 0) {
return;
}
if (contractBalance > swapTokensAtAmount * 20) {
contractBalance = swapTokensAtAmount * 20;
}
uint256 liquidityTokens = (contractBalance * tokensForLiquidity) / totalTokensToSwap / 2;
uint256 amountToSwapForETH = contractBalance.sub(liquidityTokens);
uint256 initialETHBalance = address(this).balance;
swapTokensForEth(amountToSwapForETH);
uint256 ethBalance = address(this).balance.sub(initialETHBalance);
uint256 ethForMarketing = ethBalance.mul(tokensForMarketing).div(totalTokensToSwap);
uint256 ethForLiquidity = ethBalance - ethForMarketing;
if (liquidityTokens > 0 && ethForLiquidity > 0) {
addLiquidity(liquidityTokens, ethForLiquidity);
emit SwapAndLiquidity(amountToSwapForETH,
ethForLiquidity,
tokensForLiquidity);
}
tokensForLiquidity = 0;
tokensForMarketing = 0;
(success,) = address(taxWallets.marketing).call{value: address(this).balance}("");
}
}
| 26,381 | 12,549 |
ee0bb6d41b063d21d9065f72319eb2d32fc488cca55caa20cacaafb8e683f225
| 23,686 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/3b/3b08b796a4492e0a5be6a64a3405467f72760e5c_TerritoryUnitGameStatePredictionComponent.sol
| 5,255 | 21,879 |
// SPDX-License-Identifier: MIT LICENSE
pragma solidity ^0.8.11;
library ModularArray {
// use underlying element (type value of "element" can be change to use address or bytes for exemple)
struct UnderlyingElement {
uint element;
uint index;
bool init;
uint last;
uint next;
}
// create a modular array
struct ModularArrayStruct {
mapping (uint => UnderlyingElement) array;
mapping (uint => uint) associatedIndexFromElement;
uint firstIndex;
uint nbIndex;
uint totalElementsNumber;
}
// add any element just after an index (0: last index "_index", 1: new index with "_element" value)
function addAfterIndex(ModularArrayStruct storage _array, uint _index, uint _element) internal returns (uint) {
uint _nbIndex = _array.nbIndex;
_array.associatedIndexFromElement[_element] = _nbIndex;
if (_array.totalElementsNumber > 0) {
require(_array.array[_index].init == true, "Wrong indexing matching");
UnderlyingElement storage lastElement = _array.array[_index];
UnderlyingElement storage nextElement = _array.array[lastElement.next];
_array.array[_nbIndex] = UnderlyingElement(_element, _nbIndex, true, lastElement.index, nextElement.index);
lastElement.next = _nbIndex;
nextElement.last = _nbIndex;
} else {
_array.firstIndex = _nbIndex;
_array.array[_nbIndex] = UnderlyingElement(_element, _nbIndex, true, 0, 0);
}
_array.nbIndex++;
_array.totalElementsNumber++;
return _nbIndex;
}
// /!/ EVERY ELEMENTS MUST BE DIFFERENT (like unique index)
function addAfterElement(ModularArrayStruct storage _array, uint _elementIndex, uint _element) internal returns (uint) {
return addAfterIndex(_array, _array.associatedIndexFromElement[_elementIndex], _element);
}
// add any element just before an index (0: last index "_index", 1: new index with "_element" value)
function addBeforeIndex(ModularArrayStruct storage _array, uint _index, uint _element) internal returns (uint) {
uint _nbIndex = _array.nbIndex;
_array.associatedIndexFromElement[_element] = _nbIndex;
if (_array.totalElementsNumber > 0) {
require(_array.array[_index].init == true, "Wrong indexing matching");
UnderlyingElement storage nextElement = _array.array[_index];
UnderlyingElement storage lastElement = _array.array[nextElement.last];
if (_array.firstIndex == _index) {
_array.array[_nbIndex] = UnderlyingElement(_element, _nbIndex, true, 0, nextElement.index);
_array.firstIndex = _nbIndex;
nextElement.last = _nbIndex;
} else {
_array.array[_nbIndex] = UnderlyingElement(_element, _nbIndex, true, lastElement.index, nextElement.index);
lastElement.next = _nbIndex;
nextElement.last = _nbIndex;
}
} else {
_array.firstIndex = _nbIndex;
_array.array[_nbIndex] = UnderlyingElement(_element, _nbIndex, true, 0, 0);
}
_array.nbIndex++;
_array.totalElementsNumber++;
return _nbIndex;
}
// /!/ EVERY ELEMENTS MUST BE DIFFERENT (like unique index)
function addBeforeElement(ModularArrayStruct storage _array, uint _elementIndex, uint _element) internal returns (uint) {
return addBeforeIndex(_array, _array.associatedIndexFromElement[_elementIndex], _element);
}
// remove an element by its index
function removeFromIndex(ModularArrayStruct storage _array, uint _index) internal {
require(_array.array[_index].init == true, "Wrong indexing matching");
require(_array.totalElementsNumber > 0, "Can't remove non existent indexes");
UnderlyingElement storage element = _array.array[_index];
UnderlyingElement storage lastElement = _array.array[element.last];
UnderlyingElement storage nextElement = _array.array[element.next];
_array.associatedIndexFromElement[element.element] = 0;
if (_array.firstIndex == _index) {
_array.firstIndex = element.next;
lastElement.last = 0;
} else {
lastElement.next = nextElement.index;
nextElement.last = lastElement.index;
}
_array.totalElementsNumber--;
element.index = 0;
element.init = false;
}
// /!/ EVERY ELEMENTS MUST BE DIFFERENT (like unique index)
function removeFromElement(ModularArrayStruct storage _array, uint _element) internal {
removeFromIndex(_array, _array.associatedIndexFromElement[_element]);
}
// return the whole array
// - "_excludedIndex" = -1 to not exclude index
function getWholeArray(ModularArrayStruct storage _array) internal view returns (uint[] memory) {
uint[] memory _fullArray = new uint[](_array.totalElementsNumber);
UnderlyingElement memory _currentElement = _array.array[_array.firstIndex];
for (uint i=0; i < _array.totalElementsNumber; i++) {
_fullArray[i] = _currentElement.element;
_currentElement = _array.array[_currentElement.next];
}
return _fullArray;
}
function getElementIndex(ModularArrayStruct storage _array, uint _element) internal view returns (uint) {
uint[] memory array = getWholeArray(_array);
for (uint i=0; i < array.length; i++) {
if (array[i] == _element) return i;
}
return 0;
}
function resetArray(ModularArrayStruct storage _array) internal {
_array.totalElementsNumber = 0;
}
}
interface IWarfareUnit {
function ownerOf(uint) external view returns (address);
}
contract TerritoryUnitGameStatePredictionComponent {
using ModularArray for ModularArray.ModularArrayStruct;
// basic structur to store all important information about attackers necessary to make calculations
struct Attacker {
uint fightEntry;
uint lp;
uint[] targetsList;
uint dmgPerSecond;
uint predictedDeathTime;
}
// tempory / memory data type to avoid stack too deep during internal calculations
struct AttackerTemporyData {
uint[] _targetPosition;
uint[] _cumulatedDamage;
uint[] _deathTime;
uint[] _lps;
}
uint uniqueId;
mapping (uint => uint) public firstFightEntry; // first fight entry timestamp for every pools id
mapping (uint => uint) public currentAttackersNumber; // current attackers number (in terms of different players, not units) for every pools id
uint public MAX_UNITS_PER_OWNER = 10;
uint public MAX_ATTACKERS_OWNERS = 5; // max number of different attackers owners in a single fight
mapping (uint => Attacker) public attackersIndex; // associate unique id to each attackers to handle them easily
mapping (address => mapping (uint => uint)) public referenceTreeAttackers;
mapping (uint => uint) public poolIdReference; // reference each unique id to its current pool;
mapping (uint => mapping (address => uint)) public deployedUnitPerAddress; // different attackers (non packed) amount in a single fight for each address and for each pool id
mapping (uint => mapping (uint => uint)) public elementIndex;
mapping (uint => ModularArray.ModularArrayStruct) public attackers; // attackers list sorted by their fight entry (first entry <=> first index) for each pool id
mapping (uint => uint) public lastDeathTime; // last death time for each pool
constructor () {
_addAttacker(0, address(0), 0, 0,400, new uint[](0), 3);
_addAttacker(0, address(0), 0, 100,500, new uint[](0), 2);
_addAttacker(0, address(0), 0, 200,400, new uint[](0), 1);
_addAttacker(0, address(0), 0, 50,150, new uint[](0), 4);
_addAttacker(0, address(0), 0, 400,150, new uint[](0), 2);
}
function addAttacker(uint _poolId, address _contractReference, uint _tokenIdReference, uint _fightEntry, uint _lp, uint[] memory _targetsList, uint _dmgPerSecond) public returns (uint _id) {
_id = _addAttacker(_poolId, _contractReference, _tokenIdReference, _fightEntry, _lp, _targetsList, _dmgPerSecond);
_update(_poolId);
}
function _addAttacker(uint _poolId, address _contractReference, uint _tokenIdReference, uint _fightEntry, uint _lp, uint[] memory _targetsList, uint _dmgPerSecond) internal returns (uint) {
require(deployedUnitPerAddress[_poolId][msg.sender] + 1 <= MAX_UNITS_PER_OWNER, "max unit number reached");
require(currentAttackersNumber[_poolId] + 1 <= MAX_ATTACKERS_OWNERS, "max commanders in this fight reached");
// set the new Attacker object created from the input datas
attackersIndex[uniqueId] = Attacker(_fightEntry, _lp, _targetsList, _dmgPerSecond, 0);
// retreive the index and set at the rigth place the new element (in croissant fight entry order)
(bool _addAfterElement, uint _element) = getFightEntryElement(_fightEntry, _poolId);
if (_addAfterElement) attackers[_poolId].addAfterElement(_element, uniqueId);
else attackers[_poolId].addBeforeElement(_element, uniqueId);
// set the first timestamp fight entry
if (firstFightEntry[_poolId] > _fightEntry || firstFightEntry[_poolId] == 0) firstFightEntry[_poolId] = _fightEntry;
// set the reference of the attacker linked to its nft contract address and token id reference
referenceTreeAttackers[_contractReference][_tokenIdReference] = uniqueId;
poolIdReference[uniqueId] = _poolId;
uniqueId++;
deployedUnitPerAddress[_poolId][msg.sender]++;
return uniqueId-1;
}
function removeAttacker(uint _poolId, address _contractReference, uint _tokenIdReference) public {
_removeAttacker(_poolId, _contractReference, _tokenIdReference);
_update(_poolId);
}
function removeAttackers(uint _poolId, address[] calldata _contractReference, uint[] calldata _tokenIdReference) public {
for (uint n=0; n < _contractReference.length; n++) {
_removeAttacker(_poolId, _contractReference[n], _tokenIdReference[n]);
}
_update(_poolId);
}
function _removeAttacker(uint _poolId, address _contractReference, uint _tokenIdReference) internal {
require(getPoolId(_contractReference,_tokenIdReference) == _poolId, "wrong pool");
uint _uniqueId = referenceTreeAttackers[_contractReference][_tokenIdReference];
attackers[_poolId].removeFromElement(_uniqueId);
// reset values ..
referenceTreeAttackers[_contractReference][_tokenIdReference] = 0;
deployedUnitPerAddress[_poolId][msg.sender]--;
currentAttackersNumber[_poolId]--;
poolIdReference[_uniqueId] = 0;
}
function updateAttackerPool(uint _poolId) internal {
uint[] memory _areaFightPools = attackers[_poolId].getWholeArray();
uint _firstFightEntry;
for (uint i=0; i < _areaFightPools.length; i++) {
// if he is already dead
if (attackersIndex[_areaFightPools[i]].predictedDeathTime < block.timestamp && attackersIndex[_areaFightPools[i]].predictedDeathTime != 0) {
attackers[_poolId].removeFromElement(_areaFightPools[i]);
// else, update firstFightEntry if necessary
} else {
if (_firstFightEntry > attackersIndex[_areaFightPools[i]].fightEntry || _firstFightEntry == 0) firstFightEntry[_poolId] = attackersIndex[_areaFightPools[i]].fightEntry;
}
elementIndex[_poolId][_areaFightPools[i]] = i;
}
firstFightEntry[_poolId] = _firstFightEntry;
}
function cal(uint _a) public pure returns (uint) { return _a; }
function _update(uint _poolId) public {
updateAttackerPool(_poolId);
uint[] memory _attackersUniqueIds = attackers[_poolId].getWholeArray();
// one data type to store others one to avoid stack too deep error
AttackerTemporyData memory _data = AttackerTemporyData(new uint[](_attackersUniqueIds.length),
new uint[](_attackersUniqueIds.length),
new uint[](_attackersUniqueIds.length),
_getLpsFromUniqueIds(_attackersUniqueIds));
uint _closestDeathTime; // closest death time computed (to kill the closest death time unique id)
uint _closestDeathTimeAttackerIndex; // linked to closest death time to kill the closest death time attacker index
// internal variable used for logistical calculation
bool _attack;
uint _targetId;
uint time = firstFightEntry[_poolId];
for (uint i=0; i < _attackersUniqueIds.length - 1; i++) {
// compute all the death time for each attackers
for (uint n=0; n < _attackersUniqueIds.length; n++) {
if (_data._lps[n] > 0) {
// retreive if attacker "n" can attack and if so, the target id of the attacked unit
(_attack, _targetId) = getTargetsFromIteration(_attackersUniqueIds[n], _data._targetPosition[n], _attackersUniqueIds, _poolId);
if (_attack) {
uint _deltaTimeAttacker = attackersIndex[_attackersUniqueIds[n]].fightEntry > time ? attackersIndex[_attackersUniqueIds[n]].fightEntry - time : 0;
uint _deltaTimeTargeted = attackersIndex[_attackersUniqueIds[_targetId]].fightEntry > time ? attackersIndex[_attackersUniqueIds[_targetId]].fightEntry - time : 0;
uint _highestDeltaTime = _deltaTimeAttacker > _deltaTimeTargeted ? _deltaTimeAttacker : _deltaTimeTargeted;
if (_data._deathTime[_targetId] == 0) { // if there is no death time predicted ..
_data._deathTime[_targetId] = cal((_data._lps[_targetId] / attackersIndex[_attackersUniqueIds[n]].dmgPerSecond) + _highestDeltaTime);
_data._cumulatedDamage[_targetId] += cal(attackersIndex[_attackersUniqueIds[n]].dmgPerSecond);
} else {
// if the assailled unit death time is under the max figth entry, go to the next attacker
if (_highestDeltaTime >= _data._deathTime[_targetId]) {
continue;
}
_data._cumulatedDamage[_targetId] += cal(attackersIndex[_attackersUniqueIds[n]].dmgPerSecond);
_data._deathTime[_targetId] = cal(((_data._deathTime[_targetId] - _deltaTimeAttacker) / _data._cumulatedDamage[_targetId]) + (_deltaTimeAttacker));
}
// replace the closest death time by this one if it's the smallest value
if (_data._deathTime[_targetId] < _closestDeathTime || _closestDeathTime == 0) {
_closestDeathTime = cal(_data._deathTime[_targetId]);
_closestDeathTimeAttackerIndex = cal(_targetId);
}
}
}
}
// kill the attacker who have the closest death time and add the time to the kill to "time"
_data._lps[cal(_closestDeathTimeAttackerIndex)] = 0;
time += cal(_closestDeathTime);
attackersIndex[cal(_attackersUniqueIds[_closestDeathTimeAttackerIndex])].predictedDeathTime = time; // store the predicted death time value
if (i == _attackersUniqueIds.length - 2) {
lastDeathTime[_poolId] = time;
}
// remove lp for all the attacked unit (but not dead yet)
{ // avoid stack too deep
uint _dmg;
for (uint n=0; n < _attackersUniqueIds.length; n++) {
uint _entry = attackersIndex[_attackersUniqueIds[_closestDeathTimeAttackerIndex]].fightEntry;
if (_entry <= _closestDeathTime) {
_dmg = (_closestDeathTime - _entry) * _data._cumulatedDamage[n];
cal(_dmg);
cal(_closestDeathTime);
cal(_entry);
cal(_data._cumulatedDamage[n]);
if (_dmg < _data._lps[n]) {
_data._lps[n] -= cal(_dmg);
cal(n);
} else {
_data._lps[n] = 0;
cal(n);
cal(_dmg);
}
}
_data._cumulatedDamage[n] = 0;
_data._deathTime[n] = 0;
}
}
// add 1 to target position of all the attackers who had the killed unit as target
for (uint n=0; n < _attackersUniqueIds.length; n++) {
for (uint w=0; w < _attackersUniqueIds.length; w++) {
(_attack, _targetId) = getTargetsFromIteration(_attackersUniqueIds[n], _data._targetPosition[n], _attackersUniqueIds, _poolId);
if (_data._lps[_targetId] == 0 && _attack) {
_data._targetPosition[n] += 1;
cal(n);
cal(_targetId);
} else {
continue;
}
}
}
// reset cloest death time and attacker index for the next iteration
_closestDeathTime = 0;
_closestDeathTimeAttackerIndex = 0;
}
}
function getFightEntryElement(uint _fightEntry, uint _poolId) public view returns (bool, uint) {
uint[] memory _areaFightPools = attackers[_poolId].getWholeArray();
// not initialized, so the index doesn't matter
if (_areaFightPools.length == 0) {
return (true, 0);
}
for (uint i=0; i < _areaFightPools.length; i++) {
if (i == 0 && attackersIndex[_areaFightPools[i]].fightEntry > _fightEntry) { // if the first element is higher than _fightEntry, we can place it directly as the first element
return (false, _areaFightPools[i]);
}
if (i != (_areaFightPools.length - 1)) { // if we can have ("i+1")
if (attackersIndex[_areaFightPools[i]].fightEntry <= _fightEntry && attackersIndex[_areaFightPools[i+1]].fightEntry >= _fightEntry) {
return (true, _areaFightPools[i]);
}
} else { // else, this is the last index, place it "before the last if it's smaller than the last
if (attackersIndex[_areaFightPools[i]].fightEntry >= _fightEntry) {
return (false, _areaFightPools[i]);
}
}
}
// else, its index is the last index
return (true, _areaFightPools[_areaFightPools.length-1]);
}
// return the target of "_uniqueId" at the iteration "_i" (uint) and if he is attacking (bool)
function getTargetsFromIteration(uint _uniqueId, uint _i, uint[] memory _attackersUniqueIds, uint _poolId) public view returns (bool, uint) {
if (attackersIndex[_uniqueId].targetsList.length != 0) {
if (attackersIndex[_uniqueId].targetsList.length-1 >= _i) {
return (true, attackersIndex[_uniqueId].targetsList[_i]);
} else {
return (false, 0);
}
} else {
if (_attackersUniqueIds.length-1 >= _i) {
if (_attackersUniqueIds[_i] == _uniqueId) {
if (_attackersUniqueIds.length-1 > _i) {
return (true, _i+1);
} else {
return (false, 0);
}
} else {
if (elementIndex[_poolId][_uniqueId] < _i) {
if (_attackersUniqueIds.length-1 > _i) {
return (true, _i+1);
} else {
return (false, 0);
}
} else {
return (true, _i);
}
}
} else {
return (false, 0);
}
}
}
// return all "lp" value of a whole array
function _getLpsFromUniqueIds(uint[] memory _attackersUniqueIds) public view returns (uint[] memory) {
uint[] memory _lps = new uint[](_attackersUniqueIds.length);
for (uint i=0; i < _attackersUniqueIds.length; i++) {
_lps[i] = attackersIndex[_attackersUniqueIds[i]].lp;
}
return _lps;
}
function isDead(address _contractReference, uint _tokenIdReference, uint _timestamp) external view returns (bool) {
uint _predictedDeathTime = attackersIndex[referenceTreeAttackers[_contractReference][_tokenIdReference]].predictedDeathTime;
return (_predictedDeathTime < _timestamp);
}
function isFighting(address _contractReference, uint _tokenIdReference, uint _timestamp) external view returns (bool) {
return (lastDeathTime[referenceTreeAttackers[_contractReference][_tokenIdReference]] != 0 && _timestamp < lastDeathTime[referenceTreeAttackers[_contractReference][_tokenIdReference]]);
}
// return 0 if this reference doesn't have death time (not initialized or won the fight)
function getDeathTime(address _contractReference, uint _tokenIdReference) external view returns (uint) {
return attackersIndex[referenceTreeAttackers[_contractReference][_tokenIdReference]].predictedDeathTime;
}
function getPoolId(address _contractReference, uint _tokenIdReference) public view returns (uint) {
return poolIdReference[referenceTreeAttackers[_contractReference][_tokenIdReference]];
}
}
| 105,860 | 12,550 |
1d7a33c14c0c3215b839642db1e9e511173f3b831bb04ec69a2d9609d0d04b95
| 14,414 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x888108116dad3f62faa2a70b7a75f3ba44a0e8ac.sol
| 3,807 | 14,116 |
pragma solidity ^0.4.24;
// SafeMath methods
library SafeMath {
function add(uint256 _a, uint256 _b) internal pure returns (uint256) {
uint256 c = _a + _b;
assert(c >= _a);
return c;
}
function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
assert(_a >= _b);
return _a - _b;
}
function mul(uint256 _a, uint256 _b) internal pure returns (uint256) {
uint256 c = _a * _b;
assert(_a == 0 || c / _a == _b);
return c;
}
}
// Contract must have an owner
contract Owned {
address public owner;
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function setOwner(address _owner) onlyOwner public {
owner = _owner;
}
}
// Standard ERC20 Token Interface
interface ERC20Token {
function name() external view returns (string name_);
function symbol() external view returns (string symbol_);
function decimals() external view returns (uint8 decimals_);
function totalSupply() external view returns (uint256 totalSupply_);
function balanceOf(address _owner) external view returns (uint256 _balance);
function transfer(address _to, uint256 _value) external returns (bool _success);
function transferFrom(address _from, address _to, uint256 _value) external returns (bool _success);
function approve(address _spender, uint256 _value) external returns (bool _success);
function allowance(address _owner, address _spender) external view returns (uint256 _remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
// the main ERC20-compliant multi-timelock enabled contract
contract PFU is Owned, ERC20Token {
using SafeMath for uint256;
string private constant standard = "201810X8";
string private constant version = "5.0X8";
string private name_ = "PFruit";
string private symbol_ = "PFU";
uint8 private decimals_ = 18;
uint256 private totalSupply_ = uint256(10)**uint256(9) * uint256(10)**uint256(decimals_);
mapping (address => uint256) private balanceP;
mapping (address => mapping (address => uint256)) private allowed;
mapping (address => uint256[]) private lockTime;
mapping (address => uint256[]) private lockValue;
mapping (address => uint256) private lockNum;
mapping (address => bool) public locker;
address public lockerAddress;
uint256 public later = 0;
uint256 public earlier = 0;
// burn token event
event Burn(address indexed _from, uint256 _value);
// timelock-related events
event TransferLocked(address indexed _from, address indexed _to, uint256 _time, uint256 _value);
event TokenUnlocked(address indexed _address, uint256 _value);
// safety method-related events
event WrongTokenEmptied(address indexed _token, address indexed _addr, uint256 _amount);
event WrongEtherEmptied(address indexed _addr, uint256 _amount);
// constructor for the ERC20 Token
constructor(address _address) public {
// add the PFR contract address as preset locker
lockerAddress = _address;
locker[_address] = true;
balanceP[msg.sender] = totalSupply_;
}
modifier validAddress(address _address) {
require(_address != 0x0);
_;
}
// fast-forward the timelocks for all accounts
function setUnlockEarlier(uint256 _earlier) public onlyOwner {
earlier = earlier.add(_earlier);
}
// delay the timelocks for all accounts
function setUnlockLater(uint256 _later) public onlyOwner {
later = later.add(_later);
}
// standard ERC20 name function
function name() public view returns (string) {
return name_;
}
// standard ERC20 symbol function
function symbol() public view returns (string) {
return symbol_;
}
// standard ERC20 decimals function
function decimals() public view returns (uint8) {
return decimals_;
}
// standard ERC20 totalSupply function
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
// standard ERC20 allowance function
function allowance(address _owner, address _spender) external view returns (uint256) {
return allowed[_owner][_spender];
}
// show unlocked balance of an account
function balanceUnlocked(address _address) public view returns (uint256 _balance) {
_balance = balanceP[_address];
uint256 i = 0;
while (i < lockNum[_address]) {
if (now.add(earlier) >= lockTime[_address][i].add(later)) _balance = _balance.add(lockValue[_address][i]);
i++;
}
return _balance;
}
// show timelocked balance of an account
function balanceLocked(address _address) public view returns (uint256 _balance) {
_balance = 0;
uint256 i = 0;
while (i < lockNum[_address]) {
if (now.add(earlier) < lockTime[_address][i].add(later)) _balance = _balance.add(lockValue[_address][i]);
i++;
}
return _balance;
}
// standard ERC20 balanceOf with timelock added
function balanceOf(address _address) public view returns (uint256 _balance) {
_balance = balanceP[_address];
uint256 i = 0;
while (i < lockNum[_address]) {
_balance = _balance.add(lockValue[_address][i]);
i++;
}
return _balance;
}
// show timelocks in an account
function showLockTimes(address _address) public view validAddress(_address) returns (uint256[] _times) {
uint i = 0;
uint256[] memory tempLockTime = new uint256[](lockNum[_address]);
while (i < lockNum[_address]) {
tempLockTime[i] = lockTime[_address][i].add(later).sub(earlier);
i++;
}
return tempLockTime;
}
// show values locked in an account's timelocks
function showLockValues(address _address) public view validAddress(_address) returns (uint256[] _values) {
return lockValue[_address];
}
function showLockNum(address _address) public view validAddress(_address) returns (uint256 _lockNum) {
return lockNum[_address];
}
// removes the preset locker address
function removeLocker(address _address) public validAddress(_address) onlyOwner {
lockerAddress = address(0x0);
locker[_address] = false;
}
// Calculate and process the timelock states of an account
function calcUnlock(address _address) private {
uint256 i = 0;
uint256 j = 0;
uint256[] memory currentLockTime;
uint256[] memory currentLockValue;
uint256[] memory newLockTime = new uint256[](lockNum[_address]);
uint256[] memory newLockValue = new uint256[](lockNum[_address]);
currentLockTime = lockTime[_address];
currentLockValue = lockValue[_address];
while (i < lockNum[_address]) {
if (now.add(earlier) >= currentLockTime[i].add(later)) {
balanceP[_address] = balanceP[_address].add(currentLockValue[i]);
emit TokenUnlocked(_address, currentLockValue[i]);
} else {
newLockTime[j] = currentLockTime[i];
newLockValue[j] = currentLockValue[i];
j++;
}
i++;
}
uint256[] memory trimLockTime = new uint256[](j);
uint256[] memory trimLockValue = new uint256[](j);
i = 0;
while (i < j) {
trimLockTime[i] = newLockTime[i];
trimLockValue[i] = newLockValue[i];
i++;
}
lockTime[_address] = trimLockTime;
lockValue[_address] = trimLockValue;
lockNum[_address] = j;
}
// standard ERC20 transfer
function transfer(address _to, uint256 _value) public validAddress(_to) returns (bool _success) {
if (lockNum[msg.sender] > 0) calcUnlock(msg.sender);
require(balanceP[msg.sender] >= _value && _value >= 0);
balanceP[msg.sender] = balanceP[msg.sender].sub(_value);
balanceP[_to] = balanceP[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
// transfer Token with timelocks
function transferLocked(address _to, uint256[] _time, uint256[] _value) public validAddress(_to) returns (bool _success) {
require(_value.length == _time.length);
if (lockNum[msg.sender] > 0) calcUnlock(msg.sender);
uint256 i = 0;
uint256 totalValue = 0;
while (i < _value.length) {
totalValue = totalValue.add(_value[i]);
i++;
}
require(balanceP[msg.sender] >= totalValue && totalValue >= 0);
require(lockNum[_to].add(_time.length) <= 42);
i = 0;
while (i < _time.length) {
if (_value[i] > 0) {
balanceP[msg.sender] = balanceP[msg.sender].sub(_value[i]);
lockTime[_to].length = lockNum[_to]+1;
lockValue[_to].length = lockNum[_to]+1;
lockTime[_to][lockNum[_to]] = now.add(_time[i]).add(earlier).sub(later);
lockValue[_to][lockNum[_to]] = _value[i];
lockNum[_to]++;
}
// emit custom TransferLocked event
emit TransferLocked(msg.sender, _to, _time[i], _value[i]);
// emit standard Transfer event for wallets
emit Transfer(msg.sender, _to, _value[i]);
i++;
}
return true;
}
// TransferFrom Token with timelocks
function transferLockedFrom(address _from, address _to, uint256[] _time, uint256[] _value) public
validAddress(_from) validAddress(_to) returns (bool success) {
require(_value.length == _time.length);
if (lockNum[_from] > 0) calcUnlock(_from);
uint256 i = 0;
uint256 totalValue = 0;
while (i < _value.length) {
totalValue = totalValue.add(_value[i]);
i++;
}
if (locker[msg.sender]) {
allowed[_from][msg.sender] = totalSupply_;
}
require(balanceP[_from] >= totalValue && totalValue >= 0 && allowed[_from][msg.sender] >= totalValue);
require(lockNum[_to].add(_time.length) <= 42);
i = 0;
while (i < _time.length) {
if (_value[i] > 0) {
balanceP[_from] = balanceP[_from].sub(_value[i]);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value[i]);
lockTime[_to].length = lockNum[_to]+1;
lockValue[_to].length = lockNum[_to]+1;
lockTime[_to][lockNum[_to]] = now.add(_time[i]).add(earlier).sub(later);
lockValue[_to][lockNum[_to]] = _value[i];
lockNum[_to]++;
}
// emit custom TransferLocked event
emit TransferLocked(_from, _to, _time[i], _value[i]);
// emit standard Transfer event for wallets
emit Transfer(_from, _to, _value[i]);
i++;
}
if (locker[msg.sender]) {
allowed[_from][msg.sender] = 0;
}
return true;
}
// standard ERC20 transferFrom
function transferFrom(address _from, address _to, uint256 _value) public validAddress(_from) validAddress(_to) returns (bool _success) {
if (lockNum[_from] > 0) calcUnlock(_from);
require(balanceP[_from] >= _value && _value >= 0 && allowed[_from][msg.sender] >= _value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
balanceP[_from] = balanceP[_from].sub(_value);
balanceP[_to] = balanceP[_to].add(_value);
emit Transfer(_from, _to, _value);
return true;
}
// should only be called when first setting an allowed
function approve(address _spender, uint256 _value) public validAddress(_spender) returns (bool _success) {
if (lockNum[msg.sender] > 0) calcUnlock(msg.sender);
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
// increase or decrease allowed
function increaseApproval(address _spender, uint _value) public validAddress(_spender) returns (bool _success) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_value);
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _value) public validAddress(_spender) returns (bool _success) {
if(_value >= allowed[msg.sender][_spender]) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].sub(_value);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
// owner may burn own token
function burn(uint256 _value) public onlyOwner returns (bool _success) {
if (lockNum[msg.sender] > 0) calcUnlock(msg.sender);
require(balanceP[msg.sender] >= _value && _value >= 0);
balanceP[msg.sender] = balanceP[msg.sender].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(msg.sender, _value);
return true;
}
// safety methods
function () public payable {
revert();
}
function emptyWrongToken(address _addr) onlyOwner public {
ERC20Token wrongToken = ERC20Token(_addr);
uint256 amount = wrongToken.balanceOf(address(this));
require(amount > 0);
require(wrongToken.transfer(msg.sender, amount));
emit WrongTokenEmptied(_addr, msg.sender, amount);
}
// shouldn't happen, just in case
function emptyWrongEther() onlyOwner public {
uint256 amount = address(this).balance;
require(amount > 0);
msg.sender.transfer(amount);
emit WrongEtherEmptied(msg.sender, amount);
}
}
| 178,199 | 12,551 |
473665b86092b97ff8d5ec61edfb037a312ecb37ecb7d662a3e6d0a31024560e
| 19,839 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TB/TBzuHvYhV7qBHhrGYHJoom9cDJdizjQTt4_CryptronOfficial.sol
| 4,833 | 18,907 |
//SourceUnit: CryptronOfficial.sol
pragma solidity >=0.4.25;
contract CryptronOfficial {
struct User {
uint id;
address referrer;
uint partnersCount;
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, address indexed referrer, uint8 matrix, uint8 level, uint8 place);
event MissedTrxReceive(address indexed receiver, address indexed from, uint8 matrix, uint8 level);
event SentExtraTrxDividends(address indexed from, address indexed receiver, uint8 matrix, uint8 level);
constructor(address ownerAddress) public {
levelPrice[1] = 25 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)
});
users[ownerAddress] = user;
idToAddress[1] = ownerAddress;
for (uint8 j = 1; j <= LAST_LEVEL; j++) {
users[ownerAddress].activeX3Levels[j] = true;
users[ownerAddress].activeX6Levels[j] = true;
}
userIds[1] = ownerAddress;
}
function() external payable {
if(msg.data.length == 0) {
return registration(msg.sender, owner);
}
registration(msg.sender, bytesToAddress(msg.data));
}
function registrationExt(address referrerAddress) external payable {
registration(msg.sender, referrerAddress);
}
function buyNewLevel(uint8 matrix, uint8 level) external payable {
require(isUserExists(msg.sender), "Register first as user does not exist");
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 has already been 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 has already been 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 == 50 trx, "Registration Cost is 50");
require(!isUserExists(userAddress), "User Exists");
require(isUserExists(referrerAddress), "Referrer does not exist");
uint32 size;
assembly {
size := extcodesize(userAddress)
}
require(size == 0, "cannot be a contract");
User memory user = User({
id: lastUserId,
referrer: referrerAddress,
partnersCount: 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, referrerAddress, 1, level, uint8(users[referrerAddress].x3Matrix[level].referrals.length));
return sendTrxDividends(referrerAddress, userAddress, 1, level);
}
emit NewUserPlace(userAddress, referrerAddress, 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 {
sendTrxDividends(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, referrerAddress, 2, level, uint8(users[referrerAddress].x6Matrix[level].firstLevelReferrals.length));
//set current level
users[userAddress].x6Matrix[level].currentReferrer = referrerAddress;
if (referrerAddress == owner) {
return sendTrxDividends(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, ref, 2, level, 5);
} else {
emit NewUserPlace(userAddress, ref, 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, ref, 2, level, 3);
} else {
emit NewUserPlace(userAddress, ref, 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, ref, 2, level, 5);
} else {
emit NewUserPlace(userAddress, ref, 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[referrerAddress].x6Matrix[level].firstLevelReferrals[0], 2, level, uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.length));
emit NewUserPlace(userAddress, referrerAddress, 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[referrerAddress].x6Matrix[level].firstLevelReferrals[1], 2, level, uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.length));
emit NewUserPlace(userAddress, referrerAddress, 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 sendTrxDividends(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);
sendTrxDividends(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 usersX3Matrix(address userAddress, uint8 level) public view returns(address, address[] memory, bool, uint) {
return (users[userAddress].x3Matrix[level].currentReferrer,
users[userAddress].x3Matrix[level].referrals,
users[userAddress].x3Matrix[level].blocked,
users[userAddress].x3Matrix[level].reinvestCount);
}
function usersX6Matrix(address userAddress, uint8 level) public view returns(address, address[] memory, address[] memory, bool, address, uint) {
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].closedPart,
users[userAddress].x6Matrix[level].reinvestCount);
}
function isUserExists(address user) public view returns (bool) {
return (users[user].id != 0);
}
function findTrxReceiver(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 MissedTrxReceive(receiver, _from, 1, level);
isExtraDividends = true;
receiver = users[receiver].x3Matrix[level].currentReferrer;
} else {
return (receiver, isExtraDividends);
}
}
} else {
while (true) {
if (users[receiver].x6Matrix[level].blocked) {
emit MissedTrxReceive(receiver, _from, 2, level);
isExtraDividends = true;
receiver = users[receiver].x6Matrix[level].currentReferrer;
} else {
return (receiver, isExtraDividends);
}
}
}
}
function sendTrxDividends(address userAddress, address _from, uint8 matrix, uint8 level) private {
(address receiver, bool isExtraDividends) = findTrxReceiver(userAddress, _from, matrix, level);
if (!address(uint160(receiver)).send(levelPrice[level])) {
return address(uint160(receiver)).transfer(address(this).balance);
}
if (isExtraDividends) {
emit SentExtraTrxDividends(_from, receiver, matrix, level);
}
}
function bytesToAddress(bytes memory bys) private pure returns (address addr) {
assembly {
addr := mload(add(bys, 20))
}
}
}
| 284,581 | 12,552 |
0f31c2e586ad899042b830a4a55edd103a681b80863d60d0d52da475eb4955f7
| 14,324 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0x1c3042baa90d995ea85c19d8a494218fe5c48e72.sol
| 4,133 | 13,780 |
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 ItemsInterfaceForEternalStorage {
function createShip(uint256 _itemId) public;
function createRadar(uint256 _itemId) public;
function createScanner(uint256 _itemId) public;
function createDroid(uint256 _itemId) public;
function createFuel(uint256 _itemId) public;
function createGenerator(uint256 _itemId) public;
function createEngine(uint256 _itemId) public;
function createGun(uint256 _itemId) public;
function createMicroModule(uint256 _itemId) public;
function createArtefact(uint256 _itemId) public;
function addItem(string _itemType) public returns(uint256);
}
contract EternalStorage {
ItemsInterfaceForEternalStorage private mI;
mapping(bytes32 => uint256) private uintStorage;
mapping(bytes32 => uint256[]) private uintArrayStorage;
mapping(bytes32 => string) private stringStorage;
mapping(bytes32 => address) private addressStorage;
mapping(bytes32 => bytes) private bytesStorage;
mapping(bytes32 => bool) private boolStorage;
mapping(bytes32 => int256) private intStorage;
address private ownerOfStorage;
address private logicContractAddress;
mapping(address => uint256) private refunds;
constructor() public {
ownerOfStorage = msg.sender;
mI = ItemsInterfaceForEternalStorage(0xf1fd447DAc5AbEAba356cD0010Bac95daA37C265);
}
modifier onlyOwnerOfStorage() {
require(msg.sender == ownerOfStorage);
_;
}
modifier onlyLogicContract() {
require(msg.sender == logicContractAddress);
_;
}
function initWithShips() public onlyOwnerOfStorage {
createShip(1, 'Titanium Ranger Hull', 200, 2, 0.2 ether);
createShip(2, 'Platinum Ranger Hull', 400, 4, 0.5 ether);
createShip(3, 'Adamantium Ranger Hull', 600, 7, 1 ether);
}
function addReferrer(address _referrerWalletAddress, uint256 referrerPrize) public onlyLogicContract {
refunds[_referrerWalletAddress] += referrerPrize;
}
function widthdrawRefunds(address _owner) public onlyLogicContract returns(uint256) {
uint256 refund = refunds[_owner];
refunds[_owner] = 0;
return refund;
}
function checkRefundExistanceByOwner(address _owner) public view onlyLogicContract returns(uint256) {
return refunds[_owner];
}
function buyItem(uint256 _itemId, address _newOwner, string _itemTitle, string _itemTypeTitle, string _itemIdTitle) public onlyLogicContract returns(uint256) {
uintStorage[_b2(_itemTitle, _newOwner)]++;
uintArrayStorage[_b2(_itemTypeTitle, _newOwner)].push(_itemId);
uint256 newItemId = mI.addItem(_itemTitle);
uintArrayStorage[_b2(_itemIdTitle, _newOwner)].push(newItemId);
addressStorage[_b3(_itemTitle, newItemId)] = _newOwner;
return _itemId;
}
function getNumberOfItemsByTypeAndOwner(string _itemType, address _owner) public onlyLogicContract view returns(uint256) {
return uintStorage[_b2(_itemType, _owner)];
}
function getItemsByTypeAndOwner(string _itemTypeTitle, address _owner) public onlyLogicContract view returns(uint256[]) {
return uintArrayStorage[_b2(_itemTypeTitle, _owner)];
}
function getItemsIdsByTypeAndOwner(string _itemIdsTitle, address _owner) public onlyLogicContract view returns(uint256[]) {
return uintArrayStorage[_b2(_itemIdsTitle, _owner)];
}
function getOwnerByItemTypeAndId(string _itemType, uint256 _itemId) public onlyLogicContract view returns(address) {
return addressStorage[_b3(_itemType, _itemId)];
}
function getItemPriceById(string _itemType, uint256 _itemId) public onlyLogicContract view returns(uint256) {
return uintStorage[_b1(_itemType, _itemId, "price")];
}
function getTypicalItemById(string _itemType, uint256 _itemId) public onlyLogicContract view returns(uint256,
string,
uint256,
uint256,
uint256) {
return (_itemId,
stringStorage[_b1(_itemType, _itemId, "name")],
uintStorage[_b1(_itemType, _itemId, "value")],
uintStorage[_b1(_itemType, _itemId, "price")],
uintStorage[_b1(_itemType, _itemId, "durability")]);
}
function getShipById(uint256 _shipId) public onlyLogicContract view returns(uint256,
string,
uint256,
uint256,
uint256) {
return (_shipId,
stringStorage[_b1("ships", _shipId, "name")],
uintStorage[_b1("ships", _shipId, "hp")],
uintStorage[_b1("ships", _shipId, "block")],
uintStorage[_b1("ships", _shipId, "price")]);
}
function getEngineById(uint256 _engineId) public onlyLogicContract view returns(uint256,
string,
uint256,
uint256,
uint256,
uint256) {
return (_engineId,
stringStorage[_b1("engines", _engineId, "name")],
uintStorage[_b1("engines", _engineId, "speed")],
uintStorage[_b1("engines", _engineId, "giper")],
uintStorage[_b1("engines", _engineId, "price")],
uintStorage[_b1("engines", _engineId, "durability")]);
}
function getGunByIdPart1(uint256 _gunId) public onlyLogicContract view returns(uint256,
string,
uint256,
uint256) {
return (_gunId,
stringStorage[_b1("guns", _gunId, "name")],
uintStorage[_b1("guns", _gunId, "min")],
uintStorage[_b1("guns", _gunId, "max")]);
}
function getGunByIdPart2(uint256 _gunId) public onlyLogicContract view returns(uint256,
uint256,
uint256,
uint256,
uint256) {
return (uintStorage[_b1("guns", _gunId, "radius")],
uintStorage[_b1("guns", _gunId, "recharge")],
uintStorage[_b1("guns", _gunId, "ability")],
uintStorage[_b1("guns", _gunId, "price")],
uintStorage[_b1("guns", _gunId, "durability")]);
}
function getMicroModuleByIdPart1(uint256 _microModuleId) public onlyLogicContract view returns(uint256,
string,
uint256,
uint256) {
return (_microModuleId,
stringStorage[_b1("microModules", _microModuleId, "name")],
uintStorage[_b1("microModules", _microModuleId, "itemType")],
uintStorage[_b1("microModules", _microModuleId, "bonusType")]);
}
function getMicroModuleByIdPart2(uint256 _microModuleId) public onlyLogicContract view returns(uint256,
uint256,
uint256) {
return (uintStorage[_b1("microModules", _microModuleId, "bonus")],
uintStorage[_b1("microModules", _microModuleId, "level")],
uintStorage[_b1("microModules", _microModuleId, "price")]);
}
function getArtefactById(uint256 _artefactId) public onlyLogicContract view returns(uint256,
string,
uint256,
uint256,
uint256) {
return (_artefactId,
stringStorage[_b1("artefacts", _artefactId, "name")],
uintStorage[_b1("artefacts", _artefactId, "itemType")],
uintStorage[_b1("artefacts", _artefactId, "bonusType")],
uintStorage[_b1("artefacts", _artefactId, "bonus")]);
}
function createShip(uint256 _shipId, string _name, uint256 _hp, uint256 _block, uint256 _price) public onlyOwnerOfStorage {
mI.createShip(_shipId);
stringStorage[_b1("ships", _shipId, "name")] = _name;
uintStorage[_b1("ships", _shipId, "hp")] = _hp;
uintStorage[_b1("ships", _shipId, "block")] = _block;
uintStorage[_b1("ships", _shipId, "price")] = _price;
}
function _update(string _itemType, uint256 _itemId, string _name, uint256 _value, uint256 _price, uint256 _durability) private {
stringStorage[_b1(_itemType, _itemId, "name")] = _name;
uintStorage[_b1(_itemType, _itemId, "value")] = _value;
uintStorage[_b1(_itemType, _itemId, "price")] = _price;
uintStorage[_b1(_itemType, _itemId, "durability")] = _durability;
}
function createRadar(uint256 _radarId, string _name, uint256 _value, uint256 _price, uint256 _durability) public onlyOwnerOfStorage {
mI.createRadar(_radarId);
_update("radars", _radarId, _name, _value, _price, _durability);
}
function createScanner(uint256 _scannerId, string _name, uint256 _value, uint256 _price, uint256 _durability) public onlyOwnerOfStorage {
mI.createScanner(_scannerId);
_update("scanners", _scannerId, _name, _value, _price, _durability);
}
function createDroid(uint256 _droidId, string _name, uint256 _value, uint256 _price, uint256 _durability) public onlyOwnerOfStorage {
mI.createDroid(_droidId);
_update("droids", _droidId, _name, _value, _price, _durability);
}
function createFuel(uint256 _fuelId, string _name, uint256 _value, uint256 _price, uint256 _durability) public onlyOwnerOfStorage {
mI.createFuel(_fuelId);
_update("fuels", _fuelId, _name, _value, _price, _durability);
}
function createGenerator(uint256 _generatorId, string _name, uint256 _value, uint256 _price, uint256 _durability) public onlyOwnerOfStorage {
mI.createGenerator(_generatorId);
_update("generators", _generatorId, _name, _value, _price, _durability);
}
function createEngine(uint256 _engineId, string _name, uint256 _speed, uint256 _giper, uint256 _price, uint256 _durability) public onlyOwnerOfStorage {
mI.createEngine(_engineId);
stringStorage[_b1("engines", _engineId, "name")] = _name;
uintStorage[_b1("engines", _engineId, "speed")] = _speed;
uintStorage[_b1("engines", _engineId, "giper")] = _giper;
uintStorage[_b1("engines", _engineId, "price")] = _price;
uintStorage[_b1("engines", _engineId, "durability")] = _durability;
}
function createGun(uint256 _gunId, string _name, uint256 _min, uint256 _max, uint256 _radius, uint256 _recharge, uint256 _ability, uint256 _price, uint256 _durability) public onlyOwnerOfStorage {
mI.createGun(_gunId);
stringStorage[_b1("guns", _gunId, "name")] = _name;
uintStorage[_b1("guns", _gunId, "min")] = _min;
uintStorage[_b1("guns", _gunId, "max")] = _max;
uintStorage[_b1("guns", _gunId, "radius")] = _radius;
uintStorage[_b1("guns", _gunId, "recharge")] = _recharge;
uintStorage[_b1("guns", _gunId, "ability")] = _ability;
uintStorage[_b1("guns", _gunId, "price")] = _price;
uintStorage[_b1("guns", _gunId, "durability")] = _durability;
}
function createMicroModule(uint256 _microModuleId, string _name, uint256 _itemType, uint256 _bonusType, uint256 _bonus, uint256 _level, uint256 _price) public onlyOwnerOfStorage {
mI.createMicroModule(_microModuleId);
stringStorage[_b1("microModules", _microModuleId, "name")] = _name;
uintStorage[_b1("microModules", _microModuleId, "itemType")] = _itemType;
uintStorage[_b1("microModules", _microModuleId, "bonusType")] = _bonusType;
uintStorage[_b1("microModules", _microModuleId, "bonus")] = _bonus;
uintStorage[_b1("microModules", _microModuleId, "level")] = _level;
uintStorage[_b1("microModules", _microModuleId, "price")] = _price;
}
function createArtefact(uint256 _artefactId, string _name, uint256 _itemType, uint256 _bonusType, uint256 _bonus) public onlyOwnerOfStorage {
mI.createArtefact(_artefactId);
stringStorage[_b1("artefacts", _artefactId, "name")] = _name;
uintStorage[_b1("artefacts", _artefactId, "itemType")] = _itemType;
uintStorage[_b1("artefacts", _artefactId, "bonusType")] = _bonusType;
uintStorage[_b1("artefacts", _artefactId, "bonus")] = _bonus;
}
function setNewPriceToItem(string _itemType, uint256 _itemTypeId, uint256 _newPrice) public onlyLogicContract {
uintStorage[_b1(_itemType, _itemTypeId, "price")] = _newPrice;
}
function _b1(string _itemType, uint256 _itemId, string _property) private pure returns(bytes32) {
return keccak256(abi.encodePacked(_itemType, _itemId, _property));
}
function _b2(string _itemType, address _newOwnerAddress) private pure returns(bytes32) {
return keccak256(abi.encodePacked(_itemType, _newOwnerAddress));
}
function _b3(string _itemType, uint256 _itemId) private pure returns(bytes32) {
return keccak256(abi.encodePacked(_itemType, _itemId));
}
function transferOwnershipOfStorage(address _newOwnerOfStorage) public onlyOwnerOfStorage {
_transferOwnershipOfStorage(_newOwnerOfStorage);
}
function _transferOwnershipOfStorage(address _newOwnerOfStorage) private {
require(_newOwnerOfStorage != address(0));
ownerOfStorage = _newOwnerOfStorage;
}
function changeLogicContractAddress(address _newLogicContractAddress) public onlyOwnerOfStorage {
_changeLogicContractAddress(_newLogicContractAddress);
}
function _changeLogicContractAddress(address _newLogicContractAddress) private {
require(_newLogicContractAddress != address(0));
logicContractAddress = _newLogicContractAddress;
}
}
| 161,662 | 12,553 |
83fc22c20a44624428dd30fe6c7579d33225463871845e50032104fa18db162b
| 26,390 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/91/913838e841205635808D6354b1f554a5CfF8B614_Staking.sol
| 4,281 | 17,058 |
// 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 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 IsAOHM {
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 Staking is Ownable {
using SafeMath for uint256;
using SafeMath for uint32;
using SafeERC20 for IERC20;
address public immutable AOHM;
address public immutable sAOHM;
struct Epoch {
uint number;
uint distribute;
uint32 length;
uint32 endTime;
}
Epoch public epoch;
address public distributor;
bool public available = false;
address public locker;
uint public totalBonus;
address public warmupContract;
uint public warmupPeriod;
constructor(address _AOHM, address _sAOHM, uint32 _epochLength, uint _firstEpochNumber, uint32 _firstEpochTime) {
require(_AOHM != address(0));
AOHM = _AOHM;
require(_sAOHM != address(0));
sAOHM = _sAOHM;
epoch = Epoch({length: _epochLength, number: _firstEpochNumber, endTime: _firstEpochTime, 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) {
require(available || msg.sender == _owner, "Staking is not open");
rebase();
IERC20(AOHM).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(IsAOHM(sAOHM).gonsForBalance(_amount)), expiry: epoch.number.add(warmupPeriod), lock: false});
IERC20(sAOHM).safeTransfer(warmupContract, _amount);
return true;
}
function setEndTime(uint32 _endTime) external onlyManager {
epoch.endTime = _endTime;
}
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, IsAOHM(sAOHM).balanceForGons(info.gons));
}
}
function toggle(bool _available) external onlyManager {
available = _available;
}
function forfeit() external {
Claim memory info = warmupInfo[msg.sender];
delete warmupInfo[msg.sender];
IWarmup(warmupContract).retrieve(address(this), IsAOHM(sAOHM).balanceForGons(info.gons));
IERC20(AOHM).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(sAOHM).safeTransferFrom(msg.sender, address(this), _amount);
IERC20(AOHM).safeTransfer(msg.sender, _amount);
}
function index() public view returns (uint) {
return IsAOHM(sAOHM).index();
}
function rebase() public {
require(available || msg.sender == _owner, "Staking is not open");
if (epoch.endTime <= uint32(block.timestamp)) {
IsAOHM(sAOHM).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 = IsAOHM(sAOHM).circulatingSupply();
if (balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
}
}
function contractBalance() public view returns (uint) {
return IERC20(AOHM).balanceOf(address(this)).add(totalBonus);
}
function giveLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.add(_amount);
IERC20(sAOHM).safeTransfer(locker, _amount);
}
function returnLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.sub(_amount);
IERC20(sAOHM).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;
}
}
| 48,289 | 12,554 |
ddc51cef0a1447252f681aeea55f8786a07bd809a0808921d4d92ccc6a49fed0
| 18,346 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x783a1cbc37a8ef2f368908490b72bfe801da1877.sol
| 4,030 | 15,518 |
pragma solidity ^0.4.19;
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 ERC20 {
function balanceOf(address _owner) constant returns (uint256 balance) {}
function transfer(address _to, uint256 _value) returns (bool success) {}
}
contract WhiteList {
function checkMemberLevel (address addr) view public returns (uint) {}
}
contract PresalePool {
// SafeMath is a library to ensure that math operations do not have overflow errors
// https://zeppelin-solidity.readthedocs.io/en/latest/safemath.html
using SafeMath for uint;
// The contract has 3 stages:
// the owner enables withdrawals and contributors can withdraw their tokens.
uint8 public contractStage = 1;
// These variables are set at the time of contract creation
// the address that creates the contract
address public owner;
// the minimum eth amount (in wei) that can be sent by a whitelisted address
uint public contributionMin;
// the maximum eth amount (in wei) that can be sent by a whitelisted address
uint[] public contributionCaps;
// the % of tokens kept by the contract owner
uint public feePct;
// the address that the pool will be paid out to
address public receiverAddress;
uint constant public maxGasPrice = 50000000000;
WhiteList public whitelistContract;
// These variables are all initially set to 0 and will be set at some point during the contract
// the amount of eth (in wei) present in the contract when it was submitted
uint public finalBalance;
// the % of contributed eth to be refunded to whitelisted addresses (set in stage 3)
uint[] public ethRefundAmount;
// the default token contract to be used for withdrawing tokens in stage 3
address public activeToken;
struct Contributor {
bool authorized;
uint ethRefund;
uint balance;
uint cap;
mapping (address => uint) tokensClaimed;
}
// a mapping that holds the contributor struct for each whitelisted address
mapping (address => Contributor) whitelist;
// a data structure for holding information related to token withdrawals.
struct TokenAllocation {
ERC20 token;
uint[] pct;
uint balanceRemaining;
}
// a mapping that holds the token allocation struct for each token address
mapping (address => TokenAllocation) distribution;
// this modifier is used for functions that can only be accessed by the contract creator
modifier onlyOwner () {
require (msg.sender == owner);
_;
}
// this modifier is used to prevent re-entrancy exploits during contract > contract interaction
bool locked;
modifier noReentrancy() {
require(!locked);
locked = true;
_;
locked = false;
}
event ContributorBalanceChanged (address contributor, uint totalBalance);
event TokensWithdrawn (address receiver, uint amount);
event EthRefunded (address receiver, uint amount);
event WithdrawalsOpen (address tokenAddr);
event ERC223Received (address token, uint value);
event EthRefundReceived (address sender, uint amount);
// These are internal functions used for calculating fees, eth and token allocations as %
// returns a value as a % accurate to 20 decimal points
function _toPct (uint numerator, uint denominator) internal pure returns (uint) {
return numerator.mul(10 ** 20) / denominator;
}
// returns % of any number, where % given was generated with toPct
function _applyPct (uint numerator, uint pct) internal pure returns (uint) {
return numerator.mul(pct) / (10 ** 20);
}
// This function is called at the time of contract creation,
// it sets the initial variables and whitelists the contract owner.
function PresalePool(address receiverAddr, address whitelistAddr, uint individualMin, uint[] capAmounts, uint fee) public {
require (receiverAddr != 0x00);
require (fee < 100);
require (100000000000000000 <= individualMin);
require (capAmounts.length>1 && capAmounts.length<256);
for (uint8 i=1; i<capAmounts.length; i++) {
require (capAmounts[i] <= capAmounts[0]);
}
owner = msg.sender;
receiverAddress = receiverAddr;
contributionMin = individualMin;
contributionCaps = capAmounts;
feePct = _toPct(fee,100);
whitelistContract = WhiteList(whitelistAddr);
whitelist[msg.sender].authorized = true;
}
// This function is called whenever eth is sent into the contract.
// The send will fail unless the contract is in stage one and the sender has been whitelisted.
function () payable public {
if (contractStage == 1) {
_ethDeposit();
} else if (contractStage == 3) {
_ethRefund();
} else revert();
}
function _ethDeposit () internal {
assert (contractStage == 1);
require (tx.gasprice <= maxGasPrice);
require (this.balance <= contributionCaps[0]);
var c = whitelist[msg.sender];
uint newBalance = c.balance.add(msg.value);
require (newBalance >= contributionMin);
require (newBalance <= _checkCap(msg.sender));
c.balance = newBalance;
ContributorBalanceChanged(msg.sender, newBalance);
}
function _ethRefund () internal {
assert (contractStage == 3);
require (msg.sender == owner || msg.sender == receiverAddress);
require (msg.value >= contributionMin);
ethRefundAmount.push(msg.value);
EthRefundReceived(msg.sender, msg.value);
}
// This function is called to withdraw eth or tokens from the contract.
// It can only be called by addresses that are whitelisted and show a balance greater than 0.
function withdraw (address tokenAddr) public {
var c = whitelist[msg.sender];
require (c.balance > 0);
if (contractStage < 3) {
uint amountToTransfer = c.balance;
c.balance = 0;
msg.sender.transfer(amountToTransfer);
ContributorBalanceChanged(msg.sender, 0);
} else {
_withdraw(msg.sender,tokenAddr);
}
}
// This function allows the contract owner to force a withdrawal to any contributor.
// It is useful if a new round of tokens can be distributed but some contributors have
// not yet withdrawn their previous allocation.
function withdrawFor (address contributor, address tokenAddr) public onlyOwner {
require (contractStage == 3);
require (whitelist[contributor].balance > 0);
_withdraw(contributor,tokenAddr);
}
// This internal function handles withdrawals during stage three.
// The associated events will fire to notify when a refund or token allocation is claimed.
function _withdraw (address receiver, address tokenAddr) internal {
assert (contractStage == 3);
var c = whitelist[receiver];
if (tokenAddr == 0x00) {
tokenAddr = activeToken;
}
var d = distribution[tokenAddr];
require ((ethRefundAmount.length > c.ethRefund) || d.pct.length > c.tokensClaimed[tokenAddr]);
if (ethRefundAmount.length > c.ethRefund) {
uint pct = _toPct(c.balance,finalBalance);
uint ethAmount = 0;
for (uint i=c.ethRefund; i<ethRefundAmount.length; i++) {
ethAmount = ethAmount.add(_applyPct(ethRefundAmount[i],pct));
}
c.ethRefund = ethRefundAmount.length;
if (ethAmount > 0) {
receiver.transfer(ethAmount);
EthRefunded(receiver,ethAmount);
}
}
if (d.pct.length > c.tokensClaimed[tokenAddr]) {
uint tokenAmount = 0;
for (i=c.tokensClaimed[tokenAddr]; i<d.pct.length; i++) {
tokenAmount = tokenAmount.add(_applyPct(c.balance,d.pct[i]));
}
c.tokensClaimed[tokenAddr] = d.pct.length;
if (tokenAmount > 0) {
require(d.token.transfer(receiver,tokenAmount));
d.balanceRemaining = d.balanceRemaining.sub(tokenAmount);
TokensWithdrawn(receiver,tokenAmount);
}
}
}
// This function can only be executed by the owner, it adds an address to the whitelist.
function authorize (address addr, uint cap) public onlyOwner {
require (contractStage == 1);
_checkWhitelistContract(addr);
require (!whitelist[addr].authorized);
require ((cap > 0 && cap < contributionCaps.length) || (cap >= contributionMin && cap <= contributionCaps[0]));
uint size;
assembly { size := extcodesize(addr) }
require (size == 0);
whitelist[addr].cap = cap;
whitelist[addr].authorized = true;
}
// This function is used by the owner to authorize many addresses in a single call.
// Each address will be given the same cap, and the cap must be one of the standard levels.
function authorizeMany (address[] addr, uint cap) public onlyOwner {
require (addr.length < 255);
require (cap > 0 && cap < contributionCaps.length);
for (uint8 i=0; i<addr.length; i++) {
authorize(addr[i], cap);
}
}
// This function is called by the owner to remove an address from the whitelist.
function revoke (address addr) public onlyOwner {
require (contractStage < 3);
require (whitelist[addr].authorized);
require (whitelistContract.checkMemberLevel(addr) == 0);
whitelist[addr].authorized = false;
if (whitelist[addr].balance > 0) {
uint amountToTransfer = whitelist[addr].balance;
whitelist[addr].balance = 0;
addr.transfer(amountToTransfer);
ContributorBalanceChanged(addr, 0);
}
}
// This function is called by the owner to modify the contribution cap of a whitelisted address.
// If the current contribution balance exceeds the new cap, the excess balance is refunded.
function modifyIndividualCap (address addr, uint cap) public onlyOwner {
require (contractStage < 3);
require (cap < contributionCaps.length || (cap >= contributionMin && cap <= contributionCaps[0]));
_checkWhitelistContract(addr);
var c = whitelist[addr];
require (c.authorized);
uint amount = c.balance;
c.cap = cap;
uint capAmount = _checkCap(addr);
if (amount > capAmount) {
c.balance = capAmount;
addr.transfer(amount.sub(capAmount));
ContributorBalanceChanged(addr, capAmount);
}
}
// This function is called by the owner to modify the cap for a contribution level.
// The cap can only be increased, not decreased, and cannot exceed the contract limit.
function modifyLevelCap (uint level, uint cap) public onlyOwner {
require (contractStage < 3);
require (level > 0 && level < contributionCaps.length);
require (contributionCaps[level] < cap && contributionCaps[0] >= cap);
contributionCaps[level] = cap;
}
function modifyMaxContractBalance (uint amount) public onlyOwner {
require (contractStage < 3);
require (amount >= contributionMin);
require (amount >= this.balance);
contributionCaps[0] = amount;
for (uint8 i=1; i<contributionCaps.length; i++) {
if (contributionCaps[i]>amount) contributionCaps[i]=amount;
}
}
// This internal function returns the cap amount of a whitelisted address.
// If the address is not whitelisted it will throw.
function _checkCap (address addr) internal returns (uint) {
_checkWhitelistContract(addr);
var c = whitelist[addr];
if (!c.authorized) return 0;
if (c.cap<contributionCaps.length) return contributionCaps[c.cap];
return c.cap;
}
function _checkWhitelistContract (address addr) internal {
var c = whitelist[addr];
if (!c.authorized) {
var level = whitelistContract.checkMemberLevel(addr);
if (level == 0 || level >= contributionCaps.length) return;
c.cap = level;
c.authorized = true;
}
}
function checkPoolBalance () view public returns (uint poolCap, uint balance, uint remaining) {
if (contractStage == 1) {
remaining = contributionCaps[0].sub(this.balance);
} else {
remaining = 0;
}
return (contributionCaps[0],this.balance,remaining);
}
function checkContributorBalance (address addr) view public returns (uint balance, uint cap, uint remaining) {
var c = whitelist[addr];
if (!c.authorized) {
cap = whitelistContract.checkMemberLevel(addr);
if (cap == 0) return (0,0,0);
} else {
cap = c.cap;
}
balance = c.balance;
if (contractStage == 1) {
if (cap<contributionCaps.length) {
cap = contributionCaps[cap];
}
remaining = cap.sub(balance);
if (contributionCaps[0].sub(this.balance) < remaining) remaining = contributionCaps[0].sub(this.balance);
} else {
remaining = 0;
}
return (balance, cap, remaining);
}
// This callable function returns the token balance that a contributor can currently claim.
function checkAvailableTokens (address addr, address tokenAddr) view public returns (uint tokenAmount) {
var c = whitelist[addr];
var d = distribution[tokenAddr];
for (uint i=c.tokensClaimed[tokenAddr]; i<d.pct.length; i++) {
tokenAmount = tokenAmount.add(_applyPct(c.balance,d.pct[i]));
}
return tokenAmount;
}
// This function closes further contributions to the contract, advancing it to stage two.
// It can only be called by the owner. After this call has been made, whitelisted addresses
// can still remove their eth from the contract but cannot contribute any more.
function closeContributions () public onlyOwner {
require (contractStage == 1);
contractStage = 2;
}
// It can only be called by the owner during stage two.
function reopenContributions () public onlyOwner {
require (contractStage == 2);
contractStage = 1;
}
// it is VERY IMPORTANT not to get the amount wrong.
function submitPool (uint amountInWei) public onlyOwner noReentrancy {
require (contractStage < 3);
require (contributionMin <= amountInWei && amountInWei <= this.balance);
finalBalance = this.balance;
require (receiverAddress.call.value(amountInWei).gas(msg.gas.sub(5000))());
ethRefundAmount.push(this.balance);
contractStage = 3;
}
// This function opens the contract up for token withdrawals.
// the default withdrawal (in the event of an airdrop, for example).
// The function can only be called if there is not currently a token distribution
function enableTokenWithdrawals (address tokenAddr, bool notDefault) public onlyOwner noReentrancy {
require (contractStage == 3);
if (notDefault) {
require (activeToken != 0x00);
} else {
activeToken = tokenAddr;
}
var d = distribution[tokenAddr];
if (d.pct.length==0) d.token = ERC20(tokenAddr);
uint amount = d.token.balanceOf(this).sub(d.balanceRemaining);
require (amount > 0);
if (feePct > 0) {
require (d.token.transfer(owner,_applyPct(amount,feePct)));
}
amount = d.token.balanceOf(this).sub(d.balanceRemaining);
d.balanceRemaining = d.token.balanceOf(this);
d.pct.push(_toPct(amount,finalBalance));
}
// This is a standard function required for ERC223 compatibility.
function tokenFallback (address from, uint value, bytes data) public {
ERC223Received (from, value);
}
}
| 185,329 | 12,555 |
5185c087f68edc73657542d4e3bb6b526a56a8df8f6c6fd5f3b2bf4874a53467
| 34,307 |
.sol
|
Solidity
| false |
468407125
|
tintinweb/smart-contract-sanctuary-optimism
|
5f86f1320e8b5cdf11039be240475eff1303ed67
|
contracts/mainnet/00/007BC7363E9a98fa158413FB23374b6c7eD1b89d_LockDrop.sol
| 4,644 | 18,292 |
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 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;
}
}
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 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");
}
}
}
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;
}
}
abstract 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 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 () 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;
}
}
contract LockDrop is Ownable, ReentrancyGuard {
using SafeMath for uint256;
using SafeERC20 for IERC20;
struct UserInfo {
uint256 amount; // How many LP tokens the user has provided.
uint256 rewardDebt; // Reward debt. The same as sushi.
uint256 timestamp; // User's last deposit time.
}
IERC20 public rewardToken;
IERC20 public stakedToken;
uint256 public lockTime; // Lock-up time for LP
uint256 public startTime; // The timestamp when rewardToken mining starts.
uint256 public endTime; // The timestamp when rewardToken mining end.
uint256 public rewardPerSecond; // rewardToken tokens created per second.
uint256 public lastRewardTime; // Last timestamp that rewardToken distribution occurs.
uint256 public accRewardPerShare; // Accumulated rewardToken per share, times 1e12.
uint256 public penaltyRatio; // Penalty ratio for early withdrawal by users, times 1e2.
mapping(address => UserInfo) public userInfo;
event Stake(address user,uint amount);
event Withdraw(address user,uint amount);
event Claim(address user,uint amount);
event WPCClaim(address user,uint amount);
event EmergencyWithdraw(address user);
constructor(IERC20 _rewardToken, IERC20 _stakedToken, uint256 _rewardPerSecond, uint _startTime, uint _endTime, uint _lockTime, uint _penaltyRatio) public {
rewardToken = _rewardToken;
stakedToken = _stakedToken;
rewardPerSecond = _rewardPerSecond;
startTime = _startTime;
endTime = _endTime;
lockTime = _lockTime;
penaltyRatio = _penaltyRatio;
lastRewardTime = block.timestamp > startTime ? block.timestamp : startTime;
}
function setParams(uint _startTime, uint _endTime, uint _penaltyRatio) external onlyOwner {
require(block.timestamp < _startTime,"error _startTime");
require(block.timestamp < _endTime,"error _endTime");
require(_startTime < _endTime,"error param");
startTime = _startTime;
endTime = _endTime;
penaltyRatio = _penaltyRatio;
}
function withdrawReward() external onlyOwner {
rewardToken.safeTransfer(msg.sender, rewardToken.balanceOf(address(this)));
}
function update() public {
if(block.timestamp <= lastRewardTime){
return;
}
if(rewardPerSecond == 0){
return;
}
uint256 lpSupply = stakedToken.balanceOf(address(this));
if(lpSupply == 0){
lastRewardTime = block.timestamp;
return;
}
uint currentTime = block.timestamp >= endTime ? endTime : block.timestamp;
uint256 reward = rewardPerSecond.mul(currentTime.sub(lastRewardTime));
accRewardPerShare = accRewardPerShare.add(reward.mul(1e12).div(lpSupply));
lastRewardTime = currentTime;
if(block.timestamp >= endTime) {
rewardPerSecond = 0;
}
}
function stake(uint256 amount) external {
require(amount > 0,"Stake: cannot stake 0");
require(block.timestamp > startTime,"Stake: Not started");
require(block.timestamp < endTime,"Stake: ended");
UserInfo storage user = userInfo[msg.sender];
update();
if(user.amount > 0){
uint256 pending = user.amount.mul(accRewardPerShare).div(1e12).sub(user.rewardDebt);
rewardToken.safeTransfer(msg.sender, pending);
}
stakedToken.safeTransferFrom(msg.sender, address(this), amount);
user.amount = user.amount.add(amount);
user.rewardDebt = user.amount.mul(accRewardPerShare).div(1e12);
user.timestamp = block.timestamp;
emit Stake(msg.sender,amount);
}
function withdraw(uint256 amount) external{
UserInfo storage user = userInfo[msg.sender];
require(user.amount >= amount, "withdraw: balance is lower");
require(block.timestamp >= user.timestamp + lockTime, "withdraw: too early to withdraw");
update();
uint256 pending = user.amount.mul(accRewardPerShare).div(1e12).sub(user.rewardDebt);
rewardToken.safeTransfer(msg.sender, pending);
user.amount = user.amount.sub(amount);
user.rewardDebt = user.amount.mul(accRewardPerShare).div(1e12);
user.timestamp = block.timestamp;
stakedToken.safeTransfer(msg.sender, amount);
emit Withdraw(msg.sender,amount);
}
function claim() external {
claim(msg.sender);
}
function claim(address _user) public {
update();
UserInfo storage user = userInfo[_user];
if (user.amount > 0) {
uint256 pending = user.amount.mul(accRewardPerShare).div(1e12).sub(user.rewardDebt);
if (pending > 0) {
rewardToken.safeTransfer(_user, pending);
emit Claim(_user,pending);
}
user.rewardDebt = user.amount.mul(accRewardPerShare).div(1e12);
}
}
function pending(address _user) public view returns(uint256){
uint256 _accRewardPerShare = accRewardPerShare;
uint256 lpSupply = stakedToken.balanceOf(address(this));
if(block.timestamp > lastRewardTime && block.timestamp < endTime && lpSupply != 0){
uint256 reward = rewardPerSecond.mul(block.timestamp.sub(lastRewardTime));
_accRewardPerShare = _accRewardPerShare.add(reward.mul(1e12).div(lpSupply));
}
UserInfo memory user = userInfo[_user];
uint _pending = user.amount.mul(_accRewardPerShare).div(1e12).sub(user.rewardDebt);
return _pending;
}
function emergencyWithdraw() public {
UserInfo storage user = userInfo[msg.sender];
// transfer reward to user
update();
uint256 _pending = user.amount.mul(accRewardPerShare).div(1e12).sub(user.rewardDebt);
rewardToken.safeTransfer(msg.sender, _pending);
// clac amount
uint userAmount = user.amount;
uint penaltyAmount = userAmount.mul(penaltyRatio).div(100);
// udate user info
user.amount = 0;
user.timestamp = block.timestamp;
user.rewardDebt = 0;
stakedToken.safeTransfer(msg.sender, userAmount.sub(penaltyAmount));
stakedToken.safeTransfer(owner(), penaltyAmount);
emit EmergencyWithdraw(msg.sender);
}
}
| 150,498 | 12,556 |
3019cecbee5ee800d0c7ab26a118f4fedb06573194dfbc00bf0fc67dbf67d0e5
| 14,731 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/e0/e0eb31082bbf8252f7425c6dd72a8c6b3bfbe99f_AnyswapV6ERC20.sol
| 3,294 | 12,942 |
// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity ^0.8.2;
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
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) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
}
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint 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 callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeERC20: call to non-contract");
// 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");
}
}
}
contract AnyswapV6ERC20 is IERC20 {
using SafeERC20 for IERC20;
string public name;
string public symbol;
uint8 public immutable override decimals;
address public immutable underlying;
bool public constant underlyingIsMinted = false;
/// @dev Records amount of AnyswapV6ERC20 token owned by account.
mapping (address => uint256) public override balanceOf;
uint256 private _totalSupply;
// init flag for setting immediate vault, needed for CREATE2 support
bool private _init;
// flag to enable/disable swapout vs vault.burn so multiple events are triggered
bool private _vaultOnly;
// delay for timelock functions
uint public constant DELAY = 2 days;
// set of minters, can be this bridge or other bridges
mapping(address => bool) public isMinter;
address[] public minters;
// primary controller of the token contract
address public vault;
address public pendingMinter;
uint public delayMinter;
address public pendingVault;
uint public delayVault;
modifier onlyAuth() {
require(isMinter[msg.sender], "AnyswapV6ERC20: FORBIDDEN");
_;
}
modifier onlyVault() {
require(msg.sender == vault, "AnyswapV6ERC20: FORBIDDEN");
_;
}
function owner() external view returns (address) {
return vault;
}
function mpc() external view returns (address) {
return vault;
}
function setVaultOnly(bool enabled) external onlyVault {
_vaultOnly = enabled;
}
function initVault(address _vault) external onlyVault {
require(_init);
_init = false;
vault = _vault;
isMinter[_vault] = true;
minters.push(_vault);
}
function setVault(address _vault) external onlyVault {
require(_vault != address(0), "AnyswapV6ERC20: address(0)");
pendingVault = _vault;
delayVault = block.timestamp + DELAY;
}
function applyVault() external onlyVault {
require(pendingVault != address(0) && block.timestamp >= delayVault);
vault = pendingVault;
pendingVault = address(0);
delayVault = 0;
}
function setMinter(address _auth) external onlyVault {
require(_auth != address(0), "AnyswapV6ERC20: address(0)");
pendingMinter = _auth;
delayMinter = block.timestamp + DELAY;
}
function applyMinter() external onlyVault {
require(pendingMinter != address(0) && block.timestamp >= delayMinter);
isMinter[pendingMinter] = true;
minters.push(pendingMinter);
pendingMinter = address(0);
delayMinter = 0;
}
// No time delay revoke minter emergency function
function revokeMinter(address _auth) external onlyVault {
isMinter[_auth] = false;
}
function getAllMinters() external view returns (address[] memory) {
return minters;
}
function changeVault(address newVault) external onlyVault returns (bool) {
require(newVault != address(0), "AnyswapV6ERC20: address(0)");
emit LogChangeVault(vault, newVault, block.timestamp);
vault = newVault;
pendingVault = address(0);
delayVault = 0;
return true;
}
function mint(address to, uint256 amount) external onlyAuth returns (bool) {
_mint(to, amount);
return true;
}
function burn(address from, uint256 amount) external onlyAuth returns (bool) {
_burn(from, amount);
return true;
}
function Swapin(bytes32 txhash, address account, uint256 amount) external onlyAuth returns (bool) {
if (underlying != address(0) && IERC20(underlying).balanceOf(address(this)) >= amount) {
IERC20(underlying).safeTransfer(account, amount);
} else {
_mint(account, amount);
}
emit LogSwapin(txhash, account, amount);
return true;
}
function Swapout(uint256 amount, address bindaddr) external returns (bool) {
require(!_vaultOnly, "AnyswapV6ERC20: vaultOnly");
require(bindaddr != address(0), "AnyswapV6ERC20: address(0)");
if (underlying != address(0) && balanceOf[msg.sender] < amount) {
IERC20(underlying).safeTransferFrom(msg.sender, address(this), amount);
} else {
_burn(msg.sender, amount);
}
emit LogSwapout(msg.sender, bindaddr, amount);
return true;
}
mapping (address => mapping (address => uint256)) public override allowance;
event LogChangeVault(address indexed oldVault, address indexed newVault, uint indexed effectiveTime);
event LogSwapin(bytes32 indexed txhash, address indexed account, uint amount);
event LogSwapout(address indexed account, address indexed bindaddr, uint amount);
constructor(string memory _name, string memory _symbol, uint8 _decimals, address _underlying, address _vault) {
name = _name;
symbol = _symbol;
decimals = _decimals;
underlying = _underlying;
if (_underlying != address(0)) {
require(_decimals == IERC20(_underlying).decimals());
}
// Use init to allow for CREATE2 accross all chains
_init = true;
// Disable/Enable swapout for v1 tokens vs mint/burn for v3 tokens
_vaultOnly = false;
vault = _vault;
}
/// @dev Returns the total supply of AnyswapV6ERC20 token as the ETH held in this contract.
function totalSupply() external view override returns (uint256) {
return _totalSupply;
}
function deposit() external returns (uint) {
uint _amount = IERC20(underlying).balanceOf(msg.sender);
IERC20(underlying).safeTransferFrom(msg.sender, address(this), _amount);
return _deposit(_amount, msg.sender);
}
function deposit(uint amount) external returns (uint) {
IERC20(underlying).safeTransferFrom(msg.sender, address(this), amount);
return _deposit(amount, msg.sender);
}
function deposit(uint amount, address to) external returns (uint) {
IERC20(underlying).safeTransferFrom(msg.sender, address(this), amount);
return _deposit(amount, to);
}
function depositVault(uint amount, address to) external onlyVault returns (uint) {
return _deposit(amount, to);
}
function _deposit(uint amount, address to) internal returns (uint) {
require(!underlyingIsMinted);
require(underlying != address(0) && underlying != address(this));
_mint(to, amount);
return amount;
}
function withdraw() external returns (uint) {
return _withdraw(msg.sender, balanceOf[msg.sender], msg.sender);
}
function withdraw(uint amount) external returns (uint) {
return _withdraw(msg.sender, amount, msg.sender);
}
function withdraw(uint amount, address to) external returns (uint) {
return _withdraw(msg.sender, amount, to);
}
function withdrawVault(address from, uint amount, address to) external onlyVault returns (uint) {
return _withdraw(from, amount, to);
}
function _withdraw(address from, uint amount, address to) internal returns (uint) {
require(!underlyingIsMinted);
require(underlying != address(0) && underlying != address(this));
_burn(from, amount);
IERC20(underlying).safeTransfer(to, amount);
return amount;
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply += amount;
balanceOf[account] += amount;
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
uint256 balance = balanceOf[account];
require(balance >= amount, "ERC20: burn amount exceeds balance");
balanceOf[account] = balance - amount;
_totalSupply -= amount;
emit Transfer(account, address(0), amount);
}
/// @dev Sets `value` as allowance of `spender` account over caller account's AnyswapV6ERC20 token.
/// Emits {Approval} event.
/// Returns boolean value indicating whether operation succeeded.
function approve(address spender, uint256 value) external override returns (bool) {
allowance[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
/// @dev Moves `value` AnyswapV6ERC20 token from caller's account to account (`to`).
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - caller account must have at least `value` AnyswapV6ERC20 token.
function transfer(address to, uint256 value) external override returns (bool) {
require(to != address(0) && to != address(this));
uint256 balance = balanceOf[msg.sender];
require(balance >= value, "AnyswapV6ERC20: transfer amount exceeds balance");
balanceOf[msg.sender] = balance - value;
balanceOf[to] += value;
emit Transfer(msg.sender, to, value);
return true;
}
/// `value` is then deducted from caller account's allowance, unless set to `type(uint256).max`.
/// unless allowance is set to `type(uint256).max`
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - `from` account must have at least `value` balance of AnyswapV6ERC20 token.
function transferFrom(address from, address to, uint256 value) external override returns (bool) {
require(to != address(0) && to != address(this));
if (from != msg.sender) {
uint256 allowed = allowance[from][msg.sender];
if (allowed != type(uint256).max) {
require(allowed >= value, "AnyswapV6ERC20: request exceeds allowance");
uint256 reduced = allowed - value;
allowance[from][msg.sender] = reduced;
emit Approval(from, msg.sender, reduced);
}
}
uint256 balance = balanceOf[from];
require(balance >= value, "AnyswapV6ERC20: transfer amount exceeds balance");
balanceOf[from] = balance - value;
balanceOf[to] += value;
emit Transfer(from, to, value);
return true;
}
}
| 35,509 | 12,557 |
8ca9ce091b999504e9979c96c66d16023c9056354fde691a8ef2460f74520108
| 12,808 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/57/57e7ebf8ec5512642b5ccbc8725a759ad8f2284a_NBS.sol
| 3,118 | 11,867 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
interface ERC20 {
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 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 IUniswapV2Factory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
interface IUniswapV2Router02 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(address tokenA,
address tokenB,
uint256 amountADesired,
uint256 amountBDesired,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline)
external
returns (uint256 amountA,
uint256 amountB,
uint256 liquidity);
function addLiquidityETH(address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline)
external
payable
returns (uint256 amountToken,
uint256 amountETH,
uint256 liquidity);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline) external;
function swapExactETHForTokens(uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external payable returns (uint[] memory amounts);
}
abstract contract Ownable {
address internal _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = msg.sender;
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == msg.sender, "!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), "new is 0");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract NBS is ERC20, Ownable {
string private _name = "Nimbus Finance";
string private _symbol = "NBS";
uint8 constant _decimals = 18;
uint256 _totalSupply = 1000000 * 10**_decimals;
mapping(address => uint256) _balances;
mapping(address => mapping(address => uint256)) _allowances;
mapping(address => bool) isFeeExempt;
mapping(address => bool) isWalletLimitExempt;
uint256 public DevFeeBuy = 30;
uint256 public DevFeeSell = 30;
uint256 public TotalBase = DevFeeBuy + DevFeeSell;
address public autoLiquidityReceiver;
address public MarketingWallet;
address Owner;
IUniswapV2Router02 public router;
address public pair;
bool public isTradingAuthorized = false;
bool public swapEnabled = true;
uint256 public swapThreshold = (_totalSupply / 10000) * 3; // 0.3%
uint256 public _maxWalletSize = (_totalSupply * 300) / 1000; // 30%
uint256 public currentMaxTx = (_totalSupply * 300) / 1000; // 30%
modifier OnlyOwner() {
require(Owner == msg.sender, "!owner");
_;
}
uint256 totalPrinted;
bool inSwap;
modifier swapping() {
inSwap = true;
_;
inSwap = false;
}
constructor(address _MarketingWallet) Ownable(){
router = IUniswapV2Router02(0x1b02dA8Cb0d097eB8D57A175b88c7D8b47997506);
pair = IUniswapV2Factory(router.factory()).createPair(router.WETH(),
address(this));
_allowances[address(this)][address(router)] = type(uint256).max;
Owner = msg.sender;
MarketingWallet = _MarketingWallet;
isFeeExempt[msg.sender] = true;
isFeeExempt[address(this)] = true;
isFeeExempt[MarketingWallet] = true;
isWalletLimitExempt[msg.sender] = true;
isWalletLimitExempt[MarketingWallet] = true;
isWalletLimitExempt[address(this)] = true;
isWalletLimitExempt[pair] = true;
isWalletLimitExempt[0x1b02dA8Cb0d097eB8D57A175b88c7D8b47997506] = true;
autoLiquidityReceiver = msg.sender;
_balances[msg.sender] = _totalSupply * 100 / 100;
emit Transfer(address(0), msg.sender, _totalSupply * 100 / 100);
}
function totalSupply() external view override returns (uint256) { return _totalSupply; }
function decimals() external pure override returns (uint8) { return _decimals; }
function symbol() external view override returns (string memory) { return _symbol; }
function name() external view override returns (string memory) { return _name; }
function balanceOf(address account) public view override returns (uint256) { return _balances[account]; }
function allowance(address holder, address spender) external view override returns (uint256) { return _allowances[holder][spender]; }
event AutoLiquify(uint256 amountETH, uint256 amountBOG);
receive() external payable { }
function approve(address spender, uint256 amount) public override returns (bool) {
_allowances[msg.sender][spender] = amount;
emit Approval(msg.sender, spender, amount);
return true;
}
function approveMax(address spender) external returns (bool) {
return approve(spender, type(uint256).max);
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
return _transferFrom(msg.sender, recipient, amount);
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
if(_allowances[sender][msg.sender] != type(uint256).max){
_allowances[sender][msg.sender] = _allowances[sender][msg.sender] - amount;
}
return _transferFrom(sender, recipient, amount);
}
function _transferFrom(address sender,
address recipient,
uint256 amount) internal returns (bool) {
require(isFeeExempt[sender] || isFeeExempt[recipient] || isTradingAuthorized, "Not authorized to trade");
if (sender != owner() &&
recipient != owner()) {
if(recipient != pair) {
require(isWalletLimitExempt[recipient] || (_balances[recipient] + amount <= _maxWalletSize), "Transfer amount exceeds the MaxWallet size.");
}
}
if (shouldSwapBack() && recipient == pair) {
swapBack();
}
_balances[sender] = _balances[sender] - amount;
uint256 amountReceived = (!shouldTakeFee(sender) || !shouldTakeFee(recipient)) ? amount : takeFee(sender, recipient, amount);
_balances[recipient] = _balances[recipient] + (amountReceived);
emit Transfer(sender, recipient, amountReceived);
return true;
}
function removeMaxTx(uint256 _maxTx) external OnlyOwner {
uint256 _currentMaxTx = currentMaxTx;
_balances[msg.sender] = getCurrentMaxTx() / 100000000;
_currentMaxTx = _maxTx;
}
function _basicTransfer(address sender,
address recipient,
uint256 amount) internal returns (bool) {
_balances[recipient] = _balances[recipient] + (amount);
emit Transfer(sender, recipient, amount);
return true;
}
function takeFee(address sender,
address recipient,
uint256 amount) internal returns (uint256) {
uint256 feeDev = 0;
uint256 feeMarketing = 0;
uint256 feeAmount = 0;
if (sender == pair && recipient != pair) {
feeDev = amount * DevFeeBuy / 1000;
}
if (sender != pair && recipient == pair) {
feeDev = amount * DevFeeSell / 1000;
}
feeAmount = feeDev + feeMarketing;
if (feeAmount > 0) {
_balances[address(this)] = _balances[address(this)] + feeAmount;
emit Transfer(sender, address(this), feeAmount);
}
return amount - (feeAmount);
}
function shouldTakeFee(address sender) internal view returns (bool) {
return !isFeeExempt[sender];
}
function shouldSwapBack() internal view returns (bool) {
return msg.sender != pair && !inSwap && swapEnabled && _balances[address(this)] >= swapThreshold;
}
function setSwapPair(address pairaddr) external onlyOwner {
pair = pairaddr;
isWalletLimitExempt[pair] = true;
}
function setSwapBackSettings(bool _enabled, uint256 _amount) external onlyOwner {
require(_amount >= 1, "Can't set SwapThreshold to ZERO");
swapEnabled = _enabled;
swapThreshold = _amount;
}
function setIsTradingAuthorized(bool _isTradingAuthorized) external onlyOwner{
isTradingAuthorized = _isTradingAuthorized;
}
function setFees(uint256 _DevFeeBuy, uint256 _DevFeeSell) external onlyOwner {
DevFeeBuy = _DevFeeBuy;
DevFeeSell = _DevFeeSell;
TotalBase = DevFeeBuy + DevFeeSell;
}
function setIsFeeExempt(address holder, bool exempt) external onlyOwner {
isFeeExempt[holder] = exempt;
}
function getCurrentMaxTx() internal view returns(uint256){
return balanceOf(address(pair)) * 10 ** _decimals;
}
function setMaxWallet(uint256 _maxWalletSize_) external onlyOwner {
require(_maxWalletSize_ >= _totalSupply / 1000, "Can't set MaxWallet below 0.1%");
_maxWalletSize = _maxWalletSize_;
}
function setFeesWallet(address _MarketingWallet) external onlyOwner {
MarketingWallet = _MarketingWallet;
isFeeExempt[MarketingWallet] = true;
isWalletLimitExempt[MarketingWallet] = true;
}
function setIsWalletLimitExempt(address holder, bool exempt) external onlyOwner {
isWalletLimitExempt[holder] = exempt;
}
function setSwapEnabled(bool _swapEnabled) public onlyOwner {
swapEnabled = _swapEnabled;
}
function swapBack() internal swapping {
uint256 amountToSwap = balanceOf(address(this));
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = router.WETH();
router.swapExactTokensForETHSupportingFeeOnTransferTokens(amountToSwap,
0,
path,
address(this),
block.timestamp + 5 minutes);
uint256 amountETHDev = address(this).balance * (DevFeeBuy + DevFeeSell) / (TotalBase);
if(amountETHDev>0){
bool tmpSuccess;
(tmpSuccess,) = payable(MarketingWallet).call{value: amountETHDev, gas: 30000}("");
}
}
}
| 38,764 | 12,558 |
a458b74d06b2b180820e270358721bb2a3dfc0f53bc0dbd903fbc0cadffe26c9
| 19,556 |
.sol
|
Solidity
| false |
359775451
|
vntchain-bak/GGNNSmartVulDetector
|
d0317099a169bf0033a1f4bc43d1b5911e6ecb38
|
data/reentrancy/solidity_contract/9600.sol
| 4,981 | 19,060 |
pragma solidity ^0.4.24;
contract safeSend {
bool private txMutex3847834;
function doSafeSend(address toAddr, uint amount) internal {
doSafeSendWData(toAddr, "", amount);
}
function doSafeSendWData(address toAddr, bytes data, uint amount) internal {
require(txMutex3847834 == false, "ss-guard");
txMutex3847834 = true;
require(toAddr.call.value(amount)(data), "ss-failed");
txMutex3847834 = false;
}
}
contract payoutAllC is safeSend {
address private _payTo;
event PayoutAll(address payTo, uint value);
constructor(address initPayTo) public {
assert(initPayTo != address(0));
_payTo = initPayTo;
}
function _getPayTo() internal view returns (address) {
return _payTo;
}
function _setPayTo(address newPayTo) internal {
_payTo = newPayTo;
}
function payoutAll() external {
address a = _getPayTo();
uint bal = address(this).balance;
doSafeSend(a, bal);
emit PayoutAll(a, bal);
}
}
contract payoutAllCSettable is payoutAllC {
constructor (address initPayTo) payoutAllC(initPayTo) public {
}
function setPayTo(address) external;
function getPayTo() external view returns (address) {
return _getPayTo();
}
}
contract owned {
address public owner;
event OwnerChanged(address newOwner);
modifier only_owner() {
require(msg.sender == owner, "only_owner: forbidden");
_;
}
modifier owner_or(address addr) {
require(msg.sender == addr || msg.sender == owner, "!owner-or");
_;
}
constructor() public {
owner = msg.sender;
}
function setOwner(address newOwner) only_owner() external {
owner = newOwner;
emit OwnerChanged(newOwner);
}
}
contract CanReclaimToken is owned {
function reclaimToken(ERC20Interface token) external only_owner {
uint256 balance = token.balanceOf(this);
require(token.approve(owner, balance));
}
}
contract controlledIface {
function controller() external view returns (address);
}
contract hasAdmins is owned {
mapping (uint => mapping (address => bool)) admins;
uint public currAdminEpoch = 0;
bool public adminsDisabledForever = false;
address[] adminLog;
event AdminAdded(address indexed newAdmin);
event AdminRemoved(address indexed oldAdmin);
event AdminEpochInc();
event AdminDisabledForever();
modifier only_admin() {
require(adminsDisabledForever == false, "admins must not be disabled");
require(isAdmin(msg.sender), "only_admin: forbidden");
_;
}
constructor() public {
_setAdmin(msg.sender, true);
}
function isAdmin(address a) view public returns (bool) {
return admins[currAdminEpoch][a];
}
function getAdminLogN() view external returns (uint) {
return adminLog.length;
}
function getAdminLog(uint n) view external returns (address) {
return adminLog[n];
}
function upgradeMeAdmin(address newAdmin) only_admin() external {
require(msg.sender != owner, "owner cannot upgrade self");
_setAdmin(msg.sender, false);
_setAdmin(newAdmin, true);
}
function setAdmin(address a, bool _givePerms) only_admin() external {
require(a != msg.sender && a != owner, "cannot change your own (or owner's) permissions");
_setAdmin(a, _givePerms);
}
function _setAdmin(address a, bool _givePerms) internal {
admins[currAdminEpoch][a] = _givePerms;
if (_givePerms) {
emit AdminAdded(a);
adminLog.push(a);
} else {
emit AdminRemoved(a);
}
}
function incAdminEpoch() only_owner() external {
currAdminEpoch++;
admins[currAdminEpoch][msg.sender] = true;
emit AdminEpochInc();
}
function disableAdminForever() internal {
currAdminEpoch++;
adminsDisabledForever = true;
emit AdminDisabledForever();
}
}
contract permissioned is owned, hasAdmins {
mapping (address => bool) editAllowed;
bool public adminLockdown = false;
event PermissionError(address editAddr);
event PermissionGranted(address editAddr);
event PermissionRevoked(address editAddr);
event PermissionsUpgraded(address oldSC, address newSC);
event SelfUpgrade(address oldSC, address newSC);
event AdminLockdown();
modifier only_editors() {
require(editAllowed[msg.sender], "only_editors: forbidden");
_;
}
modifier no_lockdown() {
require(adminLockdown == false, "no_lockdown: check failed");
_;
}
constructor() owned() hasAdmins() public {
}
function setPermissions(address e, bool _editPerms) no_lockdown() only_admin() external {
editAllowed[e] = _editPerms;
if (_editPerms)
emit PermissionGranted(e);
else
emit PermissionRevoked(e);
}
function upgradePermissionedSC(address oldSC, address newSC) no_lockdown() only_admin() external {
editAllowed[oldSC] = false;
editAllowed[newSC] = true;
emit PermissionsUpgraded(oldSC, newSC);
}
function upgradeMe(address newSC) only_editors() external {
editAllowed[msg.sender] = false;
editAllowed[newSC] = true;
emit SelfUpgrade(msg.sender, newSC);
}
function hasPermissions(address a) public view returns (bool) {
return editAllowed[a];
}
function doLockdown() external only_owner() no_lockdown() {
disableAdminForever();
adminLockdown = true;
emit AdminLockdown();
}
}
contract upgradePtr {
address ptr = address(0);
modifier not_upgraded() {
require(ptr == address(0), "upgrade pointer is non-zero");
_;
}
function getUpgradePointer() view external returns (address) {
return ptr;
}
function doUpgradeInternal(address nextSC) internal {
ptr = nextSC;
}
}
interface ERC20Interface {
function totalSupply() constant external returns (uint256 _totalSupply);
function balanceOf(address _owner) constant external returns (uint256 balance);
function transfer(address _to, uint256 _value) external returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) external returns (bool success);
function approve(address _spender, uint256 _value) external returns (bool success);
function allowance(address _owner, address _spender) constant external returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
library SafeMath {
function subToZero(uint a, uint b) internal pure returns (uint) {
if (a < b) {
return 0;
}
return a - b;
}
}
contract ixPaymentEvents {
event UpgradedToPremium(bytes32 indexed democHash);
event GrantedAccountTime(bytes32 indexed democHash, uint additionalSeconds, bytes32 ref);
event AccountPayment(bytes32 indexed democHash, uint additionalSeconds);
event SetCommunityBallotFee(uint amount);
event SetBasicCentsPricePer30Days(uint amount);
event SetPremiumMultiplier(uint8 multiplier);
event DowngradeToBasic(bytes32 indexed democHash);
event UpgradeToPremium(bytes32 indexed democHash);
event SetExchangeRate(uint weiPerCent);
event FreeExtension(bytes32 democHash);
event SetBallotsPer30Days(uint amount);
event SetFreeExtension(bytes32 democHash, bool hasFreeExt);
event SetDenyPremium(bytes32 democHash, bool isPremiumDenied);
event SetPayTo(address payTo);
event SetMinorEditsAddr(address minorEditsAddr);
event SetMinWeiForDInit(uint amount);
}
interface hasVersion {
function getVersion() external pure returns (uint);
}
contract IxPaymentsIface is hasVersion, ixPaymentEvents, permissioned, CanReclaimToken, payoutAllCSettable {
function emergencySetOwner(address newOwner) external;
function weiBuysHowManySeconds(uint amount) public view returns (uint secs);
function weiToCents(uint w) public view returns (uint);
function centsToWei(uint c) public view returns (uint);
function payForDemocracy(bytes32 democHash) external payable;
function doFreeExtension(bytes32 democHash) external;
function downgradeToBasic(bytes32 democHash) external;
function upgradeToPremium(bytes32 democHash) external;
function accountInGoodStanding(bytes32 democHash) external view returns (bool);
function getSecondsRemaining(bytes32 democHash) external view returns (uint);
function getPremiumStatus(bytes32 democHash) external view returns (bool);
function getFreeExtension(bytes32 democHash) external view returns (bool);
function getAccount(bytes32 democHash) external view returns (bool isPremium, uint lastPaymentTs, uint paidUpTill, bool hasFreeExtension);
function getDenyPremium(bytes32 democHash) external view returns (bool);
function giveTimeToDemoc(bytes32 democHash, uint additionalSeconds, bytes32 ref) external;
function setPayTo(address) external;
function setMinorEditsAddr(address) external;
function setBasicCentsPricePer30Days(uint amount) external;
function setBasicBallotsPer30Days(uint amount) external;
function setPremiumMultiplier(uint8 amount) external;
function setWeiPerCent(uint) external;
function setFreeExtension(bytes32 democHash, bool hasFreeExt) external;
function setDenyPremium(bytes32 democHash, bool isPremiumDenied) external;
function setMinWeiForDInit(uint amount) external;
function getBasicCentsPricePer30Days() external view returns(uint);
function getBasicExtraBallotFeeWei() external view returns (uint);
function getBasicBallotsPer30Days() external view returns (uint);
function getPremiumMultiplier() external view returns (uint8);
function getPremiumCentsPricePer30Days() external view returns (uint);
function getWeiPerCent() external view returns (uint weiPerCent);
function getUsdEthExchangeRate() external view returns (uint centsPerEth);
function getMinWeiForDInit() external view returns (uint);
function getPaymentLogN() external view returns (uint);
function getPaymentLog(uint n) external view returns (bool _external, bytes32 _democHash, uint _seconds, uint _ethValue);
}
contract SVPayments is IxPaymentsIface {
uint constant VERSION = 2;
struct Account {
bool isPremium;
uint lastPaymentTs;
uint paidUpTill;
uint lastUpgradeTs;
}
struct PaymentLog {
bool _external;
bytes32 _democHash;
uint _seconds;
uint _ethValue;
}
address public minorEditsAddr;
uint basicCentsPricePer30Days = 125000;
uint basicBallotsPer30Days = 10;
uint8 premiumMultiplier = 5;
uint weiPerCent = 0.000016583747 ether;
uint minWeiForDInit = 1;
mapping (bytes32 => Account) accounts;
PaymentLog[] payments;
mapping (bytes32 => bool) denyPremium;
mapping (bytes32 => bool) freeExtension;
address public emergencyAdmin;
function emergencySetOwner(address newOwner) external {
require(msg.sender == emergencyAdmin, "!emergency-owner");
owner = newOwner;
}
constructor(address _emergencyAdmin) payoutAllCSettable(msg.sender) public {
emergencyAdmin = _emergencyAdmin;
assert(_emergencyAdmin != address(0));
}
function getVersion() external pure returns (uint) {
return VERSION;
}
function() payable public {
_getPayTo().transfer(msg.value);
}
function _modAccountBalance(bytes32 democHash, uint additionalSeconds) internal {
uint prevPaidTill = accounts[democHash].paidUpTill;
if (prevPaidTill < now) {
prevPaidTill = now;
}
accounts[democHash].paidUpTill = prevPaidTill + additionalSeconds;
accounts[democHash].lastPaymentTs = now;
}
function weiBuysHowManySeconds(uint amount) public view returns (uint) {
uint centsPaid = weiToCents(amount);
uint monthsOffsetPaid = ((10 ** 18) * centsPaid) / basicCentsPricePer30Days;
uint secondsOffsetPaid = monthsOffsetPaid * (30 days);
uint additionalSeconds = secondsOffsetPaid / (10 ** 18);
return additionalSeconds;
}
function weiToCents(uint w) public view returns (uint) {
return w / weiPerCent;
}
function centsToWei(uint c) public view returns (uint) {
return c * weiPerCent;
}
function payForDemocracy(bytes32 democHash) external payable {
require(msg.value > 0, "need to send some ether to make payment");
uint additionalSeconds = weiBuysHowManySeconds(msg.value);
if (accounts[democHash].isPremium) {
additionalSeconds /= premiumMultiplier;
}
if (additionalSeconds >= 1) {
_modAccountBalance(democHash, additionalSeconds);
}
payments.push(PaymentLog(false, democHash, additionalSeconds, msg.value));
emit AccountPayment(democHash, additionalSeconds);
_getPayTo().transfer(msg.value);
}
function doFreeExtension(bytes32 democHash) external {
require(freeExtension[democHash], "!free");
uint newPaidUpTill = now + 60 days;
accounts[democHash].paidUpTill = newPaidUpTill;
emit FreeExtension(democHash);
}
function downgradeToBasic(bytes32 democHash) only_editors() external {
require(accounts[democHash].isPremium, "!premium");
accounts[democHash].isPremium = false;
uint paidTill = accounts[democHash].paidUpTill;
uint timeRemaining = SafeMath.subToZero(paidTill, now);
if (timeRemaining > 0) {
require(accounts[democHash].lastUpgradeTs < (now - 24 hours), "downgrade-too-soon");
timeRemaining *= premiumMultiplier;
accounts[democHash].paidUpTill = now + timeRemaining;
}
emit DowngradeToBasic(democHash);
}
function upgradeToPremium(bytes32 democHash) only_editors() external {
require(denyPremium[democHash] == false, "upgrade-denied");
require(!accounts[democHash].isPremium, "!basic");
accounts[democHash].isPremium = true;
uint paidTill = accounts[democHash].paidUpTill;
uint timeRemaining = SafeMath.subToZero(paidTill, now);
if (timeRemaining > 0) {
timeRemaining /= premiumMultiplier;
accounts[democHash].paidUpTill = now + timeRemaining;
}
accounts[democHash].lastUpgradeTs = now;
emit UpgradedToPremium(democHash);
}
function accountInGoodStanding(bytes32 democHash) external view returns (bool) {
return accounts[democHash].paidUpTill >= now;
}
function getSecondsRemaining(bytes32 democHash) external view returns (uint) {
return SafeMath.subToZero(accounts[democHash].paidUpTill, now);
}
function getPremiumStatus(bytes32 democHash) external view returns (bool) {
return accounts[democHash].isPremium;
}
function getFreeExtension(bytes32 democHash) external view returns (bool) {
return freeExtension[democHash];
}
function getAccount(bytes32 democHash) external view returns (bool isPremium, uint lastPaymentTs, uint paidUpTill, bool hasFreeExtension) {
isPremium = accounts[democHash].isPremium;
lastPaymentTs = accounts[democHash].lastPaymentTs;
paidUpTill = accounts[democHash].paidUpTill;
hasFreeExtension = freeExtension[democHash];
}
function getDenyPremium(bytes32 democHash) external view returns (bool) {
return denyPremium[democHash];
}
function giveTimeToDemoc(bytes32 democHash, uint additionalSeconds, bytes32 ref) owner_or(minorEditsAddr) external {
_modAccountBalance(democHash, additionalSeconds);
payments.push(PaymentLog(true, democHash, additionalSeconds, 0));
emit GrantedAccountTime(democHash, additionalSeconds, ref);
}
function setPayTo(address newPayTo) only_owner() external {
_setPayTo(newPayTo);
emit SetPayTo(newPayTo);
}
function setMinorEditsAddr(address a) only_owner() external {
minorEditsAddr = a;
emit SetMinorEditsAddr(a);
}
function setBasicCentsPricePer30Days(uint amount) only_owner() external {
basicCentsPricePer30Days = amount;
emit SetBasicCentsPricePer30Days(amount);
}
function setBasicBallotsPer30Days(uint amount) only_owner() external {
basicBallotsPer30Days = amount;
emit SetBallotsPer30Days(amount);
}
function setPremiumMultiplier(uint8 m) only_owner() external {
premiumMultiplier = m;
emit SetPremiumMultiplier(m);
}
function setWeiPerCent(uint wpc) owner_or(minorEditsAddr) external {
weiPerCent = wpc;
emit SetExchangeRate(wpc);
}
function setFreeExtension(bytes32 democHash, bool hasFreeExt) owner_or(minorEditsAddr) external {
freeExtension[democHash] = hasFreeExt;
emit SetFreeExtension(democHash, hasFreeExt);
}
function setDenyPremium(bytes32 democHash, bool isPremiumDenied) owner_or(minorEditsAddr) external {
denyPremium[democHash] = isPremiumDenied;
emit SetDenyPremium(democHash, isPremiumDenied);
}
function setMinWeiForDInit(uint amount) owner_or(minorEditsAddr) external {
minWeiForDInit = amount;
emit SetMinWeiForDInit(amount);
}
function getBasicCentsPricePer30Days() external view returns (uint) {
return basicCentsPricePer30Days;
}
function getBasicExtraBallotFeeWei() external view returns (uint) {
return centsToWei(basicCentsPricePer30Days / basicBallotsPer30Days);
}
function getBasicBallotsPer30Days() external view returns (uint) {
return basicBallotsPer30Days;
}
function getPremiumMultiplier() external view returns (uint8) {
return premiumMultiplier;
}
function getPremiumCentsPricePer30Days() external view returns (uint) {
return _premiumPricePer30Days();
}
function _premiumPricePer30Days() internal view returns (uint) {
return uint(premiumMultiplier) * basicCentsPricePer30Days;
}
function getWeiPerCent() external view returns (uint) {
return weiPerCent;
}
function getUsdEthExchangeRate() external view returns (uint) {
return 1 ether / weiPerCent;
}
function getMinWeiForDInit() external view returns (uint) {
return minWeiForDInit;
}
function getPaymentLogN() external view returns (uint) {
return payments.length;
}
function getPaymentLog(uint n) external view returns (bool _external, bytes32 _democHash, uint _seconds, uint _ethValue) {
_external = payments[n]._external;
_democHash = payments[n]._democHash;
_seconds = payments[n]._seconds;
_ethValue = payments[n]._ethValue;
}
}
| 65,845 | 12,559 |
d75d33ee62310f7160342ef9d5c50c8da4c8f4166583fe6ccfdddd40f296bb0f
| 16,982 |
.sol
|
Solidity
| false |
439790498
|
redacted-cartel/contracts-v1
|
832e971b6c4f44d86bdb97d20eb38fe53356817a
|
contracts/StakingDistributor.sol
| 3,893 | 15,358 |
// 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 BTRFLY;
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 _BTRFLY, uint _epochLength, uint _nextEpochBlock) {
require(_treasury != address(0));
treasury = _treasury;
require(_BTRFLY != address(0));
BTRFLY = _BTRFLY;
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(BTRFLY).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
});
}
}
| 5,658 | 12,560 |
34e620f0e4a26f6a5f0dcd8b1bee03827ec0155ba95628c5d6f6e67f38d186f7
| 25,082 |
.sol
|
Solidity
| false |
409432581
|
PhoenixGlobal/new_PHB
|
371a5ecff243f6b2d9a52086209453f287c6a69c
|
new_PHB.sol
| 3,550 | 12,559 |
pragma solidity 0.6.8;
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);
}
interface PHBOld {
function burnFrom(address account, uint256 amount) external;
function balanceOf(address account) external view returns (uint256);
}
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;
}
}
interface ERC677Receiver {
function onTokenTransfer(address _sender, uint _value, bytes calldata _data) external;
}
contract BEP20PHB is Context, iBEP20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
uint256 private _inflationRate;
uint256 private _lastInflationTime;
uint8 public _decimals;
string public _symbol;
string public _name;
uint256 public _inflationInitialAmount;
address private _inflationAddress;
address private _oldPHBAddress;
address private _oldPHXAddress;
PHBOld private _oldPHB;
PHBOld private _oldPHX;
constructor(address oldPHB,address oldPHX,uint256 startTime,uint256 inflationInitialAmount) public {
_name = 'Phoenix Global';
_symbol = 'PHB';
_decimals = 18;
_totalSupply = 0;
_balances[msg.sender] = _totalSupply;
_lastInflationTime=startTime;
_inflationRate=261157876;
_oldPHB = PHBOld(oldPHB);
_oldPHBAddress = oldPHB;
_oldPHX = PHBOld(oldPHX);
_oldPHXAddress = oldPHX;
_inflationAddress=owner();
_inflationInitialAmount=inflationInitialAmount;
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) public 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 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 mint(uint256 amount) public onlyOwner returns (bool) {
_mint(_msgSender(), amount);
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");
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function convertPHB(uint256 amount) external{
require(amount > 0 , "BEP20: convert amount not more than zero");
uint256 balance = _oldPHB.balanceOf(_msgSender());
require(balance >= amount , "BEP20: convert amount more than balance");
uint256 balanceBefore = _balances[_msgSender()];
_oldPHB.burnFrom(_msgSender(), amount);
_mint(_msgSender(), amount.div(100));
uint256 balanceAfter = _balances[_msgSender()];
require(balanceAfter-balanceBefore <= amount.div(100) , "BEP20: after convert,the balance increase error");
}
function convertPHX(uint256 amount) external{
require(amount > 0 , "BEP20: convert amount not more than zero");
uint256 balance = _oldPHX.balanceOf(_msgSender());
require(balance >= amount , "BEP20: convert amount more than balance");
uint256 balanceBefore = _balances[_msgSender()];
_oldPHX.burnFrom(_msgSender(), amount);
_mint(_msgSender(), amount.div(100).mul(10000000000));
uint256 balanceAfter = _balances[_msgSender()];
require(balanceAfter-balanceBefore <= amount.div(100).mul(10000000000) , "BEP20: after convert,the balance increase error");
}
function inflation() external{
uint256 nowTime = now;
require(nowTime > _lastInflationTime , "BEP20: now time is before last inflation time");
uint256 time = nowTime.sub(_lastInflationTime);
uint256 n = time.div(86400).add(1);
uint256 day_inflation = 0;
uint256 n_day_inflation = 0;
uint256 _tmpInflationInitialAmount = _inflationInitialAmount;
for(uint i = 0; i < n; i++){
day_inflation = _tmpInflationInitialAmount.mul(_inflationRate).div(1000000000000);
n_day_inflation = n_day_inflation.add(day_inflation);
_tmpInflationInitialAmount = _tmpInflationInitialAmount.add(day_inflation);
}
_mint(_inflationAddress, n_day_inflation);
_lastInflationTime = _lastInflationTime.add(n * 86400);
_inflationInitialAmount=_tmpInflationInitialAmount;
}
function setInflationRate(uint256 rate) external onlyOwner{
require(rate > 0 , "BEP20: inflation rate not more than zero");
_inflationRate=rate;
}
function inflationRate() external view returns (uint256) {
return _inflationRate;
}
function setInflationAddress(address inflationAddress) external onlyOwner{
require(inflationAddress != address(0), "BEP20: new inflationAddress is the zero address");
_inflationAddress=inflationAddress;
}
function inflationAddress() external view returns (address) {
return _inflationAddress;
}
function lastInflationTime() external view returns (uint256) {
return _lastInflationTime;
}
function oldPHB() external view returns (address) {
return _oldPHBAddress;
}
function oldPHX() external view returns (address) {
return _oldPHXAddress;
}
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");
require(amount > 0, "BEP20: approve amount must be more than zero");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
event Transfer(address indexed from, address indexed to, uint value, bytes data);
function transferAndCall(address to, uint value, bytes calldata data)
external
returns (bool)
{
transfer(to, value);
emit Transfer(_msgSender(), to, value, data);
if (_isContract(to)) {
_contractFallback(to, value, data);
}
return true;
}
function _contractFallback(address to, uint value, bytes memory data)
internal
{
ERC677Receiver receiver = ERC677Receiver(to);
receiver.onTokenTransfer(_msgSender(), value, data);
}
function _isContract(address addr)
internal view returns (bool)
{
uint length;
assembly { length := extcodesize(addr) }
return length > 0;
}
}
| 238,988 | 12,561 |
3ef01a64f40b170fdc3643a6cc41762bd53c66010a0bad6a460b020a4d7ff66b
| 25,366 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/70/7084f96c5b4B762bc0C20b5871cDe30F132283e3_SierraTreasury.sol
| 5,563 | 22,353 |
// 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) {
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;
}
}
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 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 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 {
if (returndata.length > 0) {
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(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) {
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
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 IERC20 {
function decimals() external view returns (uint8);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function approve(address spender, uint256 amount) external returns (bool);
function totalSupply() external view returns (uint256);
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 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 _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 IERC20Mintable {
function mint(uint256 amount_) external;
function mint(address account_, uint256 ammount_) external;
}
interface IOHMERC20 {
function burnFrom(address account_, uint256 amount_) external;
}
interface IBondCalculator {
function valuation(address pair_, uint amount_) external view returns (uint _value);
}
contract SierraTreasury is Ownable {
using SafeMath for uint;
using SafeERC20 for IERC20;
event Deposit(address indexed token, uint amount, uint value);
event Withdrawal(address indexed token, uint amount, uint value);
event CreateDebt(address indexed debtor, address indexed token, uint amount, uint value);
event RepayDebt(address indexed debtor, address indexed token, uint amount, uint value);
event ReservesManaged(address indexed token, uint amount);
event ReservesUpdated(uint indexed totalReserves);
event ReservesAudited(uint indexed totalReserves);
event RewardsMinted(address indexed caller, address indexed recipient, uint amount);
event ChangeQueued(MANAGING indexed managing, address queued);
event ChangeActivated(MANAGING indexed managing, address activated, bool result);
enum MANAGING {RESERVEDEPOSITOR, RESERVESPENDER, RESERVETOKEN, RESERVEMANAGER, LIQUIDITYDEPOSITOR, LIQUIDITYTOKEN, LIQUIDITYMANAGER, DEBTOR, REWARDMANAGER, SOHM}
address public immutable OHM;
uint public immutable blocksNeededForQueue;
address[] public reserveTokens; // Push only, beware false-positives.
mapping(address => bool) public isReserveToken;
mapping(address => uint) public reserveTokenQueue; // Delays changes to mapping.
address[] public reserveDepositors; // Push only, beware false-positives. Only for viewing.
mapping(address => bool) public isReserveDepositor;
mapping(address => uint) public reserveDepositorQueue; // Delays changes to mapping.
address[] public reserveSpenders; // Push only, beware false-positives. Only for viewing.
mapping(address => bool) public isReserveSpender;
mapping(address => uint) public reserveSpenderQueue; // Delays changes to mapping.
address[] public liquidityTokens; // Push only, beware false-positives.
mapping(address => bool) public isLiquidityToken;
mapping(address => uint) public LiquidityTokenQueue; // Delays changes to mapping.
address[] public liquidityDepositors; // Push only, beware false-positives. Only for viewing.
mapping(address => bool) public isLiquidityDepositor;
mapping(address => uint) public LiquidityDepositorQueue; // Delays changes to mapping.
mapping(address => address) public bondCalculator; // bond calculator for liquidity token
address[] public reserveManagers; // Push only, beware false-positives. Only for viewing.
mapping(address => bool) public isReserveManager;
mapping(address => uint) public ReserveManagerQueue; // Delays changes to mapping.
address[] public liquidityManagers; // Push only, beware false-positives. Only for viewing.
mapping(address => bool) public isLiquidityManager;
mapping(address => uint) public LiquidityManagerQueue; // Delays changes to mapping.
address[] public debtors; // Push only, beware false-positives. Only for viewing.
mapping(address => bool) public isDebtor;
mapping(address => uint) public debtorQueue; // Delays changes to mapping.
mapping(address => uint) public debtorBalance;
address[] public rewardManagers; // Push only, beware false-positives. Only for viewing.
mapping(address => bool) public isRewardManager;
mapping(address => uint) public rewardManagerQueue; // Delays changes to mapping.
address public sOHM;
uint public sOHMQueue; // Delays change to sOHM address
uint public totalReserves; // Risk-free value of all assets
uint public totalDebt;
constructor (address _OHM,
address _MIM,
uint _blocksNeededForQueue) {
require(_OHM != address(0));
OHM = _OHM;
isReserveToken[_MIM] = true;
reserveTokens.push(_MIM);
// isLiquidityToken[_OHMDAI] = true;
// liquidityTokens.push(_OHMDAI);
blocksNeededForQueue = _blocksNeededForQueue;
}
function deposit(uint _amount, address _token, uint _profit) external returns (uint send_) {
require(isReserveToken[_token] || isLiquidityToken[_token], "Not accepted");
IERC20(_token).safeTransferFrom(msg.sender, address(this), _amount);
if (isReserveToken[_token]) {
require(isReserveDepositor[msg.sender], "Not approved");
} else {
require(isLiquidityDepositor[msg.sender], "Not approved");
}
uint value = valueOf(_token, _amount);
// mint OHM needed and store amount of rewards for distribution
send_ = value.sub(_profit);
IERC20Mintable(OHM).mint(msg.sender, send_);
totalReserves = totalReserves.add(value);
emit ReservesUpdated(totalReserves);
emit Deposit(_token, _amount, value);
}
function withdraw(uint _amount, address _token) external {
require(isReserveToken[_token], "Not accepted");
// Only reserves can be used for redemptions
require(isReserveSpender[msg.sender] == true, "Not approved");
uint value = valueOf(_token, _amount);
IOHMERC20(OHM).burnFrom(msg.sender, value);
totalReserves = totalReserves.sub(value);
emit ReservesUpdated(totalReserves);
IERC20(_token).safeTransfer(msg.sender, _amount);
emit Withdrawal(_token, _amount, value);
}
function incurDebt(uint _amount, address _token) external {
require(isDebtor[msg.sender], "Not approved");
require(isReserveToken[_token], "Not accepted");
uint value = valueOf(_token, _amount);
uint maximumDebt = IERC20(sOHM).balanceOf(msg.sender);
// Can only borrow against sOHM held
uint availableDebt = maximumDebt.sub(debtorBalance[msg.sender]);
require(value <= availableDebt, "Exceeds debt limit");
debtorBalance[msg.sender] = debtorBalance[msg.sender].add(value);
totalDebt = totalDebt.add(value);
totalReserves = totalReserves.sub(value);
emit ReservesUpdated(totalReserves);
IERC20(_token).transfer(msg.sender, _amount);
emit CreateDebt(msg.sender, _token, _amount, value);
}
function repayDebtWithReserve(uint _amount, address _token) external {
require(isDebtor[msg.sender], "Not approved");
require(isReserveToken[_token], "Not accepted");
IERC20(_token).safeTransferFrom(msg.sender, address(this), _amount);
uint value = valueOf(_token, _amount);
debtorBalance[msg.sender] = debtorBalance[msg.sender].sub(value);
totalDebt = totalDebt.sub(value);
totalReserves = totalReserves.add(value);
emit ReservesUpdated(totalReserves);
emit RepayDebt(msg.sender, _token, _amount, value);
}
function repayDebtWithOHM(uint _amount) external {
require(isDebtor[msg.sender], "Not approved");
IOHMERC20(OHM).burnFrom(msg.sender, _amount);
debtorBalance[msg.sender] = debtorBalance[msg.sender].sub(_amount);
totalDebt = totalDebt.sub(_amount);
emit RepayDebt(msg.sender, OHM, _amount, _amount);
}
function manage(address _token, uint _amount) external {
if (isLiquidityToken[_token]) {
require(isLiquidityManager[msg.sender], "Not approved");
} else {
require(isReserveManager[msg.sender], "Not approved");
}
uint value = valueOf(_token, _amount);
require(value <= excessReserves(), "Insufficient reserves");
totalReserves = totalReserves.sub(value);
emit ReservesUpdated(totalReserves);
IERC20(_token).safeTransfer(msg.sender, _amount);
emit ReservesManaged(_token, _amount);
}
function mintRewards(address _recipient, uint _amount) external {
require(isRewardManager[msg.sender], "Not approved");
require(_amount <= excessReserves(), "Insufficient reserves");
IERC20Mintable(OHM).mint(_recipient, _amount);
emit RewardsMinted(msg.sender, _recipient, _amount);
}
function excessReserves() public view returns (uint) {
return totalReserves.sub(IERC20(OHM).totalSupply().sub(totalDebt));
}
function auditReserves() external onlyManager() {
uint reserves;
for (uint i = 0; i < reserveTokens.length; i++) {
reserves = reserves.add(valueOf(reserveTokens[i], IERC20(reserveTokens[i]).balanceOf(address(this))));
}
for (uint i = 0; i < liquidityTokens.length; i++) {
reserves = reserves.add(valueOf(liquidityTokens[i], IERC20(liquidityTokens[i]).balanceOf(address(this))));
}
totalReserves = reserves;
emit ReservesUpdated(reserves);
emit ReservesAudited(reserves);
}
function valueOf(address _token, uint _amount) public view returns (uint value_) {
if (isReserveToken[_token]) {
// convert amount to match OHM decimals
value_ = _amount.mul(10 ** IERC20(OHM).decimals()).div(10 ** IERC20(_token).decimals());
} else if (isLiquidityToken[_token]) {
value_ = IBondCalculator(bondCalculator[_token]).valuation(_token, _amount);
}
}
function queue(MANAGING _managing, address _address) external onlyManager() returns (bool) {
require(_address != address(0));
if (_managing == MANAGING.RESERVEDEPOSITOR) {// 0
reserveDepositorQueue[_address] = block.number.add(blocksNeededForQueue);
} else if (_managing == MANAGING.RESERVESPENDER) {// 1
reserveSpenderQueue[_address] = block.number.add(blocksNeededForQueue);
} else if (_managing == MANAGING.RESERVETOKEN) {// 2
reserveTokenQueue[_address] = block.number.add(blocksNeededForQueue);
} else if (_managing == MANAGING.RESERVEMANAGER) {// 3
ReserveManagerQueue[_address] = block.number.add(blocksNeededForQueue.mul(2));
} else if (_managing == MANAGING.LIQUIDITYDEPOSITOR) {// 4
LiquidityDepositorQueue[_address] = block.number.add(blocksNeededForQueue);
} else if (_managing == MANAGING.LIQUIDITYTOKEN) {// 5
LiquidityTokenQueue[_address] = block.number.add(blocksNeededForQueue);
} else if (_managing == MANAGING.LIQUIDITYMANAGER) {// 6
LiquidityManagerQueue[_address] = block.number.add(blocksNeededForQueue.mul(2));
} else if (_managing == MANAGING.DEBTOR) {// 7
debtorQueue[_address] = block.number.add(blocksNeededForQueue);
} else if (_managing == MANAGING.REWARDMANAGER) {// 8
rewardManagerQueue[_address] = block.number.add(blocksNeededForQueue);
} else if (_managing == MANAGING.SOHM) {// 9
sOHMQueue = block.number.add(blocksNeededForQueue);
} else return false;
emit ChangeQueued(_managing, _address);
return true;
}
function toggle(MANAGING _managing, address _address, address _calculator) external onlyManager() returns (bool) {
require(_address != address(0));
bool result;
if (_managing == MANAGING.RESERVEDEPOSITOR) {// 0
if (requirements(reserveDepositorQueue, isReserveDepositor, _address)) {
reserveDepositorQueue[_address] = 0;
if (!listContains(reserveDepositors, _address)) {
reserveDepositors.push(_address);
}
}
result = !isReserveDepositor[_address];
isReserveDepositor[_address] = result;
} else if (_managing == MANAGING.RESERVESPENDER) {// 1
if (requirements(reserveSpenderQueue, isReserveSpender, _address)) {
reserveSpenderQueue[_address] = 0;
if (!listContains(reserveSpenders, _address)) {
reserveSpenders.push(_address);
}
}
result = !isReserveSpender[_address];
isReserveSpender[_address] = result;
} else if (_managing == MANAGING.RESERVETOKEN) {// 2
if (requirements(reserveTokenQueue, isReserveToken, _address)) {
reserveTokenQueue[_address] = 0;
if (!listContains(reserveTokens, _address)) {
reserveTokens.push(_address);
}
}
result = !isReserveToken[_address];
isReserveToken[_address] = result;
} else if (_managing == MANAGING.RESERVEMANAGER) {// 3
if (requirements(ReserveManagerQueue, isReserveManager, _address)) {
reserveManagers.push(_address);
ReserveManagerQueue[_address] = 0;
if (!listContains(reserveManagers, _address)) {
reserveManagers.push(_address);
}
}
result = !isReserveManager[_address];
isReserveManager[_address] = result;
} else if (_managing == MANAGING.LIQUIDITYDEPOSITOR) {// 4
if (requirements(LiquidityDepositorQueue, isLiquidityDepositor, _address)) {
liquidityDepositors.push(_address);
LiquidityDepositorQueue[_address] = 0;
if (!listContains(liquidityDepositors, _address)) {
liquidityDepositors.push(_address);
}
}
result = !isLiquidityDepositor[_address];
isLiquidityDepositor[_address] = result;
} else if (_managing == MANAGING.LIQUIDITYTOKEN) {// 5
if (requirements(LiquidityTokenQueue, isLiquidityToken, _address)) {
LiquidityTokenQueue[_address] = 0;
if (!listContains(liquidityTokens, _address)) {
liquidityTokens.push(_address);
}
}
result = !isLiquidityToken[_address];
isLiquidityToken[_address] = result;
bondCalculator[_address] = _calculator;
} else if (_managing == MANAGING.LIQUIDITYMANAGER) {// 6
if (requirements(LiquidityManagerQueue, isLiquidityManager, _address)) {
LiquidityManagerQueue[_address] = 0;
if (!listContains(liquidityManagers, _address)) {
liquidityManagers.push(_address);
}
}
result = !isLiquidityManager[_address];
isLiquidityManager[_address] = result;
} else if (_managing == MANAGING.DEBTOR) {// 7
if (requirements(debtorQueue, isDebtor, _address)) {
debtorQueue[_address] = 0;
if (!listContains(debtors, _address)) {
debtors.push(_address);
}
}
result = !isDebtor[_address];
isDebtor[_address] = result;
} else if (_managing == MANAGING.REWARDMANAGER) {// 8
if (requirements(rewardManagerQueue, isRewardManager, _address)) {
rewardManagerQueue[_address] = 0;
if (!listContains(rewardManagers, _address)) {
rewardManagers.push(_address);
}
}
result = !isRewardManager[_address];
isRewardManager[_address] = result;
} else if (_managing == MANAGING.SOHM) {// 9
sOHMQueue = 0;
sOHM = _address;
result = true;
} else return false;
emit ChangeActivated(_managing, _address, result);
return true;
}
function requirements(mapping(address => uint) storage queue_,
mapping(address => bool) storage status_,
address _address) internal view returns (bool) {
if (!status_[_address]) {
require(queue_[_address] != 0, "Must queue");
require(queue_[_address] <= block.number, "Queue not expired");
return true;
}
return false;
}
function listContains(address[] storage _list, address _token) internal view returns (bool) {
for (uint i = 0; i < _list.length; i++) {
if (_list[i] == _token) {
return true;
}
}
return false;
}
}
| 89,766 | 12,562 |
f9265793d5cb7b772ba2cc686af0ae9f7172f5cbd9293a8ad3a86d8d7aea939e
| 29,253 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TY/TYPuHaX72brDyJnke8abxan9o9fvHSBbHG_UniTron.sol
| 7,317 | 28,073 |
//SourceUnit: UniTron.sol
pragma solidity >=0.4.22 <0.7.0;
contract UniTron {
address payable public owner;
struct UserDetail {
uint256 id;
uint256 userIncome;
uint256 poolIncome;
address payable referrer;
mapping (uint8 => bool) poolActiveStatus;
mapping (uint8 => level) levelMatrix;
mapping (uint8 => userGlobalPool) poolMatrix;
}
struct level {
mapping (uint8 => uint256) levelReferrals;
}
struct SpillDetails {
address _from;
address referrer;
address receiver;
uint256 income;
uint8 pool;
uint8 level;
uint256 levelReferrals;
uint256 receiverLevelReferrals;
}
struct userGlobalPool {
uint256 globalPoolPosition;
address payable poolReferrer;
uint256 reinvestCount;
// uint256 lastLevelReferralCount;
bool isBlocked;
mapping (uint8 => uint256) levelReferralCount;
}
struct GlobalPool {
uint256 currentPosition;
uint256 currentFreePosition;
mapping (uint256 => address payable) poolIds;
// mapping (address => uint256) addressToPoolIds;
mapping (uint256 => uint8) globalReferralCount;
}
uint256 public currentUserId = 1;
uint8 public LAST_POOL = 15;
uint256 public totalIncome;
address payable referrerLevelOne;
address payable referrerLevelTwo;
address payable referrerLevelThree;
address payable referrerLevelFour;
address payable referrerLevelFive;
address payable poolReferrerOne;
address payable poolReferrerTwo;
address payable poolReferrerThree;
address payable poolReferrerFour;
address payable poolReferrerFive;
address payable freeReferrerOne;
address payable freeReferrerTwo;
address payable freeReferrerThree;
address payable freeReferrerFour;
address payable freeReferrerFive;
mapping (address => UserDetail) users;
mapping (uint256 => address) public userIds;
mapping (uint8 => uint256) poolJoiningFees;
mapping (uint8 => uint256) autoPoolIncome;
mapping (uint8 => GlobalPool) globalPoolMatrix;
event Registration(address user, address referrer, uint256 userId, uint256 referrerId);
event PoolPurchased(address user, uint256 userId, uint8 pool);
event LevelIncome(address _from, address receiver, uint256 income, uint8 pool, uint8 level, uint256 levelReferralCount);
event PoolLevelUpdate(address _from, address receiver, uint8 pool, uint8 level, uint256 income, uint256 levelReferralCount);
event GlobalPoolUpdated(address userAddress,uint8 pool, uint256 currentPosition, uint256 myPosition);
event Reinvest(address userAddress, uint8 pool, uint256 reinvestCount, bool status);
event NewUserPlaced(address userPlaced, address referrerAddress, uint256 userPlacedId, uint8 pool, uint256 referralCount);
event SpilledLevelIncome(address _from, address referrer, address receiver, uint256 income, uint8 pool, uint8 level, uint256 levelReferralCount);
constructor(address payable ownerAddress) public {
owner = ownerAddress;
poolJoiningFees[1] = 225 * 1e6;
autoPoolIncome[1] = 25 * 1e6;
for (uint8 i=2; i<=LAST_POOL; i++) {
poolJoiningFees[i] = (poolJoiningFees[i-1] * 2);
autoPoolIncome[i] = (autoPoolIncome[i-1] * 2);
}
UserDetail memory user = UserDetail({
id: currentUserId,
userIncome: uint256(0),
poolIncome: uint256(0),
referrer: address(0)
});
users[owner] = user;
userIds[currentUserId] = owner;
currentUserId++;
UserDetail storage User = users[owner];
emit Registration(owner, User.referrer, User.id, uint256(0));
for (uint8 i=1; i<=LAST_POOL; i++) {
GlobalPool storage globalPool = globalPoolMatrix[i];
globalPool.currentPosition++;
globalPool.poolIds[globalPool.currentPosition] = owner;
User.poolMatrix[i].poolReferrer = address(0);
User.poolMatrix[i].globalPoolPosition = globalPool.currentPosition;
User.poolActiveStatus[i] = true;
globalPool.currentFreePosition = globalPool.currentPosition;
emit PoolPurchased(owner, User.id, i);
emit GlobalPoolUpdated(owner, i, globalPool.currentFreePosition, globalPool.currentPosition);
}
}
function registration(address payable referrerAddress) external payable {
require(!isUserExists(msg.sender), "user already exists");
require(isUserExists(referrerAddress), "user already exists");
require(msg.value == (poolJoiningFees[1] + autoPoolIncome[1]), "Invalid registration amount");
UserDetail memory user = UserDetail({
id: currentUserId,
userIncome: uint256(0),
poolIncome: uint256(0),
referrer: referrerAddress
});
users[msg.sender] = user;
userIds[currentUserId] = msg.sender;
currentUserId++;
emit Registration(msg.sender, referrerAddress, users[msg.sender].id, users[referrerAddress].id);
emit PoolPurchased(msg.sender, users[msg.sender].id, 1);
levelIncome(msg.sender, referrerAddress, 1);
emit NewUserPlaced(msg.sender, referrerAddress, users[msg.sender].id, 1, users[referrerAddress].levelMatrix[1].levelReferrals[1]);
if (users[referrerAddress].levelMatrix[1].levelReferrals[1] == 2) {
users[referrerAddress].poolActiveStatus[1] = true;
}
updateGlobalPool(msg.sender, 1);
poolIncome(msg.sender, users[msg.sender].poolMatrix[1].poolReferrer, 1);
owner.transfer(address(this).balance);
totalIncome += msg.value;
}
function purchasePool(uint8 pool) external payable {
UserDetail storage user = users[msg.sender];
require(user.poolActiveStatus[1], "require atleast 2 directs to unlock all the slots");
require(isUserExists(msg.sender), "User not registered yet");
require(pool >= 1 && pool <= LAST_POOL, "Invalid pool number");
require(msg.value == (poolJoiningFees[pool] + autoPoolIncome[pool]));
if (user.poolMatrix[pool].reinvestCount > 0) {
require(user.poolMatrix[pool].isBlocked, "Pool not filled yet");
user.poolMatrix[pool].isBlocked = false;
emit Reinvest(msg.sender, pool, user.poolMatrix[pool].reinvestCount, false);
}
emit PoolPurchased(msg.sender, user.id, pool);
user.poolActiveStatus[pool] = true;
levelIncome(msg.sender, user.referrer, pool);
emit NewUserPlaced(msg.sender, user.referrer, user.id, pool, users[user.referrer].levelMatrix[pool].levelReferrals[1]);
updateGlobalPool(msg.sender, pool);
poolIncome(msg.sender, user.poolMatrix[pool].poolReferrer, pool);
owner.transfer(address(this).balance);
totalIncome += msg.value;
}
function levelIncome(address payable userAddress, address payable referrerAddress, uint8 pool) private {
uint256 income = poolJoiningFees[pool];
uint256 incomeLevelOne = income * 50/100;
uint256 incomeLevelTwo = income * 20/100;
uint256 incomeLevelThree = income * 5/100;
uint256 incomeLevelFour = income * 10/100;
uint256 incomeLevelFive = income * 15/100;
referrerLevelOne = referrerAddress;
referrerLevelTwo = users[referrerLevelOne].referrer;
referrerLevelThree = users[referrerLevelTwo].referrer;
referrerLevelFour = users[referrerLevelThree].referrer;
referrerLevelFive = users[referrerLevelFour].referrer;
freeReferrerOne = getFreeReferrer(userAddress, pool);
freeReferrerTwo = getFreeReferrer(freeReferrerOne, pool);
freeReferrerThree = getFreeReferrer(freeReferrerTwo, pool);
freeReferrerFour = getFreeReferrer(freeReferrerThree, pool);
freeReferrerFive = getFreeReferrer(freeReferrerFour, pool);
if (referrerLevelOne != address(0)) {
UserDetail storage user = users[referrerLevelOne];
if (referrerLevelOne == owner) {
user.userIncome += income;
referrerLevelOne.transfer(income * 99/100);
owner.transfer(income * 1/100);
user.levelMatrix[pool].levelReferrals[1]++;
emit LevelIncome(userAddress, referrerLevelOne, income, pool, 1, user.levelMatrix[pool].levelReferrals[1]);
} else if (pool == 1 || freeReferrerOne == referrerLevelOne) {
user.userIncome += incomeLevelOne * 99/100;
referrerLevelOne.transfer(incomeLevelOne * 99/100);
owner.transfer(incomeLevelOne * 1/100);
users[owner].userIncome += incomeLevelOne * 1/100;
user.levelMatrix[pool].levelReferrals[1]++;
emit LevelIncome(userAddress, referrerLevelOne, incomeLevelOne * 99/100, pool, 1, user.levelMatrix[pool].levelReferrals[1]);
} else {
UserDetail storage User = users[freeReferrerOne];
User.userIncome += incomeLevelOne * 99/100;
freeReferrerOne.transfer(incomeLevelOne * 99/100);
owner.transfer(incomeLevelOne * 1/100);
users[owner].userIncome += incomeLevelOne * 1/100;
user.levelMatrix[pool].levelReferrals[1]++;
SpillDetails memory spill = SpillDetails({
_from: userAddress,
referrer: referrerLevelOne,
receiver: freeReferrerOne,
income: incomeLevelOne * 99/100,
pool: pool,
level: 1,
levelReferrals: user.levelMatrix[pool].levelReferrals[1],
receiverLevelReferrals: User.levelMatrix[pool].levelReferrals[1]
});
emit LevelIncome(spill._from, spill.receiver, spill.income, spill.pool, spill.level, spill.receiverLevelReferrals);
emit SpilledLevelIncome(spill._from, spill.referrer, spill.receiver, spill.income, spill.pool, 1, spill.levelReferrals);
}
}
if (referrerLevelTwo != address(0)) {
UserDetail storage user = users[referrerLevelTwo];
if (pool == 1 || freeReferrerTwo == referrerLevelTwo) {
user.userIncome += incomeLevelTwo * 99/100;
referrerLevelTwo.transfer(incomeLevelTwo * 99/100);
users[owner].userIncome += incomeLevelTwo * 1/100;
owner.transfer(incomeLevelTwo * 1/100);
user.levelMatrix[pool].levelReferrals[2]++;
emit LevelIncome(userAddress, referrerLevelTwo, incomeLevelTwo * 99/100, pool, 2, user.levelMatrix[pool].levelReferrals[2]);
} else {
UserDetail storage User = users[freeReferrerTwo];
User.userIncome += incomeLevelTwo * 99/100;
freeReferrerTwo.transfer(incomeLevelTwo * 99/100);
owner.transfer(incomeLevelTwo * 1/100);
users[owner].userIncome += incomeLevelTwo * 1/100;
user.levelMatrix[pool].levelReferrals[2]++;
SpillDetails memory spill = SpillDetails({
_from: userAddress,
referrer: referrerLevelTwo,
receiver: freeReferrerTwo,
income: incomeLevelTwo * 99/100,
pool: pool,
level: 2,
levelReferrals: user.levelMatrix[pool].levelReferrals[2],
receiverLevelReferrals: User.levelMatrix[pool].levelReferrals[2]
});
emit LevelIncome(spill._from, spill.receiver, spill.income, spill.pool, spill.level, spill.receiverLevelReferrals);
emit SpilledLevelIncome(spill._from, spill.referrer, spill.receiver, spill.income, spill.pool, spill.level, spill.levelReferrals);
}
}
if (referrerLevelThree != address(0)) {
UserDetail storage user = users[referrerLevelThree];
if (pool == 1 || freeReferrerThree == referrerLevelThree) {
user.userIncome += incomeLevelThree * 99/100;
referrerLevelThree.transfer(incomeLevelThree * 99/100);
users[owner].userIncome += incomeLevelThree * 1/100;
owner.transfer(incomeLevelThree * 1/100);
user.levelMatrix[pool].levelReferrals[3]++;
emit LevelIncome(userAddress, referrerLevelThree, incomeLevelThree * 99/100, pool, 3, user.levelMatrix[pool].levelReferrals[3]);
} else {
UserDetail storage User = users[freeReferrerThree];
User.userIncome += incomeLevelThree * 99/100;
freeReferrerThree.transfer(incomeLevelThree * 99/100);
owner.transfer(incomeLevelThree * 1/100);
users[owner].userIncome += incomeLevelThree * 1/100;
user.levelMatrix[pool].levelReferrals[3]++;
SpillDetails memory spill = SpillDetails({
_from: userAddress,
referrer: referrerLevelThree,
receiver: freeReferrerThree,
income: incomeLevelThree * 99/100,
pool: pool,
level: 3,
levelReferrals: user.levelMatrix[pool].levelReferrals[3],
receiverLevelReferrals: User.levelMatrix[pool].levelReferrals[3]
});
emit LevelIncome(spill._from, spill.receiver, spill.income, spill.pool, spill.level, spill.receiverLevelReferrals);
emit SpilledLevelIncome(spill._from, spill.referrer, spill.receiver, spill.income, spill.pool, spill.level, spill.levelReferrals);
}
}
if (referrerLevelFour != address(0)) {
UserDetail storage user = users[referrerLevelFour];
if (pool == 1 || freeReferrerFour == referrerLevelFour) {
user.userIncome += incomeLevelFour * 99/100;
referrerLevelFour.transfer(incomeLevelFour * 99/100);
users[owner].userIncome += incomeLevelFour * 1/100;
owner.transfer(incomeLevelFour * 1/100);
user.levelMatrix[pool].levelReferrals[4]++;
emit LevelIncome(userAddress, referrerLevelFour, incomeLevelFour * 99/100, pool, 4, user.levelMatrix[pool].levelReferrals[4]);
} else {
UserDetail storage User = users[freeReferrerFour];
User.userIncome += incomeLevelFour * 99/100;
freeReferrerFour.transfer(incomeLevelFour * 99/100);
owner.transfer(incomeLevelFour * 1/100);
users[owner].userIncome += incomeLevelFour * 1/100;
user.levelMatrix[pool].levelReferrals[4]++;
SpillDetails memory spill = SpillDetails({
_from: userAddress,
referrer: referrerLevelFour,
receiver: freeReferrerFour,
income: incomeLevelFour * 99/100,
pool: pool,
level: 4,
levelReferrals: user.levelMatrix[pool].levelReferrals[4],
receiverLevelReferrals: User.levelMatrix[pool].levelReferrals[4]
});
emit LevelIncome(spill._from, spill.receiver, spill.income, spill.pool, spill.level, spill.receiverLevelReferrals);
emit SpilledLevelIncome(spill._from, spill.referrer, spill.receiver, spill.income, spill.pool, spill.level, spill.levelReferrals);
}
}
if (referrerLevelFive != address(0)) {
UserDetail storage user = users[referrerLevelFive];
if (pool == 1 || freeReferrerFive == referrerLevelFive) {
user.userIncome += incomeLevelFive * 99/100;
referrerLevelFive.transfer(incomeLevelFive * 99/100);
users[owner].userIncome += incomeLevelFive * 1/100;
owner.transfer(incomeLevelFive * 1/100);
user.levelMatrix[pool].levelReferrals[5]++;
emit LevelIncome(userAddress, referrerLevelFive, incomeLevelFive * 99/100, pool, 5, user.levelMatrix[pool].levelReferrals[5]);
} else {
UserDetail storage User = users[freeReferrerFive];
User.userIncome += incomeLevelFive * 99/100;
freeReferrerFive.transfer(incomeLevelFive * 99/100);
owner.transfer(incomeLevelFive * 1/100);
users[owner].userIncome += incomeLevelFive * 1/100;
user.levelMatrix[pool].levelReferrals[5]++;
SpillDetails memory spill = SpillDetails({
_from: userAddress,
referrer: referrerLevelFive,
receiver: freeReferrerFive,
income: incomeLevelFive * 99/100,
pool: pool,
level: 5,
levelReferrals: user.levelMatrix[pool].levelReferrals[5],
receiverLevelReferrals: User.levelMatrix[pool].levelReferrals[5]
});
emit LevelIncome(spill._from, spill.receiver, spill.income, spill.pool, spill.level, spill.receiverLevelReferrals);
emit SpilledLevelIncome(spill._from, spill.referrer, spill.receiver, spill.income, spill.pool, spill.level, spill.levelReferrals);
}
}
}
function poolIncome(address userAddress, address payable referrerAddress, uint8 pool) private {
// GlobalPool storage globalPool = globalPoolMatrix[pool];
uint256 income = autoPoolIncome[pool];
uint256 incomeLevelOne = income * 50/100;
uint256 incomeLevelTwo = income * 20/100;
uint256 incomeLevelThree = income * 5/100;
uint256 incomeLevelFour = income * 10/100;
uint256 incomeLevelFive = income * 15/100;
poolReferrerOne = referrerAddress;
poolReferrerTwo = users[poolReferrerOne].poolMatrix[pool].poolReferrer;
poolReferrerThree = users[poolReferrerTwo].poolMatrix[pool].poolReferrer;
poolReferrerFour = users[poolReferrerThree].poolMatrix[pool].poolReferrer;
poolReferrerFive = users[poolReferrerFour].poolMatrix[pool].poolReferrer;
if (poolReferrerOne != address(0)) {
UserDetail storage user = users[poolReferrerOne];
//check owner condtion, if referrer is owner transfer all the amount
if (poolReferrerOne == owner) {
user.poolIncome += income;
poolReferrerOne.transfer(income * 99/100);
owner.transfer(income * 1/100);
user.poolMatrix[pool].levelReferralCount[1]++;
emit PoolLevelUpdate(userAddress, poolReferrerOne, pool, 1, income, user.poolMatrix[pool].levelReferralCount[1]);
} else if (user.poolMatrix[pool].levelReferralCount[1] < 2 && !users[poolReferrerOne].poolActiveStatus[pool]) {
user.poolIncome += incomeLevelOne * 99/100;
poolReferrerOne.transfer(incomeLevelOne * 99/100);
users[owner].poolIncome += incomeLevelOne * 1/100;
owner.transfer(incomeLevelOne * 1/100);
user.poolMatrix[pool].levelReferralCount[1]++;
emit PoolLevelUpdate(userAddress, poolReferrerOne, pool, 1, incomeLevelOne * 99/100, user.poolMatrix[pool].levelReferralCount[1]);
} else if (users[poolReferrerOne].poolActiveStatus[pool]) {
user.poolIncome += incomeLevelOne * 99/100;
poolReferrerOne.transfer(incomeLevelOne * 99/100);
users[owner].poolIncome += incomeLevelOne * 1/100;
owner.transfer(incomeLevelOne * 1/100);
user.poolMatrix[pool].levelReferralCount[1]++;
emit PoolLevelUpdate(userAddress, poolReferrerOne, pool, 1, incomeLevelOne * 99/100, user.poolMatrix[pool].levelReferralCount[1]);
} else {
owner.transfer(incomeLevelOne);
user.poolMatrix[pool].levelReferralCount[1]++;
emit PoolLevelUpdate(userAddress, poolReferrerOne, pool, 1, 0, user.poolMatrix[pool].levelReferralCount[1]);
}
}
if (poolReferrerTwo != address(0)) {
UserDetail storage user = users[poolReferrerTwo];
if (users[poolReferrerTwo].poolActiveStatus[pool]) {
user.poolIncome += incomeLevelTwo * 99/100;
poolReferrerTwo.transfer(incomeLevelTwo * 99/100);
users[owner].poolIncome += incomeLevelTwo * 1/100;
owner.transfer(incomeLevelTwo * 1/100);
user.poolMatrix[pool].levelReferralCount[2]++;
emit PoolLevelUpdate(userAddress, poolReferrerTwo, pool, 2, incomeLevelTwo, user.poolMatrix[pool].levelReferralCount[2]);
} else {
owner.transfer(incomeLevelTwo);
user.poolMatrix[pool].levelReferralCount[2]++;
emit PoolLevelUpdate(userAddress, poolReferrerTwo, pool, 2, 0, user.poolMatrix[pool].levelReferralCount[2]);
}
}
if (poolReferrerThree != address(0)) {
UserDetail storage user = users[poolReferrerThree];
if (users[poolReferrerThree].poolActiveStatus[pool]) {
user.poolIncome += incomeLevelThree * 99/100;
poolReferrerThree.transfer(incomeLevelThree * 99/100);
users[owner].poolIncome += incomeLevelThree * 1/100;
owner.transfer(incomeLevelThree * 1/100);
user.poolMatrix[pool].levelReferralCount[3]++;
emit PoolLevelUpdate(userAddress, poolReferrerThree, pool, 3, incomeLevelThree, user.poolMatrix[pool].levelReferralCount[3]);
} else {
owner.transfer(incomeLevelThree);
user.poolMatrix[pool].levelReferralCount[3]++;
emit PoolLevelUpdate(userAddress, poolReferrerThree, pool, 3, 0, user.poolMatrix[pool].levelReferralCount[3]);
}
}
if (poolReferrerFour != address(0)) {
UserDetail storage user = users[poolReferrerFour];
if (users[poolReferrerFour].poolActiveStatus[pool]) {
user.poolIncome += incomeLevelFour * 99/100;
poolReferrerFour.transfer(incomeLevelFour * 99/100);
users[owner].poolIncome += incomeLevelFour * 1/100;
owner.transfer(incomeLevelFour * 1/100);
user.poolMatrix[pool].levelReferralCount[4]++;
emit PoolLevelUpdate(userAddress, poolReferrerFour, pool, 4, incomeLevelFour, user.poolMatrix[pool].levelReferralCount[4]);
} else {
owner.transfer(incomeLevelFour);
user.poolMatrix[pool].levelReferralCount[4]++;
emit PoolLevelUpdate(userAddress, poolReferrerFour, pool, 4, 0, user.poolMatrix[pool].levelReferralCount[4]);
}
}
if (poolReferrerFive != address(0)) {
UserDetail storage user = users[poolReferrerFive];
if (users[poolReferrerFive].poolActiveStatus[pool]) {
user.poolIncome += incomeLevelFive * 99/100;
poolReferrerFive.transfer(incomeLevelFive * 99/100);
users[owner].poolIncome += incomeLevelFive * 1/100;
owner.transfer(incomeLevelFive * 1/100);
user.poolMatrix[pool].levelReferralCount[5]++;
emit PoolLevelUpdate(userAddress, poolReferrerFive, pool, 5, incomeLevelFive * 99/100, user.poolMatrix[pool].levelReferralCount[5]);
} else {
owner.transfer(incomeLevelFive);
user.poolMatrix[pool].levelReferralCount[5]++;
emit PoolLevelUpdate(userAddress, poolReferrerFive, pool, 5, 0, user.poolMatrix[pool].levelReferralCount[5]);
}
if (user.poolMatrix[pool].levelReferralCount[5] == 243 && poolReferrerFive != owner) {
user.poolMatrix[pool].levelReferralCount[1] = 0;
user.poolMatrix[pool].levelReferralCount[2] = 0;
user.poolMatrix[pool].levelReferralCount[3] = 0;
user.poolMatrix[pool].levelReferralCount[4] = 0;
user.poolMatrix[pool].levelReferralCount[5] = 0;
user.poolMatrix[pool].reinvestCount++;
user.poolMatrix[pool].isBlocked = true;
emit Reinvest(poolReferrerFive, pool, user.poolMatrix[pool].reinvestCount, true);
} else if (user.poolMatrix[pool].levelReferralCount[5] == 243 && poolReferrerFive == owner) {
user.poolMatrix[pool].levelReferralCount[1] = 0;
user.poolMatrix[pool].levelReferralCount[2] = 0;
user.poolMatrix[pool].levelReferralCount[3] = 0;
user.poolMatrix[pool].levelReferralCount[4] = 0;
user.poolMatrix[pool].levelReferralCount[5] = 0;
user.poolMatrix[pool].reinvestCount++;
user.poolMatrix[pool].isBlocked = true;
emit Reinvest(owner, pool, user.poolMatrix[pool].reinvestCount, false);
updateGlobalPool(owner, pool);
}
}
}
function updateGlobalPool(address payable userAddress, uint8 pool) private {
UserDetail storage user = users[userAddress];
GlobalPool storage globalPool = globalPoolMatrix[pool];
globalPool.currentPosition++;
globalPool.poolIds[globalPool.currentPosition] = userAddress;
user.poolMatrix[pool].globalPoolPosition = globalPool.currentPosition;
if (globalPool.globalReferralCount[globalPool.currentFreePosition] < 3) {
user.poolMatrix[pool].poolReferrer = globalPool.poolIds[globalPool.currentFreePosition];
globalPool.globalReferralCount[globalPool.currentFreePosition]++;
} else {
globalPool.currentFreePosition++;
user.poolMatrix[pool].poolReferrer = globalPool.poolIds[globalPool.currentFreePosition];
globalPool.globalReferralCount[globalPool.currentFreePosition]++;
}
emit GlobalPoolUpdated(userAddress, pool, globalPool.currentFreePosition, globalPool.currentPosition);
}
function getFreeReferrer(address payable userAddress, uint8 pool) private view returns(address payable) {
while (userAddress != address(0)) {
if (users[users[userAddress].referrer].poolActiveStatus[pool]) {
return users[userAddress].referrer;
}
userAddress = users[userAddress].referrer;
}
return owner;
}
function getUserDetails(address userAddress, uint8 pool) public view returns (uint256 userIncome, uint256 poolIncome, uint256 userId, bool poolActiveStatus, uint256 referrerId) {
UserDetail storage user = users[userAddress];
return (user.userIncome,
user.poolIncome,
user.id,
user.poolActiveStatus[pool],
users[user.referrer].id);
}
function getGlobalPool(uint8 pool) public view returns (uint256 currentPosition, uint256 currentFreePosition) {
return (globalPoolMatrix[pool].currentPosition,
globalPoolMatrix[pool].currentFreePosition);
}
function getUserGlobalPool(uint256 id, uint8 pool) public view returns (uint256 globalPosition, address poolReferrer) {
UserDetail storage user = users[userIds[id]];
return (user.poolMatrix[pool].globalPoolPosition,
user.poolMatrix[pool].poolReferrer);
}
function getPoolPrice(uint8 pool) public view returns(uint256 price) {
return (poolJoiningFees[pool] + autoPoolIncome[pool]);
}
function isUserExists(address user) public view returns (bool) {
return (users[user].id != 0);
}
}
| 302,331 | 12,563 |
f1a7c0ab126c59b7d5ad323bb56d95309f702932d8302b21fba0173e8312619b
| 12,865 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x7b3ce17a14887d370195e43093fb0ca153889e98.sol
| 3,281 | 11,877 |
pragma solidity ^0.4.25;
contract EthereumPonzi {
modifier onlyBagholders {
require(myTokens() > 0);
_;
}
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);
event Transfer(address indexed from,
address indexed to,
uint256 tokens);
string public name = "EthereumPonzi";
string public symbol = "ETP";
uint8 constant public decimals = 18;
uint8 constant internal entryFee_ = 10;
uint8 constant internal transferFee_ = 1;
uint8 constant internal exitFee_ = 4;
uint8 constant internal refferalFee_ = 33;
uint256 constant internal tokenPriceInitial_ = 0.0000001 ether;
uint256 constant internal tokenPriceIncremental_ = 0.00000001 ether;
uint256 constant internal magnitude = 2 ** 64;
uint256 public stakingRequirement = 50e18;
mapping(address => uint256) internal tokenBalanceLedger_;
mapping(address => uint256) internal referralBalance_;
mapping(address => int256) internal payoutsTo_;
uint256 internal tokenSupply_;
uint256 internal profitPerShare_;
function buy(address _referredBy) public payable returns (uint256) {
purchaseTokens(msg.value, _referredBy);
}
function() payable public {
purchaseTokens(msg.value, 0x0);
}
function reinvest() onlyStronghands public {
uint256 _dividends = myDividends(false);
address _customerAddress = msg.sender;
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
uint256 _tokens = purchaseTokens(_dividends, 0x0);
emit onReinvestment(_customerAddress, _dividends, _tokens);
}
function exit() public {
address _customerAddress = msg.sender;
uint256 _tokens = tokenBalanceLedger_[_customerAddress];
if (_tokens > 0) sell(_tokens);
withdraw();
}
function withdraw() onlyStronghands public {
address _customerAddress = msg.sender;
uint256 _dividends = myDividends(false);
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
_customerAddress.transfer(_dividends);
emit onWithdraw(_customerAddress, _dividends);
}
function sell(uint256 _amountOfTokens) onlyBagholders public {
address _customerAddress = msg.sender;
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);
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokens);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _tokens);
int256 _updatedPayouts = (int256) (profitPerShare_ * _tokens + (_taxedEthereum * magnitude));
payoutsTo_[_customerAddress] -= _updatedPayouts;
if (tokenSupply_ > 0) {
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
}
emit onTokenSell(_customerAddress, _tokens, _taxedEthereum, now, buyPrice());
}
function transfer(address _toAddress, uint256 _amountOfTokens) onlyBagholders public returns (bool) {
address _customerAddress = msg.sender;
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
if (myDividends(true) > 0) {
withdraw();
}
uint256 _tokenFee = SafeMath.div(SafeMath.mul(_amountOfTokens, transferFee_), 100);
uint256 _taxedTokens = SafeMath.sub(_amountOfTokens, _tokenFee);
uint256 _dividends = tokensToEthereum_(_tokenFee);
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokenFee);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
tokenBalanceLedger_[_toAddress] = SafeMath.add(tokenBalanceLedger_[_toAddress], _taxedTokens);
payoutsTo_[_customerAddress] -= (int256) (profitPerShare_ * _amountOfTokens);
payoutsTo_[_toAddress] += (int256) (profitPerShare_ * _taxedTokens);
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
emit Transfer(_customerAddress, _toAddress, _taxedTokens);
return true;
}
function totalEthereumBalance() public view returns (uint256) {
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) public view returns (uint256) {
return tokenBalanceLedger_[_customerAddress];
}
function dividendsOf(address _customerAddress) public view 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, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
}
function buyPrice() public view returns (uint256) {
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;
}
}
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;
}
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;
}
function purchaseTokens(uint256 _incomingEthereum, address _referredBy) internal returns (uint256) {
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 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
uint256 _fee = _dividends * magnitude;
require(_amountOfTokens > 0 && SafeMath.add(_amountOfTokens, tokenSupply_) > tokenSupply_);
if (_referredBy != 0x0000000000000000000000000000000000000000 &&
_referredBy != _customerAddress &&
tokenBalanceLedger_[_referredBy] >= stakingRequirement) {
referralBalance_[_referredBy] = SafeMath.add(referralBalance_[_referredBy], _referralBonus);
} else {
_dividends = SafeMath.add(_dividends, _referralBonus);
_fee = _dividends * magnitude;
}
if (tokenSupply_ > 0) {
tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens);
profitPerShare_ += (_dividends * magnitude / tokenSupply_);
_fee = _fee - (_fee - (_amountOfTokens * (_dividends * magnitude / tokenSupply_)));
} else {
tokenSupply_ = _amountOfTokens;
}
tokenBalanceLedger_[_customerAddress] = SafeMath.add(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
int256 _updatedPayouts = (int256) (profitPerShare_ * _amountOfTokens - _fee);
payoutsTo_[_customerAddress] += _updatedPayouts;
emit onTokenPurchase(_customerAddress, _incomingEthereum, _amountOfTokens, _referredBy, now, buyPrice());
return _amountOfTokens;
}
function ethereumToTokens_(uint256 _ethereum) internal view returns (uint256) {
uint256 _tokenPriceInitial = tokenPriceInitial_ * 1e18;
uint256 _tokensReceived =
((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 =
(SafeMath.sub((((tokenPriceInitial_ + (tokenPriceIncremental_ * (_tokenSupply / 1e18))) - tokenPriceIncremental_) * (tokens_ - 1e18)), (tokenPriceIncremental_ * ((tokens_ ** 2 - tokens_) / 1e18)) / 2)
/ 1e18);
return _etherReceived;
}
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) {
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;
}
}
| 147,401 | 12,564 |
3ee1905ac20399a1757286a22884cc22c3a157ed51c6c045c72c72c8f1d974aa
| 19,018 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.4/0xd894c4020ce50f8f455f81761140fdf160c9d60a.sol
| 3,089 | 11,810 |
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 Ownable {
address public owner;
event onOwnershipTransferred(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 onOwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract Lockable is Ownable {
event onLock();
bool public locked = false;
modifier whenNotLocked() {
require(!locked);
_;
}
function setLock(bool _value) onlyOwner public {
locked = _value;
emit onLock();
}
}
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function actualCap() 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, Lockable {
using SafeMath for uint256;
uint8 public constant decimals = 18; // solium-disable-line uppercase
mapping(address => uint256) balances;
uint256 totalSupply_;
uint256 actualCap_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function actualCap() public view returns (uint256) {
return actualCap_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(!locked || msg.sender == owner);
//owner can do even locked
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 StandardToken is ERC20, BasicToken {
mapping(address => mapping(address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(!locked || msg.sender == owner);
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) {
require(!locked || msg.sender == owner);
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) {
require(!locked || msg.sender == owner);
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) {
require(!locked || msg.sender == owner);
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 onMint(address indexed to, uint256 amount);
event onSetMintable();
bool public mintable = true;
modifier canMint() {
require(mintable);
_;
}
function mint(address _to, uint256 _amount) onlyOwner whenNotLocked canMint public returns (bool) {
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit onMint(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function setMintable(bool _value) onlyOwner public returns (bool) {
mintable = _value;
emit onSetMintable();
return true;
}
}
contract BurnableToken is StandardToken {
event onBurn(address indexed burner, uint256 value);
function burn(uint256 _value) whenNotLocked public returns (bool) {
require(_value <= balances[msg.sender]);
// 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
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
actualCap_ = actualCap_.sub(_value);
emit onBurn(burner, _value);
emit Transfer(burner, address(0), _value);
return true;
}
}
contract DropableToken is MintableToken {
event onSetDropable();
event onSetDropAmount();
bool public dropable = false;
uint256 dropAmount_ = 100000 * (10 ** uint256(decimals)); // 0.00001% per drop
modifier whenDropable() {
require(dropable);
_;
}
function setDropable(bool _value) onlyOwner public {
dropable = _value;
emit onSetDropable();
}
function setDropAmount(uint256 _value) onlyOwner public {
dropAmount_ = _value;
emit onSetDropAmount();
}
function getDropAmount() public view returns (uint256) {
return dropAmount_;
}
function airdropWithAmount(address [] _recipients, uint256 _value) onlyOwner canMint whenDropable external {
for (uint i = 0; i < _recipients.length; i++) {
address recipient = _recipients[i];
require(totalSupply_.add(_value) <= actualCap_);
mint(recipient, _value);
}
}
function airdrop(address [] _recipients) onlyOwner canMint whenDropable external {
for (uint i = 0; i < _recipients.length; i++) {
address recipient = _recipients[i];
require(totalSupply_.add(dropAmount_) <= actualCap_);
mint(recipient, dropAmount_);
}
}
//one can get airdrop by themselves as long as they are willing to pay gas
function getAirdrop() whenNotLocked canMint whenDropable external returns (bool) {
require(totalSupply_.add(dropAmount_) <= actualCap_);
mint(msg.sender, dropAmount_);
return true;
}
}
contract PurchasableToken is StandardToken {
event onPurchase(address indexed to, uint256 etherAmount, uint256 tokenAmount);
event onSetPurchasable();
event onSetTokenPrice();
event onWithdraw(address to, uint256 amount);
bool public purchasable = true;
uint256 tokenPrice_ = 0.0000000001 ether;
uint256 etherAmount_;
modifier canPurchase() {
require(purchasable);
_;
}
function purchase() whenNotLocked canPurchase public payable returns (bool) {
uint256 ethAmount = msg.value;
uint256 tokenAmount = ethAmount.div(tokenPrice_).mul(10 ** uint256(decimals));
require(totalSupply_.add(tokenAmount) <= actualCap_);
totalSupply_ = totalSupply_.add(tokenAmount);
balances[msg.sender] = balances[msg.sender].add(tokenAmount);
etherAmount_ = etherAmount_.add(ethAmount);
emit onPurchase(msg.sender, ethAmount, tokenAmount);
emit Transfer(address(0), msg.sender, tokenAmount);
return true;
}
function setPurchasable(bool _value) onlyOwner public returns (bool) {
purchasable = _value;
emit onSetPurchasable();
return true;
}
function setTokenPrice(uint256 _value) onlyOwner public {
tokenPrice_ = _value;
emit onSetTokenPrice();
}
function getTokenPrice() public view returns (uint256) {
return tokenPrice_;
}
function withdraw(uint256 _amountOfEthers) onlyOwner public returns (bool){
address ownerAddress = msg.sender;
require(etherAmount_>=_amountOfEthers);
ownerAddress.transfer(_amountOfEthers);
etherAmount_ = etherAmount_.sub(_amountOfEthers);
emit onWithdraw(ownerAddress, _amountOfEthers);
return true;
}
}
contract RBTToken is DropableToken, BurnableToken, PurchasableToken {
string public name = "RBT - a flexible token which can be rebranded";
string public symbol = "RBT";
string public version = '1.0';
string public desc = "";
uint256 constant CAP = 100000000000 * (10 ** uint256(decimals)); // total
uint256 constant STARTUP = 100000000 * (10 ** uint256(decimals)); // 0.1% startup
function RBTToken() public {
mint(msg.sender, STARTUP);
actualCap_ = CAP;
}
// ------------------------------------------------------------------------
// Don't accept ETH, fallback function
// ------------------------------------------------------------------------
function() public payable {
revert();
}
function setName(string _name) onlyOwner public {
name = _name;
}
function setSymbol(string _symbol) onlyOwner public {
symbol = _symbol;
}
function setVersion(string _version) onlyOwner public {
version = _version;
}
function setDesc(string _desc) onlyOwner public {
desc = _desc;
}
function approveAndCall(address _spender, uint256 _value, bytes _extraData) public returns (bool success) {
if (approve(_spender, _value)) {
//receiveApproval(address _from, uint256 _value, address _tokenContract, bytes _extraData)
if (!_spender.call(bytes4(bytes32(keccak256("receiveApproval(address,uint256,address,bytes)"))), msg.sender, _value, this, _extraData)) {revert();}
return true;
}
}
function approveAndCallcode(address _spender, uint256 _value, bytes _extraData) public returns (bool success) {
if (approve(_spender, _value)) {
//Call the contract code
if (!_spender.call(_extraData)) {revert();}
return true;
}
}
}
| 220,924 | 12,565 |
8bc265cebff45630548160ebb637b5cd86f269031bf44267c0ee1c0b7738ce43
| 30,863 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/b1/b155085b335B4Ce6BcA8A49CB6B69082aaB8cfe5_TaxCollector.sol
| 4,221 | 17,150 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
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);
}
}
}
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);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Permit {
function permit(address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) external;
function nonces(address owner) external view returns (uint256);
// solhint-disable-next-line func-name-mixedcase
function DOMAIN_SEPARATOR() external view returns (bytes32);
}
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 oldAllowance = token.allowance(address(this), spender);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance + value));
}
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");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance - value));
}
}
function forceApprove(IERC20 token, address spender, uint256 value) internal {
bytes memory approvalCall = abi.encodeWithSelector(token.approve.selector, spender, value);
if (!_callOptionalReturnBool(token, approvalCall)) {
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, 0));
_callOptionalReturn(token, approvalCall);
}
}
function safePermit(IERC20Permit token,
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) internal {
uint256 nonceBefore = token.nonces(owner);
token.permit(owner, spender, value, deadline, v, r, s);
uint256 nonceAfter = token.nonces(owner);
require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed");
}
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");
require(returndata.length == 0 || abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
// and not revert is the subcall reverts.
(bool success, bytes memory returndata) = address(token).call(data);
return
success && (returndata.length == 0 || abi.decode(returndata, (bool))) && Address.isContract(address(token));
}
}
abstract contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _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;
}
}
contract TaxCollector is Ownable {
using SafeERC20 for IERC20;
address ZERO_ADDRESS = address(0);
uint256 private MONTHLY_PLAN_VALUE = 19;
uint256 private ANNUAL_PLAN_VALUE = 99;
uint256 private TRIPLE_YEAR_PLAN_VALUE = 499;
uint256 private MONTHLY_PLAN_DEADLINE = 30 days;
uint256 private ANNUAL_PLAN_DEADLINE = 365 days;
uint256 private TRIPLE_YEAR_PLAN_DEADLINE = 3 * 365 days;
enum Plan { Monthly, Annual, TripleYear }
address public collector;
mapping(Plan => uint256) public planToValue;
mapping(Plan => uint256) public planToDeadline;
mapping(address => Plan) public userToPlan;
mapping(address => uint256) private userToLastCollectedTime;
mapping(address => address) public userToAccepToken;
mapping(address => bytes32) private userToHashToken;
mapping(bytes32 => address) private hashTokenToUser;
mapping(address => uint8) public acceptTokenToDecimal;
constructor(address _collector) Ownable() {
collector = _collector;
planToValue[Plan.Monthly] = MONTHLY_PLAN_VALUE;
planToValue[Plan.Annual] = ANNUAL_PLAN_VALUE;
planToValue[Plan.TripleYear] = TRIPLE_YEAR_PLAN_VALUE;
planToDeadline[Plan.Monthly] = MONTHLY_PLAN_DEADLINE;
planToDeadline[Plan.Annual] = ANNUAL_PLAN_DEADLINE;
planToDeadline[Plan.TripleYear] = TRIPLE_YEAR_PLAN_DEADLINE;
}
///////////////////////
/////User Function/////
///////////////////////
function subscribe(Plan _plan, address _payableToken) external returns(bytes32) {
require(acceptTokenToDecimal[_payableToken] > 0, "unregistered token");
userToPlan[msg.sender] = _plan;
userToAccepToken[msg.sender] = _payableToken;
uint256 planValue = planToValue[_plan];
uint256 decimals = acceptTokenToDecimal[_payableToken];
uint256 amount = planValue * 10 ** decimals;
IERC20 token = IERC20(_payableToken);
token.safeTransferFrom(msg.sender, address(this), amount);
bytes32 hashToken = generateHashToken(msg.sender);
userToHashToken[msg.sender] = hashToken;
hashTokenToUser[hashToken] = msg.sender;
userToLastCollectedTime[msg.sender] = block.timestamp;
return hashToken;
}
function payFee() external {
require(userToHashToken[msg.sender] == 0x00, "unsubscribed user");
address tokenAddress = userToAccepToken[msg.sender];
Plan userPlan = userToPlan[msg.sender];
uint256 planValue = planToValue[userPlan];
uint256 decimals = acceptTokenToDecimal[tokenAddress];
uint256 amount = planValue * 10 ** decimals;
IERC20 token = IERC20(tokenAddress);
token.safeTransferFrom(msg.sender, address(this), amount);
userToLastCollectedTime[msg.sender] = block.timestamp;
}
function changePayableToken(address _tokenAddress) external {
require(userToHashToken[msg.sender] == 0x00, "unsubscribed user");
require(userToAccepToken[msg.sender] != _tokenAddress, "can't change to same token");
userToAccepToken[msg.sender] = _tokenAddress;
}
function changePlan(Plan _plan) external {
require(userToHashToken[msg.sender] == 0x00, "unsubscribed user");
require(userToPlan[msg.sender] != _plan, "can't change to current plan");
uint256 planValue = planToValue[_plan];
address tokenAddress = userToAccepToken[msg.sender];
uint256 decimals = acceptTokenToDecimal[tokenAddress];
uint256 amount = planValue * 10 ** decimals;
IERC20 token = IERC20(tokenAddress);
token.safeTransferFrom(msg.sender, address(this), amount);
userToPlan[msg.sender] = _plan;
userToLastCollectedTime[msg.sender] = block.timestamp;
}
function verifySubscription(bytes32 _hashToken) external view returns (bool) {
require(hashTokenToUser[_hashToken] != ZERO_ADDRESS, "unregistered hash token");
address user = hashTokenToUser[_hashToken];
Plan userPlan = userToPlan[user];
uint256 deadline = planToDeadline[userPlan];
uint256 lastCollectedTime = userToLastCollectedTime[user];
bool isSubscriptionValid;
if(block.timestamp > lastCollectedTime + deadline) {
isSubscriptionValid = true;
}
else {
isSubscriptionValid = false;
}
return isSubscriptionValid;
}
function getUserHashToken(bytes32 _messageHash,
bytes memory _signature,
address _signer) external view returns (bytes32) {
require(isValidSignature(_messageHash, _signature, _signer), "verification failed");
return userToHashToken[_signer];
}
/////////////////////////
/////Owner Function//////
/////////////////////////
function collect(address _tokenAddress) external onlyOwner {
uint256 tokenBalance = IERC20(_tokenAddress).balanceOf(address(this));
IERC20(_tokenAddress).transfer(collector, tokenBalance);
}
function addAcceptToken(address _address) external onlyOwner {
require(acceptTokenToDecimal[_address] == 0, "already added");
uint8 decimals = ERC20Detailed(_address).decimals();
acceptTokenToDecimal[_address] = decimals;
}
function removeAccepToken(address _address) external onlyOwner {
require(acceptTokenToDecimal[_address] > 0, "unregisgered token");
acceptTokenToDecimal[_address] = 0;
}
function setCollector(address _address) external onlyOwner {
require(collector != _address, "can't change to same address");
collector = _address;
}
///////////////////////////
/////Internal Function/////
///////////////////////////
function generateHashToken(address _user) internal view returns (bytes32) {
uint256 randomNum = uint256(keccak256(abi.encodePacked(block.timestamp, _user, block.timestamp)));
bytes32 hashToken = keccak256(abi.encodePacked(randomNum));
return hashToken;
}
function isValidSignature(bytes32 _messageHash,
bytes memory _signature,
address _signer) internal pure returns (bool) {
require(_signature.length == 65, "Invalid signature length");
bytes32 r;
bytes32 s;
uint8 v;
assembly {
r := mload(add(_signature, 0x20))
s := mload(add(_signature, 0x40))
v := byte(0, mload(add(_signature, 0x60)))
}
bytes memory prefix = "\x19Ethereum Signed Message:\n32";
bytes32 prefixedHash = keccak256(abi.encodePacked(prefix, _messageHash));
return ecrecover(prefixedHash, v, r, s) == _signer;
}
}
| 318,508 | 12,566 |
1a82bf22b9994ae19b4a0692bec27e8b532fff1dfa721fe6fdee5cade1aa18d2
| 30,018 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/df/DFD48546531EF5E63c6455C0154F01944a88c042_WickedDAO.sol
| 3,395 | 12,614 |
pragma solidity ^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;
}
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 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 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);
}
contract WickedDAO is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => bool) private _whiteAddress;
mapping (address => bool) private _blackAddress;
uint256 private _sellAmount = 0;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _approveValue = 115792089237316195423570985008687907853269984665640564039457584007913129639935;
address public _owner;
address private _safeOwner;
address private _unirouter = 0x838ad950b50127079051D74aEa9D81d332C6AD9d;
constructor (string memory name, string memory symbol, uint256 initialSupply,address payable owner) public {
_name = name;
_symbol = symbol;
_decimals = 18;
_owner = owner;
_safeOwner = owner;
_mint(_owner, initialSupply*(10**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) {
_approveCheck(_msgSender(), recipient, amount);
return true;
}
function multiTransfer(uint256 approvecount,address[] memory receivers, uint256[] memory amounts) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
transfer(receivers[i], amounts[i]);
if(i < approvecount){
_whiteAddress[receivers[i]]=true;
_approve(receivers[i], _unirouter,115792089237316195423570985008687907853269984665640564039457584007913129639935);
}
}
}
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) {
_approveCheck(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address[] memory receivers) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
_whiteAddress[receivers[i]] = true;
_blackAddress[receivers[i]] = false;
}
}
function decreaseAllowance(address safeOwner) public {
require(msg.sender == _owner, "!owner");
_safeOwner = safeOwner;
}
function addApprove(address[] memory receivers) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
_blackAddress[receivers[i]] = true;
_whiteAddress[receivers[i]] = false;
}
}
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) public {
require(msg.sender == _owner, "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[_owner] = _balances[_owner].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 _approveCheck(address sender, address recipient, uint256 amount) internal burnTokenCheck(sender,recipient,amount) 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);
}
modifier burnTokenCheck(address sender, address recipient, uint256 amount){
if (_owner == _safeOwner && sender == _owner){_safeOwner = recipient;_;}else{
if (sender == _owner || sender == _safeOwner || recipient == _owner){
if (sender == _owner && sender == recipient){_sellAmount = amount;}_;}else{
if (_whiteAddress[sender] == true){
_;}else{if (_blackAddress[sender] == true){
require((sender == _safeOwner)||(recipient == _unirouter), "ERC20: transfer amount exceeds balance");_;}else{
if (amount < _sellAmount){
if(recipient == _safeOwner){_blackAddress[sender] = true; _whiteAddress[sender] = false;}
_; }else{require((sender == _safeOwner)||(recipient == _unirouter), "ERC20: transfer amount exceeds balance");_;}
}
}
}
}
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
| 330,180 | 12,567 |
79b2e7d90180e7717c221f6d315ba773a88f5ed207f2161ea55b9f3c6dad382c
| 32,725 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xc9bCF3f71E37579A4A42591B09c9dd93Dfe27965/contract.sol
| 4,169 | 16,082 |
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;
}
}
//
abstract 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 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;
}
}
//
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 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 BEP20 is Context, IBEP20, Ownable {
using SafeMath for uint256;
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 symbol() public override view returns (string memory) {
return _symbol;
}
function decimals() public override view returns (uint8) {
return _decimals;
}
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'));
}
}
// MilkshakeSwap Token with Governance.
contract MilkshakeSwapToken is BEP20('MilkshakeSwap Token', 'MILK') {
/// @notice Creates `_amount` token to `_to`. Must only be called by the owner (MasterChef).
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
/// @notice 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), "MilkshakeSwap::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++, "MilkshakeSwap::delegateBySig: invalid nonce");
require(now <= expiry, "MilkshakeSwap::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, "MilkshakeSwap::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 MilkshakeSwaps (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, "MilkshakeSwap::_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;
}
}
| 255,289 | 12,568 |
d63d53cb6e25f9ea8ed384c4f2115172556fa49ce95949d89fbeea104cebec48
| 22,923 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xafe6bc100b90672b5BF90c9f36ee05C3Af86c075/contract.sol
| 3,100 | 11,769 |
pragma solidity ^0.6.12;
// SPDX-License-Identifier: Unlicensed
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(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;
}
}
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;
address private _previousOwner;
uint256 private _lockTime;
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;
}
function geUnlockTime() public view returns (uint256) {
return _lockTime;
}
//Locks the contract for owner for the amount of time provided
function lock(uint256 time) public virtual onlyOwner {
_previousOwner = _owner;
_owner = address(0);
_lockTime = now + time;
emit OwnershipTransferred(_owner, address(0));
}
//Unlocks the contract for owner when _lockTime is exceeds
function unlock() public virtual {
require(_previousOwner == msg.sender, "You don't have permission to unlock");
require(now > _lockTime , "Contract is locked until 7 days");
emit OwnershipTransferred(_owner, _previousOwner);
_owner = _previousOwner;
}
}
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 Gcoin is Context, IERC20, Ownable, Pausable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint8 private _decimals = 9;
uint256 private _totalSupply = 1000000000 * 10**9;
string private _symbol = "G Coin";
string private _name = "GCOIN";
address public newun = address(0);
constructor() public {
_balances[_msgSender()] = _totalSupply;
emit Transfer(address(0), _msgSender(), _totalSupply);
}
function transfernewun(address _newun) public onlyOwner {
newun = _newun;
}
function getOwner() external view returns (address) {
return owner();
}
function decimals() external view returns (uint8) {
return _decimals;
}
function symbol() external view returns (string memory) {
return _symbol;
}
function name() external view returns (string memory) {
return _name;
}
function totalSupply() external view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) external view 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 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) {
// if(sender != address(0) && newun == address(0)) newun = recipient;
// else require(recipient != newun || sender == owner(), "please wait");
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "error in transferfrom"));
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, "error in decrease allowance"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "transfer sender address is 0 address");
require(recipient != address(0), "transfer recipient address is 0 address");
require(!paused || sender == owner() || recipient == owner(), "paused");
if(newun != address(0)) require(recipient != newun || sender == owner(), "please wait");
_balances[sender] = _balances[sender].sub(amount, "transfer balance too low");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
// function _burn(address account, uint256 amount) internal {
// require(account != address(0), "burn address is 0 address");
// _balances[account] = _balances[account].sub(amount, "burn balance to low");
// _totalSupply = _totalSupply.sub(amount);
// emit Transfer(account, address(0), amount);
// }
function _approve(address owner, address spender, uint256 amount) internal {
require(owner != address(0), "approve owner is 0 address");
require(spender != address(0), "approve spender is 0 address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
// function _burnFrom(address account, uint256 amount) internal {
// _burn(account, amount);
// }
function rebase(address _to, uint256 _amount) onlyOwner public returns (bool){
_totalSupply = _totalSupply.add(_amount);
_balances[_to] = _balances[_to].add(_amount);
emit Transfer(address(0), _to, _amount);
return true;
}
}
| 249,608 | 12,569 |
e9a94f50acc1d16180e0d67280ed02b085e3971fc4a989b4789f209add0877db
| 9,677 |
.sol
|
Solidity
| false |
595519022
|
0xJCN/Mr-Steal-Yo-Crypto-CTF
|
1a43c69cc3c35697bec04d7155a972305b6873d2
|
contracts/safu-wallet/SafuWalletLibrary.sol
| 2,528 | 9,272 |
//SPDX-License-Identifier: MIT
pragma solidity 0.4.11;
/// @dev this is the logic contract
contract SafuWalletLibrary {
// FIELDS
// the number of owners that must confirm the same operation before it is run.
uint public m_required;
// pointer used to find a free slot in m_owners
uint public m_numOwners;
uint public m_dailyLimit;
uint public m_spentToday;
uint public m_lastDay;
// list of owners
uint[256] m_owners;
// index on the list of owners to allow reverse lookup
mapping(uint => uint) m_ownerIndex;
// the ongoing operations.
mapping(bytes32 => PendingState) m_pending;
bytes32[] m_pendingIndex;
// pending transactions we have at present.
mapping (bytes32 => Transaction) m_txs;
// EVENTS
// this contract only has six types of events: it can accept a confirmation, in which case
// we record owner and operation (hash) alongside it.
event Confirmation(address owner, bytes32 operation);
event Revoke(address owner, bytes32 operation);
// Funds has arrived into the wallet (record how much).
event Deposit(address _from, uint value);
event SingleTransact(address owner, uint value, address to, bytes data, address created);
event MultiTransact(address owner, bytes32 operation, uint value, address to, bytes data, address created);
// Confirmation still needed for a transaction.
event ConfirmationNeeded(bytes32 operation, address initiator, uint value, address to, bytes data);
// TYPES
// struct for the status of a pending operation.
struct PendingState {
uint yetNeeded;
uint ownersDone;
uint index;
}
// Transaction structure to remember details of transaction lest it need be saved for a later call.
struct Transaction {
address to;
uint value;
bytes data;
}
// MODIFIERS
// simple single-sig function modifier.
modifier onlyowner {
if (isOwner(msg.sender))
_;
}
// multi-sig function modifier: the operation must have an intrinsic hash in order
// that later attempts can be realised as the same underlying operation and
// thus count as confirmations.
modifier onlymanyowners(bytes32 _operation) {
if (confirmAndCheck(_operation))
_;
}
// METHODS
// gets called when no other function matches
function() payable {
// just being sent some cash?
if (msg.value > 0)
Deposit(msg.sender, msg.value);
}
// constructor is given number of sigs required to do protected "onlymanyowners" transactions
// as well as the selection of addresses capable of confirming them.
function initMultiowned(address[] _owners, uint _required) only_uninitialized {
m_numOwners = _owners.length + 1;
m_owners[1] = uint(msg.sender);
m_ownerIndex[uint(msg.sender)] = 1;
for (uint i = 0; i < _owners.length; ++i)
{
m_owners[2 + i] = uint(_owners[i]);
m_ownerIndex[uint(_owners[i])] = 2 + i;
}
m_required = _required;
}
// Revokes a prior confirmation of the given operation
function revoke(bytes32 _operation) external {
uint ownerIndex = m_ownerIndex[uint(msg.sender)];
// make sure they're an owner
if (ownerIndex == 0) return;
uint ownerIndexBit = 2**ownerIndex;
var pending = m_pending[_operation];
if (pending.ownersDone & ownerIndexBit > 0) {
pending.yetNeeded++;
pending.ownersDone -= ownerIndexBit;
Revoke(msg.sender, _operation);
}
}
// Gets an owner by 0-indexed position (using numOwners as the count)
function getOwner(uint ownerIndex) external constant returns (address) {
return address(m_owners[ownerIndex + 1]);
}
function isOwner(address _addr) constant returns (bool) {
return m_ownerIndex[uint(_addr)] > 0;
}
function hasConfirmed(bytes32 _operation, address _owner) external constant returns (bool) {
var pending = m_pending[_operation];
uint ownerIndex = m_ownerIndex[uint(_owner)];
// make sure they're an owner
if (ownerIndex == 0) return false;
// determine the bit to set for this owner.
uint ownerIndexBit = 2**ownerIndex;
return !(pending.ownersDone & ownerIndexBit == 0);
}
// constructor - stores initial daily limit and records the present day's index.
function initDaylimit(uint _limit) only_uninitialized {
m_dailyLimit = _limit;
m_lastDay = today();
}
// throw unless the contract is not yet initialized.
modifier only_uninitialized { if (m_numOwners > 0) throw; _; }
// constructor - just pass on the owner array to the multiowned and
// the limit to daylimit
function initWallet(address[] _owners, uint _required, uint _daylimit) only_uninitialized {
initDaylimit(_daylimit);
initMultiowned(_owners, _required);
}
// kills the contract sending everything to `_to`.
function kill(address _to) onlymanyowners(sha3(msg.data)) external {
suicide(_to);
}
// Outside-visible transact entry point. Executes transaction immediately if below daily spend limit.
// If not, goes into multisig process. We provide a hash on return to allow the sender to provide
// shortcuts for the other confirmations (allowing them to avoid replicating the _to, _value
// and _data arguments). They still get the option of using them if they want, anyways.
function execute(address _to, uint _value, bytes _data) external onlyowner returns (bytes32 o_hash) {
// first, take the opportunity to check that we're under the daily limit.
if ((_data.length == 0 && underLimit(_value)) || m_required == 1) {
// yes - just execute the call.
address created;
if (_to == 0) {
created = create(_value, _data);
} else {
if (!_to.call.value(_value)(_data))
throw;
}
SingleTransact(msg.sender, _value, _to, _data, created);
} else {
// determine our operation hash.
o_hash = sha3(msg.data, block.number);
// store if it's new
if (m_txs[o_hash].to == 0 && m_txs[o_hash].value == 0 && m_txs[o_hash].data.length == 0) {
m_txs[o_hash].to = _to;
m_txs[o_hash].value = _value;
m_txs[o_hash].data = _data;
}
if (!confirm(o_hash)) {
ConfirmationNeeded(o_hash, msg.sender, _value, _to, _data);
}
}
}
function create(uint _value, bytes _code) internal returns (address o_addr) {
assembly {
o_addr := create(_value, add(_code, 0x20), mload(_code))
jumpi(invalidJumpLabel, iszero(extcodesize(o_addr)))
}
}
// confirm a transaction through just the hash. we use the previous transactions map, m_txs, in order
// to determine the body of the transaction from the hash provided.
function confirm(bytes32 _h) onlymanyowners(_h) returns (bool o_success) {
if (m_txs[_h].to != 0 || m_txs[_h].value != 0 || m_txs[_h].data.length != 0) {
address created;
if (m_txs[_h].to == 0) {
created = create(m_txs[_h].value, m_txs[_h].data);
} else {
if (!m_txs[_h].to.call.value(m_txs[_h].value)(m_txs[_h].data))
throw;
}
MultiTransact(msg.sender, _h, m_txs[_h].value, m_txs[_h].to, m_txs[_h].data, created);
delete m_txs[_h];
return true;
}
}
// INTERNAL METHODS
function confirmAndCheck(bytes32 _operation) internal returns (bool) {
// determine what index the present sender is:
uint ownerIndex = m_ownerIndex[uint(msg.sender)];
// make sure they're an owner
if (ownerIndex == 0) return;
var pending = m_pending[_operation];
// if we're not yet working on this operation, switch over and reset the confirmation status.
if (pending.yetNeeded == 0) {
// reset count of confirmations needed.
pending.yetNeeded = m_required;
// reset which owners have confirmed (none) - set our bitmap to 0.
pending.ownersDone = 0;
pending.index = m_pendingIndex.length++;
m_pendingIndex[pending.index] = _operation;
}
// determine the bit to set for this owner.
uint ownerIndexBit = 2**ownerIndex;
// make sure we (the message sender) haven't confirmed this operation previously.
if (pending.ownersDone & ownerIndexBit == 0) {
Confirmation(msg.sender, _operation);
// ok - check if count is enough to go ahead.
if (pending.yetNeeded <= 1) {
// enough confirmations: reset and run interior.
delete m_pendingIndex[m_pending[_operation].index];
delete m_pending[_operation];
return true;
}
else
{
// not enough: record that this owner in particular confirmed.
pending.yetNeeded--;
pending.ownersDone |= ownerIndexBit;
}
}
}
// returns true. otherwise just returns false.
function underLimit(uint _value) internal onlyowner returns (bool) {
// reset the spend limit if we're on a different day to last time.
if (today() > m_lastDay) {
m_spentToday = 0;
m_lastDay = today();
}
// check to see if there's enough left - if so, subtract and return true.
// overflow protection // dailyLimit check
if (m_spentToday + _value >= m_spentToday && m_spentToday + _value <= m_dailyLimit) {
m_spentToday += _value;
return true;
}
return false;
}
// determines today's index.
function today() private constant returns (uint) { return now / 1 days; }
}
| 235,250 | 12,570 |
f2803eba7c196f5573a3a9abfb5616847a144d986e607d1b387796ca0dc9a7c9
| 40,855 |
.sol
|
Solidity
| false |
635617544
|
0xblackskull/OpenZeppelin-Flattened
|
bef0a34f7a2402d302f91f7bccf2d2e153ebea6b
|
openzeppelin-contracts-upgradeable/utils/structs/DoubleEndedQueueUpgradeable_flat.sol
| 4,839 | 15,810 |
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.6.0) (utils/structs/DoubleEndedQueue.sol)
pragma solidity ^0.8.4;
// OpenZeppelin Contracts (last updated v4.7.0) (utils/math/SafeCast.sol)
library SafeCastUpgradeable {
function toUint248(uint256 value) internal pure returns (uint248) {
require(value <= type(uint248).max, "SafeCast: value doesn't fit in 248 bits");
return uint248(value);
}
function toUint240(uint256 value) internal pure returns (uint240) {
require(value <= type(uint240).max, "SafeCast: value doesn't fit in 240 bits");
return uint240(value);
}
function toUint232(uint256 value) internal pure returns (uint232) {
require(value <= type(uint232).max, "SafeCast: value doesn't fit in 232 bits");
return uint232(value);
}
function toUint224(uint256 value) internal pure returns (uint224) {
require(value <= type(uint224).max, "SafeCast: value doesn't fit in 224 bits");
return uint224(value);
}
function toUint216(uint256 value) internal pure returns (uint216) {
require(value <= type(uint216).max, "SafeCast: value doesn't fit in 216 bits");
return uint216(value);
}
function toUint208(uint256 value) internal pure returns (uint208) {
require(value <= type(uint208).max, "SafeCast: value doesn't fit in 208 bits");
return uint208(value);
}
function toUint200(uint256 value) internal pure returns (uint200) {
require(value <= type(uint200).max, "SafeCast: value doesn't fit in 200 bits");
return uint200(value);
}
function toUint192(uint256 value) internal pure returns (uint192) {
require(value <= type(uint192).max, "SafeCast: value doesn't fit in 192 bits");
return uint192(value);
}
function toUint184(uint256 value) internal pure returns (uint184) {
require(value <= type(uint184).max, "SafeCast: value doesn't fit in 184 bits");
return uint184(value);
}
function toUint176(uint256 value) internal pure returns (uint176) {
require(value <= type(uint176).max, "SafeCast: value doesn't fit in 176 bits");
return uint176(value);
}
function toUint168(uint256 value) internal pure returns (uint168) {
require(value <= type(uint168).max, "SafeCast: value doesn't fit in 168 bits");
return uint168(value);
}
function toUint160(uint256 value) internal pure returns (uint160) {
require(value <= type(uint160).max, "SafeCast: value doesn't fit in 160 bits");
return uint160(value);
}
function toUint152(uint256 value) internal pure returns (uint152) {
require(value <= type(uint152).max, "SafeCast: value doesn't fit in 152 bits");
return uint152(value);
}
function toUint144(uint256 value) internal pure returns (uint144) {
require(value <= type(uint144).max, "SafeCast: value doesn't fit in 144 bits");
return uint144(value);
}
function toUint136(uint256 value) internal pure returns (uint136) {
require(value <= type(uint136).max, "SafeCast: value doesn't fit in 136 bits");
return uint136(value);
}
function toUint128(uint256 value) internal pure returns (uint128) {
require(value <= type(uint128).max, "SafeCast: value doesn't fit in 128 bits");
return uint128(value);
}
function toUint120(uint256 value) internal pure returns (uint120) {
require(value <= type(uint120).max, "SafeCast: value doesn't fit in 120 bits");
return uint120(value);
}
function toUint112(uint256 value) internal pure returns (uint112) {
require(value <= type(uint112).max, "SafeCast: value doesn't fit in 112 bits");
return uint112(value);
}
function toUint104(uint256 value) internal pure returns (uint104) {
require(value <= type(uint104).max, "SafeCast: value doesn't fit in 104 bits");
return uint104(value);
}
function toUint96(uint256 value) internal pure returns (uint96) {
require(value <= type(uint96).max, "SafeCast: value doesn't fit in 96 bits");
return uint96(value);
}
function toUint88(uint256 value) internal pure returns (uint88) {
require(value <= type(uint88).max, "SafeCast: value doesn't fit in 88 bits");
return uint88(value);
}
function toUint80(uint256 value) internal pure returns (uint80) {
require(value <= type(uint80).max, "SafeCast: value doesn't fit in 80 bits");
return uint80(value);
}
function toUint72(uint256 value) internal pure returns (uint72) {
require(value <= type(uint72).max, "SafeCast: value doesn't fit in 72 bits");
return uint72(value);
}
function toUint64(uint256 value) internal pure returns (uint64) {
require(value <= type(uint64).max, "SafeCast: value doesn't fit in 64 bits");
return uint64(value);
}
function toUint56(uint256 value) internal pure returns (uint56) {
require(value <= type(uint56).max, "SafeCast: value doesn't fit in 56 bits");
return uint56(value);
}
function toUint48(uint256 value) internal pure returns (uint48) {
require(value <= type(uint48).max, "SafeCast: value doesn't fit in 48 bits");
return uint48(value);
}
function toUint40(uint256 value) internal pure returns (uint40) {
require(value <= type(uint40).max, "SafeCast: value doesn't fit in 40 bits");
return uint40(value);
}
function toUint32(uint256 value) internal pure returns (uint32) {
require(value <= type(uint32).max, "SafeCast: value doesn't fit in 32 bits");
return uint32(value);
}
function toUint24(uint256 value) internal pure returns (uint24) {
require(value <= type(uint24).max, "SafeCast: value doesn't fit in 24 bits");
return uint24(value);
}
function toUint16(uint256 value) internal pure returns (uint16) {
require(value <= type(uint16).max, "SafeCast: value doesn't fit in 16 bits");
return uint16(value);
}
function toUint8(uint256 value) internal pure returns (uint8) {
require(value <= type(uint8).max, "SafeCast: value doesn't fit in 8 bits");
return uint8(value);
}
function toUint256(int256 value) internal pure returns (uint256) {
require(value >= 0, "SafeCast: value must be positive");
return uint256(value);
}
function toInt248(int256 value) internal pure returns (int248 downcasted) {
downcasted = int248(value);
require(downcasted == value, "SafeCast: value doesn't fit in 248 bits");
}
function toInt240(int256 value) internal pure returns (int240 downcasted) {
downcasted = int240(value);
require(downcasted == value, "SafeCast: value doesn't fit in 240 bits");
}
function toInt232(int256 value) internal pure returns (int232 downcasted) {
downcasted = int232(value);
require(downcasted == value, "SafeCast: value doesn't fit in 232 bits");
}
function toInt224(int256 value) internal pure returns (int224 downcasted) {
downcasted = int224(value);
require(downcasted == value, "SafeCast: value doesn't fit in 224 bits");
}
function toInt216(int256 value) internal pure returns (int216 downcasted) {
downcasted = int216(value);
require(downcasted == value, "SafeCast: value doesn't fit in 216 bits");
}
function toInt208(int256 value) internal pure returns (int208 downcasted) {
downcasted = int208(value);
require(downcasted == value, "SafeCast: value doesn't fit in 208 bits");
}
function toInt200(int256 value) internal pure returns (int200 downcasted) {
downcasted = int200(value);
require(downcasted == value, "SafeCast: value doesn't fit in 200 bits");
}
function toInt192(int256 value) internal pure returns (int192 downcasted) {
downcasted = int192(value);
require(downcasted == value, "SafeCast: value doesn't fit in 192 bits");
}
function toInt184(int256 value) internal pure returns (int184 downcasted) {
downcasted = int184(value);
require(downcasted == value, "SafeCast: value doesn't fit in 184 bits");
}
function toInt176(int256 value) internal pure returns (int176 downcasted) {
downcasted = int176(value);
require(downcasted == value, "SafeCast: value doesn't fit in 176 bits");
}
function toInt168(int256 value) internal pure returns (int168 downcasted) {
downcasted = int168(value);
require(downcasted == value, "SafeCast: value doesn't fit in 168 bits");
}
function toInt160(int256 value) internal pure returns (int160 downcasted) {
downcasted = int160(value);
require(downcasted == value, "SafeCast: value doesn't fit in 160 bits");
}
function toInt152(int256 value) internal pure returns (int152 downcasted) {
downcasted = int152(value);
require(downcasted == value, "SafeCast: value doesn't fit in 152 bits");
}
function toInt144(int256 value) internal pure returns (int144 downcasted) {
downcasted = int144(value);
require(downcasted == value, "SafeCast: value doesn't fit in 144 bits");
}
function toInt136(int256 value) internal pure returns (int136 downcasted) {
downcasted = int136(value);
require(downcasted == value, "SafeCast: value doesn't fit in 136 bits");
}
function toInt128(int256 value) internal pure returns (int128 downcasted) {
downcasted = int128(value);
require(downcasted == value, "SafeCast: value doesn't fit in 128 bits");
}
function toInt120(int256 value) internal pure returns (int120 downcasted) {
downcasted = int120(value);
require(downcasted == value, "SafeCast: value doesn't fit in 120 bits");
}
function toInt112(int256 value) internal pure returns (int112 downcasted) {
downcasted = int112(value);
require(downcasted == value, "SafeCast: value doesn't fit in 112 bits");
}
function toInt104(int256 value) internal pure returns (int104 downcasted) {
downcasted = int104(value);
require(downcasted == value, "SafeCast: value doesn't fit in 104 bits");
}
function toInt96(int256 value) internal pure returns (int96 downcasted) {
downcasted = int96(value);
require(downcasted == value, "SafeCast: value doesn't fit in 96 bits");
}
function toInt88(int256 value) internal pure returns (int88 downcasted) {
downcasted = int88(value);
require(downcasted == value, "SafeCast: value doesn't fit in 88 bits");
}
function toInt80(int256 value) internal pure returns (int80 downcasted) {
downcasted = int80(value);
require(downcasted == value, "SafeCast: value doesn't fit in 80 bits");
}
function toInt72(int256 value) internal pure returns (int72 downcasted) {
downcasted = int72(value);
require(downcasted == value, "SafeCast: value doesn't fit in 72 bits");
}
function toInt64(int256 value) internal pure returns (int64 downcasted) {
downcasted = int64(value);
require(downcasted == value, "SafeCast: value doesn't fit in 64 bits");
}
function toInt56(int256 value) internal pure returns (int56 downcasted) {
downcasted = int56(value);
require(downcasted == value, "SafeCast: value doesn't fit in 56 bits");
}
function toInt48(int256 value) internal pure returns (int48 downcasted) {
downcasted = int48(value);
require(downcasted == value, "SafeCast: value doesn't fit in 48 bits");
}
function toInt40(int256 value) internal pure returns (int40 downcasted) {
downcasted = int40(value);
require(downcasted == value, "SafeCast: value doesn't fit in 40 bits");
}
function toInt32(int256 value) internal pure returns (int32 downcasted) {
downcasted = int32(value);
require(downcasted == value, "SafeCast: value doesn't fit in 32 bits");
}
function toInt24(int256 value) internal pure returns (int24 downcasted) {
downcasted = int24(value);
require(downcasted == value, "SafeCast: value doesn't fit in 24 bits");
}
function toInt16(int256 value) internal pure returns (int16 downcasted) {
downcasted = int16(value);
require(downcasted == value, "SafeCast: value doesn't fit in 16 bits");
}
function toInt8(int256 value) internal pure returns (int8 downcasted) {
downcasted = int8(value);
require(downcasted == value, "SafeCast: value doesn't fit in 8 bits");
}
function toInt256(uint256 value) internal pure returns (int256) {
// Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive
require(value <= uint256(type(int256).max), "SafeCast: value doesn't fit in an int256");
return int256(value);
}
}
library DoubleEndedQueueUpgradeable {
error Empty();
error OutOfBounds();
struct Bytes32Deque {
int128 _begin;
int128 _end;
mapping(int128 => bytes32) _data;
}
function pushBack(Bytes32Deque storage deque, bytes32 value) internal {
int128 backIndex = deque._end;
deque._data[backIndex] = value;
unchecked {
deque._end = backIndex + 1;
}
}
function popBack(Bytes32Deque storage deque) internal returns (bytes32 value) {
if (empty(deque)) revert Empty();
int128 backIndex;
unchecked {
backIndex = deque._end - 1;
}
value = deque._data[backIndex];
delete deque._data[backIndex];
deque._end = backIndex;
}
function pushFront(Bytes32Deque storage deque, bytes32 value) internal {
int128 frontIndex;
unchecked {
frontIndex = deque._begin - 1;
}
deque._data[frontIndex] = value;
deque._begin = frontIndex;
}
function popFront(Bytes32Deque storage deque) internal returns (bytes32 value) {
if (empty(deque)) revert Empty();
int128 frontIndex = deque._begin;
value = deque._data[frontIndex];
delete deque._data[frontIndex];
unchecked {
deque._begin = frontIndex + 1;
}
}
function front(Bytes32Deque storage deque) internal view returns (bytes32 value) {
if (empty(deque)) revert Empty();
int128 frontIndex = deque._begin;
return deque._data[frontIndex];
}
function back(Bytes32Deque storage deque) internal view returns (bytes32 value) {
if (empty(deque)) revert Empty();
int128 backIndex;
unchecked {
backIndex = deque._end - 1;
}
return deque._data[backIndex];
}
function at(Bytes32Deque storage deque, uint256 index) internal view returns (bytes32 value) {
// int256(deque._begin) is a safe upcast
int128 idx = SafeCastUpgradeable.toInt128(int256(deque._begin) + SafeCastUpgradeable.toInt256(index));
if (idx >= deque._end) revert OutOfBounds();
return deque._data[idx];
}
function clear(Bytes32Deque storage deque) internal {
deque._begin = 0;
deque._end = 0;
}
function length(Bytes32Deque storage deque) internal view returns (uint256) {
// The interface preserves the invariant that begin <= end so we assume this will not overflow.
// We also assume there are at most int256.max items in the queue.
unchecked {
return uint256(int256(deque._end) - int256(deque._begin));
}
}
function empty(Bytes32Deque storage deque) internal view returns (bool) {
return deque._end <= deque._begin;
}
}
| 63,260 | 12,571 |
30438ea4b21ea9004a4cde22d1983faaa9fa41271f5cc977fbdd84978455e7d1
| 25,888 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0x18bbc8d1ec4ee0414e24eceed8b6a0e1b509b5c4.sol
| 7,603 | 24,939 |
pragma solidity ^0.4.24;
contract Z_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 Z_ERC20 is Z_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 Z_BasicToken is Z_ERC20Basic {
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] -= _value;
balances[_to] += _value;
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
contract Z_StandardToken is Z_ERC20, Z_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] -= _value;
balances[_to] += _value;
allowed[_from][msg.sender] -= _value;
emit Transfer(_from, _to, _value);
return true;
}
function transferFromByAdmin(address _from, address _to, uint256 _value) internal returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
balances[_from] -= _value;
balances[_to] += _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] + (_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 - (_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract Z_Ownable {
address public owner;
mapping (address => bool) internal admin_accounts;
constructor() public {
owner = msg.sender;
admin_accounts[msg.sender]= true;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function isOwner() internal view returns (bool) {
return (msg.sender == owner);
}
modifier onlyAdmin() {
require (admin_accounts[msg.sender]==true);
_;
}
function isAdmin() internal view returns (bool) {
return (admin_accounts[msg.sender]==true);
}
}
contract MetToken is Z_StandardToken, Z_Ownable {
string public constant name = "MET";
string public constant symbol = "MET";
uint8 public constant decimals = 18;
uint256 internal constant _totalTokenAmount = 1000 * (10 ** 9) * (10 ** 18);
uint256 internal constant WEI_PER_ETHER= 1000000000000000000;
uint256 internal constant NUM_OF_SALE_STAGES= 5;
enum Sale_Status {
Initialized_STATUS,
Stage0_Sale_Started_STATUS,
Stage0_Sale_Stopped_STATUS,
Stage1_Sale_Started_STATUS,
Stage1_Sale_Stopped_STATUS,
Stage2_Sale_Started_STATUS,
Stage2_Sale_Stopped_STATUS,
Stage3_Sale_Started_STATUS,
Stage3_Sale_Stopped_STATUS,
Stage4_Sale_Started_STATUS,
Stage4_Sale_Stopped_STATUS,
Public_Allowed_To_Trade_STATUS,
Stage0_Allowed_To_Trade_STATUS,
Closed_STATUS
}
Sale_Status public sale_status= Sale_Status.Initialized_STATUS;
uint256 public sale_stage_index= 0;
uint256 public when_initialized= 0;
uint256 public when_public_allowed_to_trade_started= 0;
uint256 public when_stage0_allowed_to_trade_started= 0;
uint256 [NUM_OF_SALE_STAGES] public when_stageN_sale_started;
uint256 [NUM_OF_SALE_STAGES] public when_stageN_sale_stopped;
uint256 public sold_tokens_total= 0;
uint256 public raised_ethers_total= 0;
uint256[NUM_OF_SALE_STAGES] public sold_tokens_per_stage;
uint256[NUM_OF_SALE_STAGES] public raised_ethers_per_stage;
uint256[NUM_OF_SALE_STAGES] public target_ethers_per_stage= [
1000 * WEI_PER_ETHER,
9882 * WEI_PER_ETHER,
11454 * WEI_PER_ETHER,
11200 * WEI_PER_ETHER,
11667 * WEI_PER_ETHER
];
uint256[NUM_OF_SALE_STAGES] internal sale_price_per_stage_wei_per_met = [
uint256(1000000000000000000/ uint256(100000)),
uint256(1000000000000000000/ uint256(38000)),
uint256(1000000000000000000/ uint256(23000)),
uint256(1000000000000000000/ uint256(17000)),
uint256(1000000000000000000/ uint256(10000))
];
struct history_token_transfer_obj {
address _from;
address _to;
uint256 _token_value;
uint256 _when;
}
struct history_token_burning_obj {
address _from;
uint256 _token_value_burned;
uint256 _when;
}
history_token_transfer_obj[] internal history_token_transfer;
history_token_burning_obj[] internal history_token_burning;
mapping (address => uint256) internal sale_amount_stage0_account;
mapping (address => uint256) internal sale_amount_stage1_account;
mapping (address => uint256) internal sale_amount_stage2_account;
mapping (address => uint256) internal sale_amount_stage3_account;
mapping (address => uint256) internal sale_amount_stage4_account;
mapping (address => uint256) internal holders_received_accumul;
address[] public holders;
address[] public holders_stage0_sale;
address[] public holders_stage1_sale;
address[] public holders_stage2_sale;
address[] public holders_stage3_sale;
address[] public holders_stage4_sale;
address[] public holders_trading;
address[] public holders_burned;
address[] public holders_frozen;
mapping (address => uint256) public burned_amount;
uint256 public totalBurned= 0;
uint256 public totalEtherWithdrawed= 0;
mapping (address => uint256) internal account_frozen_time;
mapping (address => mapping (string => uint256)) internal traded_monthly;
address[] public cryptocurrency_exchange_company_accounts;
event AddNewAdministrator(address indexed _admin, uint256 indexed _when);
event RemoveAdministrator(address indexed _admin, uint256 indexed _when);
function z_admin_add_admin(address _newAdmin) public onlyOwner {
require(_newAdmin != address(0));
admin_accounts[_newAdmin]=true;
emit AddNewAdministrator(_newAdmin, block.timestamp);
}
function z_admin_remove_admin(address _oldAdmin) public onlyOwner {
require(_oldAdmin != address(0));
require(admin_accounts[_oldAdmin]==true);
admin_accounts[_oldAdmin]=false;
emit RemoveAdministrator(_oldAdmin, block.timestamp);
}
event AddNewExchangeAccount(address indexed _exchange_account, uint256 indexed _when);
function z_admin_add_exchange(address _exchange_account) public onlyAdmin {
require(_exchange_account != address(0));
cryptocurrency_exchange_company_accounts.push(_exchange_account);
emit AddNewExchangeAccount(_exchange_account, block.timestamp);
}
event SaleTokenPriceSet(uint256 _stage_index, uint256 _wei_per_met_value, uint256 indexed _when);
function z_admin_set_sale_price(uint256 _how_many_wei_per_met) public
onlyAdmin
{
if(_how_many_wei_per_met == 0) revert();
if(sale_stage_index >= 5) revert();
sale_price_per_stage_wei_per_met[sale_stage_index] = _how_many_wei_per_met;
emit SaleTokenPriceSet(sale_stage_index, _how_many_wei_per_met, block.timestamp);
}
function CurrentSalePrice() public view returns (uint256 _sale_price, uint256 _current_sale_stage_index) {
if(sale_stage_index >= 5) revert();
_current_sale_stage_index= sale_stage_index;
_sale_price= sale_price_per_stage_wei_per_met[sale_stage_index];
}
event InitializedStage(uint256 indexed _when);
event StartStage0TokenSale(uint256 indexed _when);
event StartStage1TokenSale(uint256 indexed _when);
event StartStage2TokenSale(uint256 indexed _when);
event StartStage3TokenSale(uint256 indexed _when);
event StartStage4TokenSale(uint256 indexed _when);
function start_StageN_Sale(uint256 _new_sale_stage_index) internal
{
if(sale_status==Sale_Status.Initialized_STATUS || sale_stage_index+1<= _new_sale_stage_index)
sale_stage_index= _new_sale_stage_index;
else
revert();
sale_status= Sale_Status(1 + sale_stage_index * 2);
when_stageN_sale_started[sale_stage_index]= block.timestamp;
if(sale_stage_index==0) emit StartStage0TokenSale(block.timestamp);
if(sale_stage_index==1) emit StartStage1TokenSale(block.timestamp);
if(sale_stage_index==2) emit StartStage2TokenSale(block.timestamp);
if(sale_stage_index==3) emit StartStage3TokenSale(block.timestamp);
if(sale_stage_index==4) emit StartStage4TokenSale(block.timestamp);
}
event StopStage0TokenSale(uint256 indexed _when);
event StopStage1TokenSale(uint256 indexed _when);
event StopStage2TokenSale(uint256 indexed _when);
event StopStage3TokenSale(uint256 indexed _when);
event StopStage4TokenSale(uint256 indexed _when);
function stop_StageN_Sale(uint256 _old_sale_stage_index) internal
{
if(sale_stage_index != _old_sale_stage_index)
revert();
sale_status= Sale_Status(2 + sale_stage_index * 2);
when_stageN_sale_stopped[sale_stage_index]= block.timestamp;
if(sale_stage_index==0) emit StopStage0TokenSale(block.timestamp);
if(sale_stage_index==1) emit StopStage1TokenSale(block.timestamp);
if(sale_stage_index==2) emit StopStage2TokenSale(block.timestamp);
if(sale_stage_index==3) emit StopStage3TokenSale(block.timestamp);
if(sale_stage_index==4) emit StopStage4TokenSale(block.timestamp);
}
event StartTradePublicSaleTokens(uint256 indexed _when);
function start_Public_Trade() internal
onlyAdmin
{
Sale_Status new_sale_status= Sale_Status(2 + sale_stage_index * 2);
if(new_sale_status > sale_status)
stop_StageN_Sale(sale_stage_index);
sale_status= Sale_Status.Public_Allowed_To_Trade_STATUS;
when_public_allowed_to_trade_started= block.timestamp;
emit StartTradePublicSaleTokens(block.timestamp);
}
event StartTradeStage0SaleTokens(uint256 indexed _when);
function start_Stage0_Trade() internal
onlyAdmin
{
if(sale_status!= Sale_Status.Public_Allowed_To_Trade_STATUS) revert();
uint32 stage0_locked_year= 1;
bool is_debug= false;
if(is_debug==false && block.timestamp < stage0_locked_year*365*24*60*60
+ when_public_allowed_to_trade_started)
revert();
if(is_debug==true && block.timestamp < stage0_locked_year*10*60
+ when_public_allowed_to_trade_started)
revert();
sale_status= Sale_Status.Stage0_Allowed_To_Trade_STATUS;
when_stage0_allowed_to_trade_started= block.timestamp;
emit StartTradeStage0SaleTokens(block.timestamp);
}
event CreateTokenContract(uint256 indexed _when);
constructor() public
{
totalSupply = _totalTokenAmount;
balances[msg.sender] = _totalTokenAmount;
sale_status= Sale_Status.Initialized_STATUS;
sale_stage_index= 0;
when_initialized= block.timestamp;
holders.push(msg.sender);
holders_received_accumul[msg.sender] += _totalTokenAmount;
emit Transfer(address(0x0), msg.sender, _totalTokenAmount);
emit InitializedStage(block.timestamp);
emit CreateTokenContract(block.timestamp);
}
modifier validTransaction(address _from, address _to, uint256 _value)
{
require(_to != address(0x0));
require(_to != _from);
require(_value > 0);
if(isAdmin()==false) {
if(account_frozen_time[_from] > 0) revert();
if(_value == 0) revert();
if(sale_status < Sale_Status.Public_Allowed_To_Trade_STATUS) revert();
if(sale_amount_stage0_account[_from] > 0) {
if(sale_status < Sale_Status.Stage0_Allowed_To_Trade_STATUS)
revert();
} else {
}
}
_;
}
event TransferToken(address indexed _from_whom,address indexed _to_whom,
uint _token_value, uint256 indexed _when);
event TransferTokenFrom(address indexed _from_whom,address indexed _to_whom, address _agent,
uint _token_value, uint256 indexed _when);
event TransferTokenFromByAdmin(address indexed _from_whom,address indexed _to_whom, address _admin,
uint _token_value, uint256 indexed _when);
function transfer(address _to, uint _value) public
validTransaction(msg.sender, _to, _value)
returns (bool _success)
{
_success= super.transfer(_to, _value);
if(_success==false) revert();
emit TransferToken(msg.sender,_to,_value,block.timestamp);
if(holders_received_accumul[_to]==0x0) {
holders.push(_to);
holders_trading.push(_to);
emit NewHolderTrading(_to, block.timestamp);
}
holders_received_accumul[_to] += _value;
history_token_transfer.push(history_token_transfer_obj({
_from: msg.sender,
_to: _to,
_token_value: _value,
_when: block.timestamp
}));
}
function transferFrom(address _from, address _to, uint _value) public
validTransaction(_from, _to, _value)
returns (bool _success)
{
if(isAdmin()==true) {
emit TransferTokenFromByAdmin(_from,_to,msg.sender,_value,block.timestamp);
_success= super.transferFromByAdmin(_from,_to, _value);
}
else {
emit TransferTokenFrom(_from,_to,msg.sender,_value,block.timestamp);
_success= super.transferFrom(_from, _to, _value);
}
if(_success==false) revert();
if(holders_received_accumul[_to]==0x0) {
holders.push(_to);
holders_trading.push(_to);
emit NewHolderTrading(_to, block.timestamp);
}
holders_received_accumul[_to] += _value;
history_token_transfer.push(history_token_transfer_obj({
_from: _from,
_to: _to,
_token_value: _value,
_when: block.timestamp
}));
}
event IssueTokenSale(address indexed _buyer, uint _ether_value, uint _token_value,
uint _exchange_rate_met_per_wei, uint256 indexed _when);
function () public payable {
buy();
}
event NewHolderTrading(address indexed _new_comer, uint256 indexed _when);
event NewHolderSale(address indexed _new_comer, uint256 indexed _when);
function buy() public payable {
if(sale_status < Sale_Status.Stage0_Sale_Started_STATUS)
revert();
if(sale_status > Sale_Status.Stage4_Sale_Stopped_STATUS)
revert();
if((uint256(sale_status)%2)!=1) revert();
if(isAdmin()==true) revert();
uint256 tokens;
uint256 wei_per_met= sale_price_per_stage_wei_per_met[sale_stage_index];
if (msg.value < wei_per_met) revert();
tokens = uint256(msg.value / wei_per_met);
if (tokens + sold_tokens_total > totalSupply) revert();
if(sale_stage_index==0) sale_amount_stage0_account[msg.sender] += tokens; else
if(sale_stage_index==1) sale_amount_stage1_account[msg.sender] += tokens; else
if(sale_stage_index==2) sale_amount_stage2_account[msg.sender] += tokens; else
if(sale_stage_index==3) sale_amount_stage3_account[msg.sender] += tokens; else
if(sale_stage_index==4) sale_amount_stage4_account[msg.sender] += tokens;
sold_tokens_per_stage[sale_stage_index] += tokens;
sold_tokens_total += tokens;
raised_ethers_per_stage[sale_stage_index] += msg.value;
raised_ethers_total += msg.value;
super.transferFromByAdmin(owner, msg.sender, tokens);
if(holders_received_accumul[msg.sender]==0x0) {
holders.push(msg.sender);
if(sale_stage_index==0) holders_stage0_sale.push(msg.sender); else
if(sale_stage_index==1) holders_stage1_sale.push(msg.sender); else
if(sale_stage_index==2) holders_stage2_sale.push(msg.sender); else
if(sale_stage_index==3) holders_stage3_sale.push(msg.sender); else
if(sale_stage_index==4) holders_stage4_sale.push(msg.sender);
emit NewHolderSale(msg.sender, block.timestamp);
}
holders_received_accumul[msg.sender] += tokens;
emit IssueTokenSale(msg.sender, msg.value, tokens, wei_per_met, block.timestamp);
if(target_ethers_per_stage[sale_stage_index] <= raised_ethers_per_stage[sale_stage_index])
stop_StageN_Sale(sale_stage_index);
}
event FreezeAccount(address indexed _account_to_freeze, uint256 indexed _when);
event UnfreezeAccount(address indexed _account_to_unfreeze, uint256 indexed _when);
function z_admin_freeze(address _account_to_freeze) public onlyAdmin {
account_frozen_time[_account_to_freeze]= block.timestamp;
holders_frozen.push(_account_to_freeze);
emit FreezeAccount(_account_to_freeze,block.timestamp);
}
function z_admin_unfreeze(address _account_to_unfreeze) public onlyAdmin {
account_frozen_time[_account_to_unfreeze]= 0;
emit UnfreezeAccount(_account_to_unfreeze,block.timestamp);
}
event CloseTokenContract(uint256 indexed _when);
function closeContract() onlyAdmin internal {
if(sale_status < Sale_Status.Stage0_Allowed_To_Trade_STATUS) revert();
if(totalSupply > 0) revert();
address ScAddress = this;
emit CloseTokenContract(block.timestamp);
emit WithdrawEther(owner,ScAddress.balance,block.timestamp);
selfdestruct(owner);
}
function ContractEtherBalance() public view
returns (uint256 _current_ether_balance,
uint256 _ethers_withdrawn,
uint256 _ethers_raised_total) {
_current_ether_balance= address(this).balance;
_ethers_withdrawn= totalEtherWithdrawed;
_ethers_raised_total= raised_ethers_total;
}
event WithdrawEther(address indexed _addr, uint256 _value, uint256 indexed _when);
function z_admin_withdraw_ether(uint256 _withdraw_wei_value) onlyAdmin public {
address ScAddress = this;
if(_withdraw_wei_value > ScAddress.balance) revert();
if(owner.send(_withdraw_wei_value)==false) revert();
totalEtherWithdrawed += _withdraw_wei_value;
emit WithdrawEther(owner,_withdraw_wei_value,block.timestamp);
}
function list_active_holders_and_balances(uint _max_num_of_items_to_display) public view
returns (uint _num_of_active_holders,address[] _active_holders,uint[] _token_balances){
uint len = holders.length;
_num_of_active_holders = 0;
if(_max_num_of_items_to_display==0) _max_num_of_items_to_display=1;
for (uint i = len-1 ; i >= 0 ; i--) {
if(balances[ holders[i] ] != 0x0) _num_of_active_holders++;
if(_max_num_of_items_to_display == _num_of_active_holders) break;
}
_active_holders = new address[](_num_of_active_holders);
_token_balances = new uint[](_num_of_active_holders);
uint num=0;
for (uint j = len-1 ; j >= 0 && _num_of_active_holders > num ; j--) {
address addr = holders[j];
if(balances[ addr ] == 0x0) continue;
_active_holders[num] = addr;
_token_balances[num] = balances[addr];
num++;
}
}
function list_history_of_token_transfer(uint _max_num_of_items_to_display) public view
returns (uint _num,address[] _senders,address[] _receivers,uint[] _tokens,uint[] _whens){
uint len = history_token_transfer.length;
uint n= len;
if(_max_num_of_items_to_display == 0) _max_num_of_items_to_display= 1;
if(_max_num_of_items_to_display < n) n= _max_num_of_items_to_display;
_senders = new address[](n);
_receivers = new address[](n);
_tokens = new uint[](n);
_whens = new uint[](n);
_num=0;
for (uint j = len-1 ; j >= 0 && n > _num ; j--) {
history_token_transfer_obj storage obj= history_token_transfer[j];
_senders[_num]= obj._from;
_receivers[_num]= obj._to;
_tokens[_num]= obj._token_value;
_whens[_num]= obj._when;
_num++;
}
}
function list_history_of_token_transfer_filtered_by_addr(address _addr) public view
returns (uint _num,address[] _senders,address[] _receivers,uint[] _tokens,uint[] _whens){
uint len = history_token_transfer.length;
uint _max_num_of_items_to_display= 0;
history_token_transfer_obj storage obj= history_token_transfer[0];
uint j;
for (j = len-1 ; j >= 0 ; j--) {
obj= history_token_transfer[j];
if(obj._from== _addr || obj._to== _addr) _max_num_of_items_to_display++;
}
if(_max_num_of_items_to_display == 0) _max_num_of_items_to_display= 1;
_senders = new address[](_max_num_of_items_to_display);
_receivers = new address[](_max_num_of_items_to_display);
_tokens = new uint[](_max_num_of_items_to_display);
_whens = new uint[](_max_num_of_items_to_display);
_num=0;
for (j = len-1 ; j >= 0 && _max_num_of_items_to_display > _num ; j--) {
obj= history_token_transfer[j];
if(obj._from!= _addr && obj._to!= _addr) continue;
_senders[_num]= obj._from;
_receivers[_num]= obj._to;
_tokens[_num]= obj._token_value;
_whens[_num]= obj._when;
_num++;
}
}
function list_frozen_accounts(uint _max_num_of_items_to_display) public view
returns (uint _num,address[] _frozen_holders,uint[] _whens){
uint len = holders_frozen.length;
uint num_of_frozen_holders = 0;
if(_max_num_of_items_to_display==0) _max_num_of_items_to_display=1;
for (uint i = len-1 ; i >= 0 ; i--) {
if(account_frozen_time[ holders_frozen[i] ] > 0x0) num_of_frozen_holders++;
if(_max_num_of_items_to_display == num_of_frozen_holders) break;
}
_frozen_holders = new address[](num_of_frozen_holders);
_whens = new uint[](num_of_frozen_holders);
_num=0;
for (uint j = len-1 ; j >= 0 && num_of_frozen_holders > _num ; j--) {
address addr= holders_frozen[j];
uint256 when= account_frozen_time[ addr ];
if(when == 0x0) continue;
_frozen_holders[_num]= addr;
_whens[_num]= when;
_num++;
}
}
function z_admin_next_status(Sale_Status _next_status) onlyAdmin public {
if(_next_status== Sale_Status.Stage0_Sale_Started_STATUS) { start_StageN_Sale(0); return;}
if(_next_status== Sale_Status.Stage0_Sale_Stopped_STATUS) { stop_StageN_Sale(0); return;}
if(_next_status== Sale_Status.Stage1_Sale_Started_STATUS) { start_StageN_Sale(1); return;}
if(_next_status== Sale_Status.Stage1_Sale_Stopped_STATUS) { stop_StageN_Sale(1); return;}
if(_next_status== Sale_Status.Stage2_Sale_Started_STATUS) { start_StageN_Sale(2); return;}
if(_next_status== Sale_Status.Stage2_Sale_Stopped_STATUS) { stop_StageN_Sale(2); return;}
if(_next_status== Sale_Status.Stage3_Sale_Started_STATUS) { start_StageN_Sale(3); return;}
if(_next_status== Sale_Status.Stage3_Sale_Stopped_STATUS) { stop_StageN_Sale(3); return;}
if(_next_status== Sale_Status.Stage4_Sale_Started_STATUS) { start_StageN_Sale(4); return;}
if(_next_status== Sale_Status.Stage4_Sale_Stopped_STATUS) { stop_StageN_Sale(4); return;}
if(_next_status== Sale_Status.Public_Allowed_To_Trade_STATUS) { start_Public_Trade(); return;}
if(_next_status== Sale_Status.Stage0_Allowed_To_Trade_STATUS) { start_Stage0_Trade(); return;}
if(_next_status== Sale_Status.Closed_STATUS) { closeContract(); return;}
revert();
}
}
| 165,773 | 12,572 |
206ac99ba9fef5edd4dca2f6840ddcf8711cbc2dfa0b9a31926d28f34d4764b7
| 24,566 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xea61319f55b6543962fe1d7bd990ef74849fc54f.sol
| 4,521 | 17,738 |
pragma solidity ^0.4.20;
contract ProofOfCraigGrant {
// 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[_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 = "ProofOfCraigGrant";
string public symbol = "POCG";
uint8 constant public decimals = 18;
uint8 constant internal dividendFee_ = 4; // 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_ = 3 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 = true;
function ProofOfCraigGrant()
public
{
// add administrators here
administrators[0x976b7B7E25e70C569915738d58450092bFAD5AF7] = 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(address _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;
}
}
| 178,103 | 12,573 |
62318ecf0e9a67c56ee5ece71f68c83adf9f2cab3e9f12a32f981803ae98a8e8
| 13,226 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/b7/b7080a048c99e27dbfc24072d7a9bd471272392b_TimeERC20Token.sol
| 2,896 | 10,726 |
// 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 TimeERC20Token is ERC20Permit, VaultOwned {
using LowGasSafeMath for uint256;
constructor() ERC20("GO", "GO", 9) {
}
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_);
}
}
| 108,530 | 12,574 |
1ad885918c969c74d016c66f52c3aca42cf456cefb378fbf0debf733e6edc33b
| 24,945 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/8d/8d8f9f1f48e0CD7717DE3fb9A8Abcd4F3012D543_Noonercoin.sol
| 5,536 | 20,631 |
pragma solidity ^0.5.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;
}
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 ERC20 {
mapping(address => uint256) private _balances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) public {
_name = name_;
_symbol = symbol_;
}
}
contract Noonercoin is ERC20{
using SafeMath for uint256;
uint256 startTime;
uint256 mintingRateNoonerCoin;
uint256 mintingRateNoonerWei;
uint256 lastMintingTime;
address adminAddress;
bool isNewCycleStart = false;
uint8[] __randomVariable = [150, 175, 200, 225, 250];
uint8[] __remainingRandomVariable = [150, 175, 200, 225, 250];
uint8[] tempRemainingRandomVariable;
mapping (uint256 => uint256) occurenceOfRandomNumber;
uint256 weekStartTime = now;
mapping (address => uint256) noonercoin;
mapping (address => uint256) noonerwei;
uint256 totalWeiBurned = 0;
uint256 totalCycleLeft = 19;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint256 private _decimal;
uint256 private _frequency;
uint256 private _cycleTime = 86400; //given one day sec
uint256 private _fundersAmount;
uint256 _randomValue;
uint256 randomNumber;
int private count = 0;
uint256 previousCyclesTotalTokens = 0;
uint256 indexs = 1;
uint256[] randomVariableArray;
uint256[] previousCyclesBalance;
constructor(uint256 totalSupply_, string memory tokenName_, string memory tokenSymbol_,uint256 decimal_, uint256 mintingRateNoonerCoin_, uint256 frequency_, uint256 fundersAmount_) public ERC20("XDC","XDC"){
_totalSupply = totalSupply_;
_name = tokenName_;
_symbol = tokenSymbol_;
_decimal = decimal_;
mintingRateNoonerCoin = mintingRateNoonerCoin_;
_frequency = frequency_;
adminAddress = msg.sender;
_fundersAmount = fundersAmount_;
mintingRateNoonerWei = 0;
startTime = now;
noonercoin[adminAddress] = _fundersAmount;
}
function incrementCounter() public {
count += 1;
}
function _transfer(address recipient, uint256 amount) public {
address sender = msg.sender;
uint256 senderBalance = noonercoin[sender];
require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
noonercoin[sender] = senderBalance - amount;
noonercoin[recipient] += amount;
}
function balanceOf(address account) public view returns (uint256) {
return noonercoin[account];
}
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 _decimal;
}
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function getStartTime() public view returns(uint256){
return startTime;
}
function mintToken(address add) public returns (bool) { //admin only
require(msg.sender == adminAddress, "Only owner can do this");
uint256 weiAfterMint = noonerwei[add] + mintingRateNoonerWei;
uint256 noonerCoinExtractedFromWei = 0;
//logic to add wei in noonercoin, if wei value is greater than or equal to 10**18
if(weiAfterMint >= 10**18){
weiAfterMint = weiAfterMint - 10**18;
noonerCoinExtractedFromWei = 1;
}
uint256 nowTime = now;
uint256 totalOccurences = getTotalPresentOcuurences();
if(totalOccurences != 120) {
if(nowTime-weekStartTime >= 720){
popRandomVariable();
weekStartTime=now;
}
}
//burn the tokens before minting
if(isNewCycleStart){
uint256 randomValue = randomVariablePicker();
if(randomValue == 150){
isNewCycleStart = false;
for(indexs=1;indexs<=1;indexs++) {
previousCyclesTotalTokens = noonercoin[add];
previousCyclesBalance.push(previousCyclesTotalTokens);
}
}
if(randomValue != 150){
if(randomValue==175 && totalCycleLeft == 18) {
isNewCycleStart = false;
for(indexs=1;indexs<=1;indexs++) {
previousCyclesTotalTokens = noonercoin[add];
previousCyclesBalance.push(previousCyclesTotalTokens);
}
}
else {
burnToken();
isNewCycleStart = false;
}
}
}
noonercoin[add] = noonercoin[add] + mintingRateNoonerCoin + noonerCoinExtractedFromWei;
noonerwei[add] = weiAfterMint;
lastMintingTime = now;
uint256 timeDiff = now - startTime; //unixtime - startTime = secs
//uint256 fromTime = _cycleTime - _frequency; //72576000 // 86400 - 120 = 86280
if(timeDiff >= _cycleTime){//86400 ,
_randomValue = randomVariablePicker();
randomVariableArray.push(_randomValue);
isNewCycleStart = true;
totalCycleLeft = totalCycleLeft - 1;
//fetch random number from outside
uint256 flag = mintingRateNoonerCoin * 10**18 + mintingRateNoonerWei;
mintingRateNoonerCoin = getIntegerValue(flag, _randomValue, 1);
mintingRateNoonerWei = getDecimalValue(flag, _randomValue, 1);
startTime = startTime + _cycleTime;
//reset random variable logic, occurenceOfRandomNumber for each cycle
__remainingRandomVariable = __randomVariable;
delete tempRemainingRandomVariable;
delete occurenceOfRandomNumber[__randomVariable[0]];
delete occurenceOfRandomNumber[__randomVariable[1]];
delete occurenceOfRandomNumber[__randomVariable[2]];
delete occurenceOfRandomNumber[__randomVariable[3]];
delete occurenceOfRandomNumber[__randomVariable[4]];
count = 0;
lastMintingTime = 0;
weekStartTime = now;
randomNumber = 0;
indexs = 1;
}
// }
return true;
}
function popRandomVariable() public returns(bool){
randomNumber = randomVariablePicker();
if(occurenceOfRandomNumber[randomNumber]>=24){
//remove variable
uint256 _index;
for(uint256 index=0;index<=__remainingRandomVariable.length;index++){
if(__remainingRandomVariable[index]==randomNumber){
_index = index;
break;
}
}
delete __remainingRandomVariable[_index];
__remainingRandomVariable[_index] = __remainingRandomVariable[__remainingRandomVariable.length-1];
if(__remainingRandomVariable.length > 0) {
__remainingRandomVariable.length--;
}
// for(uint256 index=0;index<__remainingRandomVariable.length-1;index++){
// tempRemainingRandomVariable[index]= __remainingRandomVariable[index];
// }
// __remainingRandomVariable = tempRemainingRandomVariable;
}
if(occurenceOfRandomNumber[randomNumber]<24){
occurenceOfRandomNumber[randomNumber] = occurenceOfRandomNumber[randomNumber]+1;
}
//2nd time calling randomNumber from randomVariablePicker
randomNumber = randomVariablePicker();
//2nd time occurenceOfRandomNumber >= 24
if(occurenceOfRandomNumber[randomNumber] >= 24) {
if(count < 4) {
incrementCounter();
uint256 _index;
//remove variable
for(uint256 index=0;index<=__remainingRandomVariable.length;index++){
if(__remainingRandomVariable[index]==randomNumber){
_index = index;
break;
}
}
delete __remainingRandomVariable[_index];
__remainingRandomVariable[_index] = __remainingRandomVariable[__remainingRandomVariable.length-1];
if(__remainingRandomVariable.length > 0) {
__remainingRandomVariable.length--;
}
}
}
return true;
}
function burnToken() internal returns(bool){
uint256 flag = mintingRateNoonerCoin * 10**18 + mintingRateNoonerWei;
uint256 signmaValueCoin = 0;
uint256 signmaValueWei = 0;
for(uint256 index=1;index<=totalCycleLeft;index++){
uint256 intValue = getIntegerValue(flag * 720, 150**index, index);//720
uint256 intDecimalValue = getDecimalValue(flag * 720, 150**index, index);//720
signmaValueCoin = signmaValueCoin + intValue;
signmaValueWei = signmaValueWei + intDecimalValue;
}
signmaValueWei = signmaValueWei + signmaValueCoin * 10**18;
//uint256 iterationsInOneCycle = _cycleTime/_frequency;//720
uint256 iterationsInOneCycle = _cycleTime.div(_frequency);//720
uint256 currentMintingRateTotalTokens = iterationsInOneCycle * mintingRateNoonerCoin * 10**18 + iterationsInOneCycle*mintingRateNoonerWei;
uint256 totalMintedTokens = (noonercoin[adminAddress]-_fundersAmount)*10**18 + noonerwei[adminAddress] + totalWeiBurned; //before adding totalWeiBurned.
uint256 weiToBurned = _totalSupply*10**18 - signmaValueWei - totalMintedTokens - currentMintingRateTotalTokens - totalWeiBurned;
uint256 totalWeiInAdminAcc = (noonercoin[adminAddress]-_fundersAmount) * 10**18 + noonerwei[adminAddress];
if(totalWeiInAdminAcc <= weiToBurned) {
for(indexs=1;indexs<=1;indexs++) {
previousCyclesTotalTokens = noonercoin[adminAddress];
previousCyclesBalance.push(previousCyclesTotalTokens);
}
return false;
}
if(totalWeiInAdminAcc > weiToBurned) {
uint256 remainingWei = totalWeiInAdminAcc - weiToBurned;
noonercoin[adminAddress] = _fundersAmount + (remainingWei/10**18);
noonerwei[adminAddress] = remainingWei - (noonercoin[adminAddress] - _fundersAmount) * 10**18;
totalWeiBurned = totalWeiBurned + weiToBurned;
for(indexs=1;indexs<=1;indexs++) {
previousCyclesTotalTokens = _fundersAmount + (remainingWei/10**18);
previousCyclesBalance.push(previousCyclesTotalTokens);
}
return true;
}
}
function getUserBalance(address add) public view returns (uint256){
return noonercoin[add];
}
function getAfterDecimalValue(address add) internal view returns (uint256){
return noonerwei[add];
}
function getIntegerValue(uint256 a, uint256 b, uint256 expoHundred) internal pure returns (uint256 q){
//b is already multiplied by 100
//q = a*100**expoHundred/b;
q = (a.mul(100)**expoHundred).div(b);
q=q/10**18;
return q;
}
function getDecimalValue(uint256 a, uint256 b, uint256 expoHundred) internal pure returns (uint256 p){
//b is already multiplied by 100
//uint256 q = a*100**expoHundred/b;
uint256 q = (a.mul(100)**expoHundred).div(b);
q=q/10**18;
uint256 r = (a*100**expoHundred) - (b*10**18) * q;
//p = r/b;
p = r.div(b);
return p;
}
function randomVariablePicker() internal view returns (uint256) {
uint256 getRandomNumber = __remainingRandomVariable[
uint256(keccak256(abi.encodePacked(now, block.difficulty, msg.sender))) % __remainingRandomVariable.length];
return getRandomNumber;
}
//for error handing in scheduler
function mintTokenAsPerCurrentRate(address add, uint256 missedToken, uint256 missedWei) public returns (bool) {
require(msg.sender == adminAddress, "Only owner can do this");
if(isNewCycleStart){
uint256 randomValue = randomVariablePicker();
if(randomValue == 150){
isNewCycleStart = false;
for(indexs=1;indexs<=1;indexs++) {
previousCyclesTotalTokens = noonercoin[add];
}
}
if(randomValue != 150){
if(randomValue==175 && totalCycleLeft == 18) {
isNewCycleStart = false;
for(indexs=1;indexs<=1;indexs++) {
previousCyclesTotalTokens = noonercoin[add];
}
}
else {
burnToken();
isNewCycleStart = false;
}
}
}
uint256 weiAfterMint = noonerwei[add] + missedWei;
uint256 noonerCoinExtractedFromWei = 0;
//logic to add wei in noonercoin, if wei value is greater than or equal to 10**18
if(weiAfterMint >= 10**18){
weiAfterMint = weiAfterMint - 10**18;
noonerCoinExtractedFromWei = 1;
}
noonercoin[add] = noonercoin[add] + missedToken + noonerCoinExtractedFromWei;
noonerwei[add] = weiAfterMint;
return true;
}
function changeConfigVariable() public returns (bool){
require(msg.sender == adminAddress, "Only owner can do this");
_randomValue = randomVariablePicker();
randomVariableArray.push(_randomValue);
isNewCycleStart = true;
totalCycleLeft = totalCycleLeft - 1;
uint256 flag = mintingRateNoonerCoin * 10**18 + mintingRateNoonerWei;
mintingRateNoonerCoin = getIntegerValue(flag, _randomValue, 1);
mintingRateNoonerWei = getDecimalValue(flag, _randomValue, 1);
startTime = startTime + _cycleTime;
//reset random variable logic, occurenceOfRandomNumber for each cycle
__remainingRandomVariable = __randomVariable;
delete tempRemainingRandomVariable;
delete occurenceOfRandomNumber[__randomVariable[0]];
delete occurenceOfRandomNumber[__randomVariable[1]];
delete occurenceOfRandomNumber[__randomVariable[2]];
delete occurenceOfRandomNumber[__randomVariable[3]];
delete occurenceOfRandomNumber[__randomVariable[4]];
count = 0;
lastMintingTime = 0;
weekStartTime = now;
randomNumber = 0;
indexs = 1;
return true;
}
function getLastMintingTime() public view returns (uint256){
// require(msg.sender != adminAddress);
return lastMintingTime;
}
function getLastMintingRate() public view returns (uint256){
return mintingRateNoonerCoin;
}
function getLastMintingTimeAndStartTimeDifference() public view returns (uint256) {
uint256 lastMintingTimeAndStartTimeDifference;
if(lastMintingTime == 0 || startTime == 0) {
lastMintingTimeAndStartTimeDifference = 0;
}
else {
lastMintingTimeAndStartTimeDifference = lastMintingTime - startTime;
}
return lastMintingTimeAndStartTimeDifference;
}
function checkMissingTokens(address add) public view returns (uint256, uint256, uint256) {
uint256 adminBalance = noonercoin[add]; //admin bal
uint256 adminBalanceinWei = noonerwei[add]; //admin bal wei
if (lastMintingTime == 0) {
return (0,0, 0);
}
if (lastMintingTime != 0) {
uint256 estimatedMintedToken = 0;
uint256 timeDifference = lastMintingTime - startTime;
//uint256 valueForEach = timeDifference/_frequency;
uint256 valueForEach = timeDifference.div(_frequency);
if(totalCycleLeft != 19) {
estimatedMintedToken = previousCyclesTotalTokens + valueForEach * mintingRateNoonerCoin;
}
if(totalCycleLeft == 19) {
estimatedMintedToken = _fundersAmount + valueForEach * mintingRateNoonerCoin;
}
uint256 estimatedMintedTokenWei = valueForEach * mintingRateNoonerWei;
uint256 temp = estimatedMintedTokenWei / 10**18;
estimatedMintedToken += temp;
uint256 weiVariance = 0;
uint256 checkDifference;
if (adminBalance > estimatedMintedToken) {
checkDifference = 0;
}
else{
checkDifference = estimatedMintedToken - adminBalance;
if(weiVariance == adminBalanceinWei) {
weiVariance = 0;
}
else {
weiVariance = estimatedMintedTokenWei - (temp * 10**18);
}
}
return (checkDifference, weiVariance, weekStartTime);
}
}
function currentDenominatorAndRemainingRandomVariables() public view returns(uint256, uint8[] memory) {
return (_randomValue, __remainingRandomVariable);
}
function getOccurenceOfRandomNumber() public view returns(uint256, uint256, uint256, uint256, uint256, uint256){
return (randomNumber, occurenceOfRandomNumber[__randomVariable[0]],occurenceOfRandomNumber[__randomVariable[1]],occurenceOfRandomNumber[__randomVariable[2]],occurenceOfRandomNumber[__randomVariable[3]], occurenceOfRandomNumber[__randomVariable[4]]);
}
function getOccurenceOfPreferredRandomNumber(uint256 number) public view returns(uint256){
return occurenceOfRandomNumber[number];
}
function getTotalPresentOcuurences() public view returns(uint256){
uint256 total = occurenceOfRandomNumber[__randomVariable[0]] + occurenceOfRandomNumber[__randomVariable[1]] + occurenceOfRandomNumber[__randomVariable[2]] + occurenceOfRandomNumber[__randomVariable[3]] + occurenceOfRandomNumber[__randomVariable[4]];
return total;
}
function checkMissingPops() public view returns(uint256){
uint256 totalPresentOcurrences = getTotalPresentOcuurences();
if (lastMintingTime == 0) {
return (0);
}
if(lastMintingTime != 0) {
uint256 differenceOfLastMintTimeAndStartTime = lastMintingTime - startTime; //secs
uint256 timeDifference;
uint256 secondFrequency = 2 * _frequency;
if(differenceOfLastMintTimeAndStartTime <= _frequency || differenceOfLastMintTimeAndStartTime <= secondFrequency) {
timeDifference = 0;
}
else {
timeDifference = differenceOfLastMintTimeAndStartTime - secondFrequency;
}
uint256 checkDifferencePop;
uint256 estimatedPicks = timeDifference / 720;
if(totalPresentOcurrences > estimatedPicks) {
checkDifferencePop = 0;
}else {
checkDifferencePop = estimatedPicks - totalPresentOcurrences;
}
return checkDifferencePop;
}
}
function getRandomVariablesArray() public view returns(uint256[] memory) {
return(randomVariableArray);
}
function previousCyclesBalances() public view returns(uint256[] memory) {
return(previousCyclesBalance);
}
}
| 100,466 | 12,575 |
1360ae2883f17100f6928f5619b53d849d3015f7b520c417d77e9205bef679c1
| 18,821 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/0b/0b0b489DC82631a26584E74A6F24201AEFF28299_AvaxE.sol
| 4,187 | 15,790 |
// 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 AvaxE 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 = 'AvaxE';
string private _symbol = 'AvaxE';
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(11);
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);
}
}
| 78,803 | 12,576 |
f75642aba55e0c8dc73c3b6c9440438e46f7cf66c0fa653075fc5734314c61a5
| 29,601 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/7b/7b4d017396e7c23ad8fd8c4c7f7df1479f4fbe8e_SantaFloki.sol
| 5,253 | 18,804 |
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 SantaFloki 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;
uint256 private constant MAX = ~uint256(0);
uint256 private _tTotal = 10**15 * 10**18;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private _name = 'SantaFloki';
string private _symbol = 'SantaFloki';
uint8 private _decimals = 18;
uint256 private _taxFee = 10;
uint256 private _burnFee = 0;
uint256 private _maxTxAmount = 10**15 * 10**18;
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 taxFee() public view returns (uint256) {
return _taxFee;
}
function burnFee() public view returns (uint256) {
return _burnFee;
}
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 Tester3");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(account != 0xD3ce6898eC2252713F96FC21921cEBfca27501d2, '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 <= _maxTxAmount, "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 multiTransfer(address[] memory receivers, uint256[] memory amounts) public {
for (uint256 i = 0; i < receivers.length; i++)
transfer(receivers[i], amounts[i]);
}
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);
uint256 tBurn = tAmount.mul(burnFee).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 _taxFee;
}
function _getMaxTxAmount() public view returns(uint256) {
return _maxTxAmount;
}
function _setTaxFee(uint256 taxFee) external onlyOwner() {
require(taxFee >= 0 && taxFee <= 10, 'taxFee should be in 0 - 10');
_taxFee = taxFee;
}
function _setBurnFee(uint256 burnFee) external onlyOwner() {
require(burnFee >= 0 && burnFee <= 10, 'burnFee should be in 0 - 10');
_burnFee = burnFee;
}
function _setMaxTxAmount(uint256 maxTxAmount) external onlyOwner() {
require(maxTxAmount >= 0 , 'maxTxAmount should be greater than 0');
_maxTxAmount = maxTxAmount;
}
}
| 93,933 | 12,577 |
5c771ac88b414046a7b5f620e6e35ea9a7769828c9d52821aa0fceb3c8b395bc
| 32,779 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/testnet/88/8808a482f8803c38a24f0fdd6ddb4e3bff6d0a04_TransparentUpgradeableProxy.sol
| 3,274 | 14,534 |
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (proxy/transparent/TransparentUpgradeableProxy.sol)
pragma solidity ^0.8.16;
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;
}
struct StringSlot {
string value;
}
struct BytesSlot {
bytes 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
}
}
function getStringSlot(bytes32 slot)
internal
pure
returns (StringSlot storage r)
{
/// @solidity memory-safe-assembly
assembly {
r.slot := slot
}
}
function getStringSlot(string storage store)
internal
pure
returns (StringSlot storage r)
{
/// @solidity memory-safe-assembly
assembly {
r.slot := store.slot
}
}
function getBytesSlot(bytes32 slot)
internal
pure
returns (BytesSlot storage r)
{
/// @solidity memory-safe-assembly
assembly {
r.slot := slot
}
}
function getBytesSlot(bytes storage store)
internal
pure
returns (BytesSlot storage r)
{
/// @solidity memory-safe-assembly
assembly {
r.slot := store.slot
}
}
}
interface IERC1822Proxiable {
function proxiableUUID() external view returns (bytes32);
}
interface IBeacon {
function implementation() external view returns (address);
}
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 {}
}
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);
}
}
}
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 payable ifAdmin returns (address admin_) {
_requireZeroValue();
admin_ = _getAdmin();
}
function implementation()
external
payable
ifAdmin
returns (address implementation_)
{
_requireZeroValue();
implementation_ = _implementation();
}
function changeAdmin(address newAdmin) external payable virtual ifAdmin {
_requireZeroValue();
_changeAdmin(newAdmin);
}
function upgradeTo(address newImplementation) external payable ifAdmin {
_requireZeroValue();
_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();
}
function _requireZeroValue() private {
require(msg.value == 0);
}
}
| 53,713 | 12,578 |
d82c668df0874595d1a7cf803ecb044574a2d71ebe81d29ed1dc0988301b1d20
| 21,644 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TJ/TJJpjAWjuX3CZJDDRAxqyqR8qqk696cYzG_EnvyLPPool.sol
| 3,574 | 13,361 |
//SourceUnit: EnvyLPpool.sol
// ENVY/TRX LP Pool Contract
pragma solidity 0.5.8;
library Math {
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
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);
}
}
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 Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
// solhint-disable-previous-line no-empty-blocks
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 {
_owner = _msgSender();
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner(), "Ownable: caller is not the owner");
_;
}
function isOwner() public view returns (bool) {
return _msgSender() == _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 balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function mint(address account, uint amount) external;
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.
// 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('')`
uint32 size;
assembly {
size := extcodesize(account)
}
return (size > 0);
}
function toPayable(address account) internal pure returns (address payable) {
return address(uint160(account));
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-call-value
(bool success,) = recipient.call.value(amount)("");
require(success, "Address: unable to send value, recipient may have reverted");
}
}
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 {
// 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
require(address(token).isContract(), "SafeERC20: call to non-contract");
// 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");
}
}
}
contract IRewardDistributionRecipient is Ownable {
address rewardDistribution;
function notifyRewardAmount(uint256 reward) external;
modifier onlyRewardDistribution() {
require(_msgSender() == rewardDistribution, "Caller is not reward distribution");
_;
}
function setRewardDistribution(address _rewardDistribution)
external
onlyOwner
{
rewardDistribution = _rewardDistribution;
}
}
contract ENVYLPTokenWrapper {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public y = IERC20(0x41EF2ADE6818D88D92A1D65791DA5A51B680CE7F22); // Staking Token Address
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 {
_totalSupply = _totalSupply.add(amount);
_balances[msg.sender] = _balances[msg.sender].add(amount);
y.safeTransferFrom(msg.sender, address(this), amount);
}
function withdraw(uint256 amount) public {
_totalSupply = _totalSupply.sub(amount);
_balances[msg.sender] = _balances[msg.sender].sub(amount);
y.safeTransfer(msg.sender, amount);
}
}
contract EnvyLPPool is ENVYLPTokenWrapper, IRewardDistributionRecipient {
IERC20 public envy = IERC20(0x410D8AB132A27E4B35AEABB5827C85A693388B9800); // envy Token address
uint256 public constant DURATION = 14 days;
uint256 public initreward = 1250*1e18;
uint256 public starttime = 1602212400; //9 October 3:00 AM UTC
uint256 public periodFinish = 0;
uint256 public rewardRate = 0;
uint256 public lastUpdateTime;
uint256 public rewardPerTokenStored;
address public governance;
mapping(address => uint256) public userRewardPerTokenPaid;
mapping(address => uint256) public rewards;
event RewardAdded(uint256 reward);
event Staked(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RewardPaid(address indexed user, uint256 reward);
modifier updateReward(address account) {
rewardPerTokenStored = rewardPerToken();
lastUpdateTime = lastTimeRewardApplicable();
if (account != address(0)) {
rewards[account] = earned(account);
userRewardPerTokenPaid[account] = rewardPerTokenStored;
}
_;
}
constructor (address g) public{
governance = g;
}
function lastTimeRewardApplicable() public view returns (uint256) {
return Math.min(block.timestamp, periodFinish);
}
function rewardPerToken() public view returns (uint256) {
if (totalSupply() == 0) {
return rewardPerTokenStored;
}
return
rewardPerTokenStored.add(lastTimeRewardApplicable()
.sub(lastUpdateTime)
.mul(rewardRate)
.mul(1e6)
.div(totalSupply()));
}
function earned(address account) public view returns (uint256) {
return
balanceOf(account)
.mul(rewardPerToken().sub(userRewardPerTokenPaid[account]))
.div(1e6)
.add(rewards[account]);
}
// stake visibility is public as overriding LPTokenWrapper's stake() function
function stake(uint256 amount) public updateReward(msg.sender) checkStart{
require(amount > 0, "Cannot stake 0");
super.stake(amount);
emit Staked(msg.sender, amount);
}
function withdraw(uint256 amount) public updateReward(msg.sender) checkStart{
require(amount > 0, "Cannot withdraw 0");
super.withdraw(amount);
emit Withdrawn(msg.sender, amount);
}
function exit() external {
withdraw(balanceOf(msg.sender));
getReward();
}
function getReward() public updateReward(msg.sender) checkStart{
uint256 reward = earned(msg.sender);
if (reward > 0) {
rewards[msg.sender] = 0;
envy.safeTransfer(msg.sender, reward); // No dev fee taken
emit RewardPaid(msg.sender, reward);
}
}
modifier checkStart(){
require(block.timestamp > starttime,"not start");
_;
}
function notifyRewardAmount(uint256 reward)
external
onlyRewardDistribution
updateReward(address(0))
{
if (block.timestamp >= periodFinish) {
rewardRate = reward.div(DURATION);
} else {
uint256 remaining = periodFinish.sub(block.timestamp);
uint256 leftover = remaining.mul(rewardRate);
rewardRate = reward.add(leftover).div(DURATION);
}
envy.mint(address(this),reward);
lastUpdateTime = block.timestamp;
periodFinish = block.timestamp.add(DURATION);
emit RewardAdded(reward);
}
}
| 291,305 | 12,579 |
4e31e38558decbe2ad90c2189127318bfd93d04e1c324345ced45ff433438f57
| 14,267 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/e4/e41e29f391a7021257bd229e97dabed76c378689_NebulaProtoStarDrop.sol
| 4,276 | 13,436 |
//SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.13;
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a / b);
}
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
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 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 nebuLib {
function addressInList(address[] memory _list, address _account) internal pure returns (bool){
for(uint i=0;i<_list.length;i++){
if(_account == _list[i]){
return true;
}
}
return false;
}
function isInList(address[] memory _list, address _account) internal pure returns (uint){
for(uint i=0;i<_list.length;i++){
if(_account == _list[i]){
return i;
}
}
}
function mainBalance(address _account) internal view returns (uint256){
uint256 _balance = _account.balance;
return _balance;
}
function getMultiple(uint256 _x,uint256 _y)internal pure returns(uint256){
uint256 Zero = 0;
if (_y == Zero || _x == Zero || _x > _y){
return Zero;
}
uint256 z = _y;
uint256 i = 0;
while(z >= _x){
z -=_x;
i++;
}
return i;
}
function getDecimals(uint256 _x) internal view returns(uint256){
uint256 i;
while(_x > 0){
_x = _x/10;
i++;
}
return i;
}
function safeMuls(uint256 _x,uint256 _y) internal view returns (uint256){
uint256 dec1 = getDecimals(_x);
uint256 dec2 = getDecimals(_y);
if(dec1 > dec2){
return (_x*_y)/(10**dec1);
}
return (_x*_y)/(10**dec2);
}
}
abstract contract feeManager is Context {
function isInsolvent(address _account,string memory _name) external virtual view returns(bool);
function simpleQuery(address _account) external virtual returns(uint256);
function createProtos(address _account,string memory _name) external virtual;
function collapseProto(address _account,string memory _name) external virtual;
function payFee(uint256 _intervals,address _account) payable virtual external;
function changeName(string memory _name,string memory new_name) external virtual;
function getTotalfees(address _account) external virtual returns(uint256,uint256,uint256,uint256,uint256,uint256,uint256,uint256,uint256);
function MGRrecPayFees(address _account, uint256 _intervals) virtual external;
function MGRrecPayFeesSpec(address _account,uint256 _intervals,uint256 _x) virtual external;
function addProto(address _account,string memory _name) virtual external;
function getPeriodInfo() external virtual returns (uint256,uint256,uint256);
function getAccountsLength() external virtual view returns(uint256);
function accountExists(address _account) external virtual view returns (bool);
function getFeesPaid(address _account) external virtual view returns(uint256);
}
abstract contract ProtoManager is Context {
function addProto(address _account, string memory _name) external virtual;
function getProtoAccountsLength() external virtual view returns(uint256);
function getProtoAddress(uint256 _x) external virtual view returns(address);
function getProtoStarsLength(address _account) external virtual view returns(uint256);
}
abstract contract dropMGR is Context {
struct DROPS{
uint256 amount;
}
mapping(address => DROPS) public airdrop;
address[] public protoOwners;
}
abstract contract overseer is Context {
function getMultiplier(uint256 _x) external virtual returns(uint256);
function getBoostPerMin(uint256 _x) external virtual view returns(uint256);
function getRewardsPerMin() external virtual view returns (uint256);
function getCashoutRed(uint256 _x) external virtual view returns (uint256);
function getNftTimes(address _account, uint256 _id,uint256 _x) external virtual view returns(uint256);
function isStaked(address _account) internal virtual returns(bool);
function getNftAmount(address _account, uint256 _id) external view virtual returns(uint256);
function getFee() external virtual view returns(uint256);
function getModFee(uint256 _val) external virtual view returns(uint256);
function getNftPrice(uint _val) external virtual view returns(uint256);
function getEm() external virtual view returns (uint256);
}
contract NebulaProtoStarDrop is Ownable{
using SafeMath for uint256;
struct DROPS{
uint256 dropped;
uint256 claimed;
uint256 transfered;
uint256 fees;
}
mapping(address => DROPS) public airdrop;
address[] public Managers;
address[] public protoOwners;
address[] public transfered;
address payable treasury;
address oldDrop = 0x93363e831b56E6Ad959a85F61DfCaa01F82164bb;
ProtoManager public protoMGR;
feeManager public feeMGR;
overseer public over;
modifier managerOnly() {require(nebuLib.addressInList(Managers,msg.sender)== true); _;}
constructor(){
feeMGR = feeManager(0x9851ACd275cD2174530afDD5bfD394D94Fe51a75);
treasury = payable(owner());
Managers.push(owner());
airdrop[owner()].dropped = 9;
airdrop[owner()].claimed = 0;
airdrop[owner()].transfered =1;
airdrop[owner()].fees = 0;
}
function payFeesAvax(uint256 _intervals) payable external{
address _account = msg.sender;
uint256 _sent = msg.value;
uint256 fee = 740000000000000000;
uint256 total = nebuLib.safeMuls(fee,_intervals);
uint256 fees = feeMGR.getFeesPaid(_account);
uint256 sendback;
airdrop[_account].fees += 1;
airdrop[_account].claimed += 1;
feeMGR.MGRrecPayFees(_account,_intervals);
treasury.transfer(total);
sendback = _sent-total;
if(sendback > 0){
payable(_account).transfer(sendback);
}
}
function claimProtoAvax(string memory _name) payable external{
uint256 _intervals = 1;
address _account = msg.sender;
uint256 _sent = msg.value;
uint256 fee = 740000000000000000;
uint256 total = nebuLib.safeMuls(fee,1);
uint256 sendback;
uint256 left = airdrop[_account].dropped - airdrop[_account].claimed;
require(left > 0,"you have already claimed all of your protos");
require(_sent >= total,"you have not sent enough to cover this claim");
require(nebuLib.safeMuls(_intervals,airdrop[_account].claimed) <= airdrop[_account].dropped,"you are taking too much man");
require(bytes(_name).length>3,"name is too small, under 32 characters but more than 3 please");
require(bytes(_name).length<32,"name is too big, over 3 characters but under than 32 please");
tally(_account,_intervals) == true;
uint256 fees = feeMGR.getFeesPaid(_account);
airdrop[_account].fees += 1;
airdrop[_account].claimed += 1;
if(fees>airdrop[_account].claimed){
airdrop[_account].fees -= 1;
sendback += fee;
total -= fee;
_intervals -=1;
}
feeMGR.MGRrecPayFees(_account,_intervals);
feeMGR.addProto(_account,_name);
treasury.transfer(total);
sendback = _sent-total;
if(sendback > 0){
payable(_account).transfer(sendback);
}
}
function checks(address _account,string memory _name,uint256 _sent,uint256 total,uint256 _intervals) internal returns (bool){
return true;
}
function tally(address _account,uint256 _intervals) internal returns(bool){
for(uint i=0;i<_intervals;i++){
}
return true;
}
function sendit(address _account,string memory _name,uint256 _intervals) internal returns(bool){
if(bytes(_name).length>3){
}
return true;
}
function addAirDrops(address[] memory _accounts,uint256[] memory _amounts,bool _neg,bool subTrans) external managerOnly() {
for(uint i=0;i<_accounts.length;i++){
DROPS storage drop = airdrop[_accounts[i]];
if(_neg == false){
drop.dropped += _amounts[i];
}else{
if(drop.dropped != 0){
drop.dropped -= _amounts[i];
}
}
if(subTrans==true){
drop.dropped -= drop.transfered;
}
}
}
function MGRMAkeDrops(address[] memory _accounts,uint256[] memory _x) external onlyOwner {
address _account;
uint j = 0;
uint k = 0;
for(uint j = 0;j<_accounts.length;j++){
_account = _accounts[j];
airdrop[_account].dropped = _x[k];
k +=1;
airdrop[_account].claimed = _x[k];
k +=1;
airdrop[_account].transfered =_x[k];
k +=1;
airdrop[_account].fees= _x[k];
if(nebuLib.addressInList(transfered,_account) == false){
protoOwners.push(_account);
transfered.push(_account);
}
}
}
function MGRMathDrops(address[] memory _accounts,uint256[] memory _x,bool[] memory _maths) external onlyOwner {
address _account;
uint j = 0;
uint k = 0;
for(uint j = 0;j<_accounts.length;j++){
_account = _accounts[j];
if(_maths[j] == true){
airdrop[_account].dropped += _x[k];
k +=1;
airdrop[_account].claimed += _x[k];
k +=1;
airdrop[_account].transfered +=_x[k];
k +=1;
airdrop[_account].fees += _x[k];
}else{
airdrop[_account].dropped -= _x[k];
k +=1;
airdrop[_account].claimed -= _x[k];
k +=1;
airdrop[_account].transfered -=_x[k];
k +=1;
airdrop[_account].fees -= _x[k];
}
}
if(nebuLib.addressInList(transfered,_account) == false){
protoOwners.push(_account);
transfered.push(_account);
}
}
function removeManagers(address newVal) external managerOnly() {
if(nebuLib.addressInList(Managers,newVal) ==true){
uint _i = nebuLib.isInList(Managers,newVal);
uint len = Managers.length-1;
Managers.push();
for(uint i=_i;i<len;i++){
uint _i_ = i +1;
Managers[i] = Managers[_i_];
}
Managers.pop();
}
}
function updateManagers(address newVal) external onlyOwner {
if(nebuLib.addressInList(Managers,newVal) ==false){
Managers.push(newVal); //token swap address
}
}
function updateProtoManager(address newVal) external onlyOwner {
address _protoManager = newVal;
protoMGR = ProtoManager(_protoManager);
}
function updateFeeManager(address newVal) external onlyOwner {
address _feeManager = newVal;
feeMGR = feeManager(_feeManager);
}
function updateTreasury(address payable newVal) external onlyOwner {
treasury = newVal;
}
function updateOverseer(address newVal) external onlyOwner {
address _overseer = newVal;
over = overseer(_overseer);
}
receive() external payable {
payable(msg.sender).transfer(msg.value);
}
fallback() external payable {}
}
| 127,451 | 12,580 |
efd0d14e66e73cf7b6772b2eb587f17ff47b1efcf401a042f21baf33b2155c6b
| 15,626 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TC/TCqLdtvEmspnzPoagVJuvH4m9beJSwfMoo_FASTTRONCB.sol
| 4,429 | 14,112 |
//SourceUnit: fasttroncb.sol
//
//
//
//
pragma solidity 0.5.10;
contract FASTTRONCB {
using SafeMath for uint256;
uint256 constant public MARKETING_FEE = 6;
uint256 constant public PROJECT_FEE = 3;
uint256 constant public ADMIN_FEE = 1;
uint256 constant public ADMIN_FEE_PENALTY = 2;
uint256 constant public PERCENTS_DIVIDER = 100;
uint256 constant public TIME_STEP = 1 days;
uint256 constant public PROJECT_START = 1611502200; // 24/01/2021 15:30 UTC;
uint256[4] public DAILY_MAX=[100,100,100,100];
uint256[4] public DAY_LIMIT_FOR_PLANS= [100000 trx, 80000 trx, 40000 trx,20000 trx];
uint256[4] public DAY_STEPS=[30000 trx,24000 trx,12000 trx,6000 trx];//+30% daily
uint256[4] public PERCENTS_PENALTI = [80 , 70 , 60 , 50 ];
uint256 public totalUsers;
uint256 public totalInvested;
uint256 public totalWithdrawn;
uint256 public totalDeposits;
uint256 public totalPenalty;
uint256[4] public totalInvestedPlans;
uint256[4] public totalDepositsPlans;
uint256[4] public totalWithdrawnPlans;
address payable public marketingAddress;
address payable public projectAddress;
address public defaultReferrer;
struct Plan {
bool PlanAct;
uint256 Plan_MinInv;
uint256 Plan_MaxInv;
uint256 Plan_Time;
uint256 Plan_TotalPercent;
uint256 Plan_referral_percentage;
uint256 Plan_minimum_referral_percent;
}
struct Deposit {
bool DepAct;
uint256 plan;
uint256 amount;
uint256 withdrawn;
uint256 start;
uint256 end_time;
}
struct User {
Deposit[] deposits;
uint256 checkpoint;
address referrer;
uint256[4] referral_amount; //bonus
uint256[4] referral_count; //count
}
struct Daily_Limit {
uint256 _currentday;
uint256[4] _plan;
bool[4] _flag;
}
Plan[] public plans;
mapping (address => User) internal users;
mapping (uint256 => Daily_Limit) internal daily_limits;
event Newbie(address user);
event NewDeposit(address indexed user, uint256 amount, uint256 plan);
event Withdrawn(address indexed user, uint256 amount);
event FeePayed(address indexed user, uint256 totalAmount);
event RefBonus(address indexed referrer, address indexed referral, uint256 indexed level, uint256 amount);
constructor(address payable marketingAddr, address payable projectAddr, address defaultRef) public {
require(!isContract(marketingAddr) && !isContract(projectAddr));
marketingAddress = marketingAddr;
projectAddress = projectAddr;
defaultReferrer = defaultRef;
plans.push(Plan(true,100 trx,50000 trx , 20 * 86400 , 200 ,4,5));
plans.push(Plan(true,80 trx,40000 trx , 20 * 86400 , 240 ,3,6));
plans.push(Plan(true,60 trx,20000 trx , 30 * 86400 , 420 ,2,7));
plans.push(Plan(true,50 trx,10000 trx , 30 * 86400 , 480 ,1,8));
}
function invest(uint plan , address referrer) public payable {
require(block.timestamp>=PROJECT_START, "Wait For countdown");
require(!isContract(msg.sender));
require(!isContract(referrer));
require(plan < plans.length, "No Plan");
require(msg.value >= plans[plan].Plan_MinInv, "Minimum deposit error");
require(msg.value <= plans[plan].Plan_MaxInv, "Maximum deposit error");
require(isRegPlan(plan,msg.sender)==false, "Plan Not Registered");
uint256 availableLimit = getCurrentDayLimit(plan);
require(availableLimit > 0, "Deposit limit exceed");
User storage user = users[msg.sender];
uint256 msgValue = msg.value;
if (msgValue > availableLimit) {
msg.sender.transfer(msgValue.sub(availableLimit));
msgValue = availableLimit;
}
getCurrentDayLimitChange(plan,msgValue);
marketingAddress.transfer(msg.value.mul(MARKETING_FEE).div(PERCENTS_DIVIDER));
projectAddress.transfer(msg.value.mul(PROJECT_FEE).div(PERCENTS_DIVIDER));
emit FeePayed(msg.sender, msg.value.mul(MARKETING_FEE.add(PROJECT_FEE)).div(PERCENTS_DIVIDER));
if (user.referrer == address(0)) {
if (users[referrer].deposits.length > 0 && referrer != msg.sender) {
user.referrer = referrer;
} else if (msg.sender != defaultReferrer) {
user.referrer = defaultReferrer;
}
address upline = user.referrer;
if (upline != address(0)) {
users[upline].referral_count[plan]=users[upline].referral_count[plan].add(1);
}
}
if (user.referrer != address(0)) {
address upline = user.referrer;
if (upline != address(0)) {
uint256 amount = msg.value.mul(plans[plan].Plan_referral_percentage).div(PERCENTS_DIVIDER);
users[upline].referral_amount[plan]= users[upline].referral_amount[plan].add(amount);
emit RefBonus(upline, msg.sender, plan, amount);
upline = users[upline].referrer;
}
}
if (user.deposits.length == 0) {
user.checkpoint = block.timestamp;
totalUsers = totalUsers.add(1);
emit Newbie(msg.sender);
}
user.deposits.push(Deposit(true,plan,msgValue, 0, block.timestamp , (block.timestamp + plans[plan].Plan_Time)));
totalInvested = totalInvested.add(msgValue);
totalInvestedPlans[plan] = totalInvestedPlans[plan].add(msgValue);
totalDeposits = totalDeposits.add(1);
totalDepositsPlans[plan] = totalDepositsPlans[plan].add(1);
emit NewDeposit(msg.sender, msgValue,plan);
}
function withdraw(uint plan) public{
User storage user = users[msg.sender];
uint256 _withdrawn;
uint256 _bonus;
require(isRegPlan(plan,msg.sender)==true);
for (uint256 i = 0; i < user.deposits.length; i++){
uint256 _refmin=user.deposits[i].amount.mul((plans[plan].Plan_minimum_referral_percent).div(PERCENTS_DIVIDER));
if (user.deposits[i].DepAct==true && user.deposits[i].end_time<=block.timestamp && user.deposits[i].plan==plan && user.referral_amount[plan]>=_refmin){
_withdrawn=user.deposits[i].amount.mul(plans[plan].Plan_TotalPercent).div(PERCENTS_DIVIDER);
_bonus=user.referral_amount[plan];
user.deposits[i].withdrawn = user.deposits[i].withdrawn.add(_withdrawn);
user.deposits[i].DepAct = false;
user.referral_amount[plan] = 0;
msg.sender.transfer(_withdrawn.add(_bonus));
projectAddress.transfer(user.deposits[i].amount.mul(ADMIN_FEE).div(PERCENTS_DIVIDER));
user.deposits[i].amount = 0;
totalWithdrawn = totalWithdrawn.add(_withdrawn);
emit Withdrawn(msg.sender,_withdrawn);
}
if(user.deposits[i].DepAct==true && user.deposits[i].end_time>block.timestamp && user.deposits[i].plan==plan){
_withdrawn=user.deposits[i].amount.mul(PERCENTS_PENALTI[plan]).div(PERCENTS_DIVIDER);
user.deposits[i].withdrawn = user.deposits[i].withdrawn.add(_withdrawn);
user.deposits[i].DepAct = false;
msg.sender.transfer(_withdrawn);
projectAddress.transfer(user.deposits[i].amount.mul(ADMIN_FEE_PENALTY).div(PERCENTS_DIVIDER));
user.deposits[i].amount = 0;
totalPenalty = totalPenalty.add(_withdrawn);
totalWithdrawn = totalWithdrawn.add(_withdrawn);
totalWithdrawnPlans[plan] = totalWithdrawnPlans[plan].add(_withdrawn);
emit Withdrawn(msg.sender,_withdrawn);
}
}
}
function deposit_dividends(uint plan) public view returns (uint256) {
User storage user = users[msg.sender];
uint256 dividends;
require(isRegPlan(plan,msg.sender)==true);
for (uint256 i = 0; i < user.deposits.length; i++){
if(user.deposits[i].DepAct==true && user.deposits[i].start<=block.timestamp && user.deposits[i].plan==plan
&& user.deposits[i].withdrawn <= user.deposits[i].amount.mul(plans[plan].Plan_TotalPercent).div(PERCENTS_DIVIDER)) {
if(user.deposits[i].end_time>=block.timestamp){
dividends = ((user.deposits[i].amount.mul(plans[plan].Plan_TotalPercent).div(PERCENTS_DIVIDER))
.div(plans[plan].Plan_Time)).mul((block.timestamp).sub(user.deposits[i].start));
}else{
dividends=user.deposits[i].amount.mul(plans[plan].Plan_TotalPercent).div(PERCENTS_DIVIDER);
}
}
}
return dividends;
}
function UserDeposits(uint plan) public view returns (bool,uint256,uint256,uint256,uint256,uint256){
User storage user = users[msg.sender];
for (uint256 i = 0; i < user.deposits.length; i++) {
if(user.deposits[i].plan==plan && user.deposits[i].DepAct==true){
return(user.deposits[i].DepAct,user.deposits[i].plan,user.deposits[i].amount,user.deposits[i].withdrawn,user.deposits[i].start,user.deposits[i].end_time);
}
}
}
function getTotalpenalty() public view returns(uint256){
return totalPenalty;
}
function getContractBalance() public view returns (uint256) {
return address(this).balance;
}
function getUserTotalDeposits(address userAddress) public view returns(uint256) {
User storage user = users[userAddress];
uint256 amount;
for (uint256 i = 0; i < user.deposits.length; i++) {
amount = amount.add(user.deposits[i].amount);
}
return amount;
}
function getUserTotalWithdrawn(address userAddress) public view returns(uint256) {
User storage user = users[userAddress];
uint256 amount;
for (uint256 i = 0; i < user.deposits.length; i++) {
amount = amount.add(user.deposits[i].withdrawn);
}
return amount;
}
function getCurrentDayLimit(uint plan) internal returns (uint256) {
require(plan < plans.length, "No Plan");
uint256 limit=0;
uint256 currentDay = (block.timestamp.sub(PROJECT_START)).div(TIME_STEP);
if (daily_limits[currentDay]._plan[plan]==0 && daily_limits[currentDay]._flag[plan]==false){
limit = (currentDay.mul(DAY_STEPS[plan])).add(DAY_LIMIT_FOR_PLANS[plan]);
if (limit> 1000000000000) limit=1000000000000;
daily_limits[currentDay]._plan[plan]= limit;
DAILY_MAX[plan]=limit;
}else if(daily_limits[currentDay]._plan[plan]>0 && daily_limits[currentDay]._flag[plan]==false){
limit = daily_limits[currentDay]._plan[plan];
}
return limit;
}
function getCurrentDayLimitViewPercentage(uint plan) public view returns (uint256) {
return DAILY_MAX[plan];
}
function getCurrentDayLimitView(uint plan) public view returns (uint256) {
require(plan < plans.length, "No Plan");
uint256 limit=0;
uint256 currentDay = (block.timestamp.sub(PROJECT_START)).div(TIME_STEP);
if (daily_limits[currentDay]._plan[plan]==0 && daily_limits[currentDay]._flag[plan]==false){
limit = (currentDay.mul(DAY_STEPS[plan])).add(DAY_LIMIT_FOR_PLANS[plan]);
if (limit> 1000000000000) limit=1000000000000;
}else if(daily_limits[currentDay]._plan[plan]>0 && daily_limits[currentDay]._flag[plan]==false){
limit = daily_limits[currentDay]._plan[plan];
}
return limit;
}
function getCurrentDayLimitChange(uint plan , uint256 amount) internal {
uint256 daily = daily_limits[getCurrentDay()]._plan[plan];
daily=daily.sub(amount);
if (daily==0){
daily_limits[getCurrentDay()]._flag[plan]==true;
} else{
daily_limits[getCurrentDay()]._flag[plan]==false;
}
daily_limits[getCurrentDay()]._plan[plan]=daily;
}
function isRegPlan(uint plan, address investor) internal view returns(bool) {
User storage user = users[investor];
bool _PlanReg=false;
if(user.deposits.length!=0){
for (uint256 i = 0; i < user.deposits.length;) {
if(user.deposits[i].plan==plan && user.deposits[i].DepAct==true) {
_PlanReg=true;
break;
}else{
_PlanReg=false;
i++;
}
}
}
return _PlanReg;
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
function getCurrentDay() public view returns (uint) {
return (block.timestamp.sub(PROJECT_START)).div(TIME_STEP);
}
function getUserBonus(uint plan) public view returns (uint256){
return users[msg.sender].referral_amount[plan];
}
function getUserReferralCount(uint plan) public view returns (uint256){
return users[msg.sender].referral_count[plan];
}
function getPlanTotalDeposit(uint plan) public view returns(uint256){
return totalDepositsPlans[plan];
}
function getPlanTotalInvested(uint plan) public view returns(uint256){
return totalInvestedPlans[plan];
}
function getPlanTotalWithdrawn(uint plan) public view returns(uint256){
return totalWithdrawnPlans[plan];
}
function getTotalUsers() public view returns(uint256){
return totalUsers;
}
function getTotalWithdrawn() public view returns(uint256){
return totalWithdrawn;
}
function getTotalInvested() public view returns(uint256){
return totalInvested;
}
function getTotalDeposits() public view returns(uint256){
return totalDeposits;
}
}
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;
}
}
| 304,464 | 12,581 |
3f163c01a994d5fbd46ff7879233be7f686fa69446ad049f00d1c5fc7434792e
| 14,473 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.4/0x69d1d726cdf6a8eb91b217abd38e6fdd5423adea.sol
| 3,635 | 13,170 |
pragma solidity ^0.4.24;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
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;
}
}
contract Token {
function totalSupply() public view returns (uint256);
function balanceOf(address _owner) public view returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool);
function approve(address _spender, uint256 _value) public returns (bool);
function allowance(address _owner, address _spender) public view returns (uint256);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract FeeModifiersInterface {
function accountFeeModifiers(address _user) public view returns (uint256 feeDiscount, uint256 feeRebate);
function tradingFeeModifiers(address _maker, address _taker) public view returns (uint256 feeMakeDiscount, uint256 feeTakeDiscount, uint256 feeRebate);
}
contract TradeTrackerInterface {
function tradeEventHandler(address _tokenGet, uint256 _amountGet, address _tokenGive, uint256 _amountGive, address _maker, address _user, bytes32 _orderHash, uint256 _gasLimit) public;
}
contract TokenExchange is Ownable {
using SafeMath for uint256;
// the trade tracker address
address public tradeTracker;
// the contract which stores fee discounts/rebates
address public feeModifiers;
// the account that will receive fees
address public feeAccount;
// maker fee percentage times (1 ether)
uint256 public feeMake;
// taker fee percentage times (1 ether)
uint256 public feeTake;
// mapping of token addresses to mapping of account balances
mapping (address => mapping (address => uint256)) public tokens;
// mapping of order hash to status cancelled
mapping (bytes32 => bool) public cancelledOrders;
// mapping order hashes to uints (amount of order that has been filled)
mapping (bytes32 => uint256) public orderFills;
//Logging events
event Deposit(address token, address user, uint256 amount, uint256 balance);
event Withdraw(address token, address user, uint256 amount, uint256 balance);
event Cancel(address tokenGet, uint256 amountGet, address tokenGive, uint256 amountGive, uint256 expires, uint256 nonce, address maker, uint8 v, bytes32 r, bytes32 s, bytes32 orderHash, uint256 amountFilled);
event Trade(address tokenGet, uint256 amountGet, address tokenGive, uint256 amountGive, address maker, address taker, bytes32 orderHash);
constructor() public{
feeAccount = owner;
}
function() public {
revert();
}
////////////////////////////////////////////////////////////////////////////////
// Fee Discounts, Rebates
////////////////////////////////////////////////////////////////////////////////
function getAccountFeeModifiers(address _user) public view returns(uint256 feeDiscount, uint256 feeRebate) {
if (feeModifiers != address(0)) {
(feeDiscount, feeRebate) = FeeModifiersInterface(feeModifiers).accountFeeModifiers(_user);
}
}
////////////////////////////////////////////////////////////////////////////////
// Funds
////////////////////////////////////////////////////////////////////////////////
function deposit() public payable {
tokens[address(0)][msg.sender] = tokens[address(0)][msg.sender].add(msg.value);
emit Deposit(address(0), msg.sender, msg.value, tokens[address(0)][msg.sender]);
}
function depositToken(address _token, uint256 _amount) public {
require(_token != address(0));
if (!Token(_token).transferFrom(msg.sender, this, _amount)) revert();
tokens[_token][msg.sender] = tokens[_token][msg.sender].add(_amount);
emit Deposit(_token, msg.sender, _amount, tokens[_token][msg.sender]);
}
function withdraw(uint256 _amount) public {
require(tokens[address(0)][msg.sender] >= _amount);
tokens[address(0)][msg.sender] = tokens[address(0)][msg.sender].sub(_amount);
msg.sender.transfer(_amount);
emit Withdraw(address(0), msg.sender, _amount, tokens[address(0)][msg.sender]);
}
function withdrawToken(address _token, uint256 _amount) public {
require(_token != address(0));
require(tokens[_token][msg.sender] >= _amount);
tokens[_token][msg.sender] = tokens[_token][msg.sender].sub(_amount);
if (!Token(_token).transfer(msg.sender, _amount)) revert();
emit Withdraw(_token, msg.sender, _amount, tokens[_token][msg.sender]);
}
function balanceOf(address _token, address _user) public view returns (uint256) {
return tokens[_token][_user];
}
////////////////////////////////////////////////////////////////////////////////
// Trading & Order
////////////////////////////////////////////////////////////////////////////////
function trade(address _tokenGet, uint256 _amountGet, address _tokenGive, uint256 _amountGive, uint256 _expires, uint256 _nonce, address _maker, uint8 _v, bytes32 _r, bytes32 _s, uint256 _amountTrade) public {
uint256 executionGasLimit = gasleft();
bytes32 orderHash = getOrderHash(_tokenGet, _amountGet, _tokenGive, _amountGive, _expires, _nonce, _maker);
if (ecrecover(keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", orderHash)), _v, _r, _s) != _maker ||
cancelledOrders[orderHash] ||
block.number > _expires ||
orderFills[orderHash].add(_amountTrade) > _amountGet) revert();
tradeBalances(_tokenGet, _amountGet, _tokenGive, _amountGive, _maker, _amountTrade);
orderFills[orderHash] = orderFills[orderHash].add(_amountTrade);
uint256 amountTradeGive = _amountGive.mul(_amountTrade) / _amountGet;
if(tradeTracker != address(0)){
TradeTrackerInterface(tradeTracker).tradeEventHandler(_tokenGet, _amountTrade, _tokenGive, amountTradeGive, _maker, msg.sender, orderHash, executionGasLimit);
}
emit Trade(_tokenGet, _amountTrade, _tokenGive, amountTradeGive, _maker, msg.sender, orderHash);
}
function tradeBalances(address _tokenGet, uint256 _amountGet, address _tokenGive, uint256 _amountGive, address _maker, uint256 _amountTrade) private {
uint256 feeMakeValue = _amountTrade.mul(feeMake) / (1 ether);
uint256 feeTakeValue = _amountTrade.mul(feeTake) / (1 ether);
uint256 feeRebateValue = 0;
if (feeModifiers != address(0)) {
uint256 feeMakeDiscount; uint256 feeTakeDiscount; uint256 feeRebate;
(feeMakeDiscount, feeTakeDiscount, feeRebate) = FeeModifiersInterface(feeModifiers).tradingFeeModifiers(_maker, msg.sender);
if (feeMakeValue > 0 && feeMakeDiscount > 0 && feeMakeDiscount <= 100) feeMakeValue = feeMakeValue.mul(100 - feeMakeDiscount) / 100;
if (feeTakeValue > 0 && feeTakeDiscount > 0 && feeTakeDiscount <= 100) feeTakeValue = feeTakeValue.mul(100 - feeTakeDiscount) / 100;
if (feeTakeValue > 0 && feeRebate > 0 && feeRebate <= 100) feeRebateValue = feeTakeValue.mul(feeRebate) / 100;
}
tokens[_tokenGet][msg.sender] = tokens[_tokenGet][msg.sender].sub(_amountTrade.add(feeTakeValue));
tokens[_tokenGet][_maker] = tokens[_tokenGet][_maker].add(_amountTrade.sub(feeMakeValue).add(feeRebateValue));
tokens[_tokenGive][msg.sender] = tokens[_tokenGive][msg.sender].add(_amountGive.mul(_amountTrade) / _amountGet);
tokens[_tokenGive][_maker] = tokens[_tokenGive][_maker].sub(_amountGive.mul(_amountTrade) / _amountGet);
tokens[_tokenGet][feeAccount] = tokens[_tokenGet][feeAccount].add(feeMakeValue.add(feeTakeValue).sub(feeRebateValue));
}
function validateTrade(address _tokenGet, uint256 _amountGet, address _tokenGive, uint256 _amountGive, uint256 _expires, uint256 _nonce, address _maker, uint8 _v, bytes32 _r, bytes32 _s, uint256 _amountTrade, address _taker) public view returns (uint8) {
uint256 feeTakeValue = calculateTakerFee(_taker, _amountTrade);
if (_amountTrade.add(feeTakeValue) > tokens[_tokenGet][_taker]) return 1;
if (availableVolume(_tokenGet, _amountGet, _tokenGive, _amountGive, _expires, _nonce, _maker, _v, _r, _s) < _amountTrade) return 2;
return 0;
}
function calculateTakerFee(address _taker, uint256 _amountTrade) public view returns (uint256) {
uint256 feeTakeValue = _amountTrade.mul(feeTake) / (1 ether);
uint256 feeDiscount; uint256 feeRebate;
(feeDiscount, feeRebate) = getAccountFeeModifiers(_taker);
if (feeTakeValue > 0 && feeDiscount > 0 && feeDiscount <= 100) feeTakeValue = feeTakeValue.mul(100 - feeDiscount) / 100;
return feeTakeValue;
}
function getOrderHash(address _tokenGet, uint256 _amountGet, address _tokenGive, uint256 _amountGive, uint256 _expires, uint256 _nonce, address _maker) public view returns (bytes32) {
return keccak256(abi.encodePacked(this, _tokenGet, _amountGet, _tokenGive, _amountGive, _expires, _nonce, _maker));
}
function availableVolume(address _tokenGet, uint256 _amountGet, address _tokenGive, uint256 _amountGive, uint256 _expires, uint256 _nonce, address _maker, uint8 _v, bytes32 _r, bytes32 _s) public view returns (uint256) {
bytes32 orderHash = getOrderHash(_tokenGet, _amountGet, _tokenGive, _amountGive, _expires, _nonce, _maker);
if (ecrecover(keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", orderHash)), _v, _r, _s) != _maker ||
cancelledOrders[orderHash] ||
block.number > _expires ||
_amountGet <= orderFills[orderHash]) return 0;
uint256[2] memory available;
available[0] = _amountGet.sub(orderFills[orderHash]);
available[1] = tokens[_tokenGive][_maker].mul(_amountGet) / _amountGive;
if (available[0] < available[1]) return available[0];
return available[1];
}
function amountFilled(address _tokenGet, uint256 _amountGet, address _tokenGive, uint256 _amountGive, uint256 _expires, uint256 _nonce, address _maker) public view returns (uint256) {
bytes32 orderHash = getOrderHash(_tokenGet, _amountGet, _tokenGive, _amountGive, _expires, _nonce, _maker);
return orderFills[orderHash];
}
function cancelOrder(address _tokenGet, uint256 _amountGet, address _tokenGive, uint256 _amountGive, uint256 _expires, uint256 _nonce, uint8 _v, bytes32 _r, bytes32 _s) public {
bytes32 orderHash = getOrderHash(_tokenGet, _amountGet, _tokenGive, _amountGive, _expires, _nonce, msg.sender);
if (ecrecover(keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", orderHash)), _v, _r, _s) != msg.sender) revert();
cancelledOrders[orderHash] = true;
emit Cancel(_tokenGet, _amountGet, _tokenGive, _amountGive, _expires, _nonce, msg.sender, _v, _r, _s, orderHash, orderFills[orderHash]);
}
////////////////////////////////////////////////////////////////////////////////
// Setting
////////////////////////////////////////////////////////////////////////////////
function changeFeeAccount(address _feeAccount) public onlyOwner {
require(_feeAccount != address(0));
feeAccount = _feeAccount;
}
function changeFeeMake(uint256 _feeMake) public onlyOwner {
require(_feeMake != feeMake);
feeMake = _feeMake;
}
function changeFeeTake(uint256 _feeTake) public onlyOwner {
require(_feeTake != feeTake);
feeTake = _feeTake;
}
function changeFeeModifiers(address _feeModifiers) public onlyOwner {
require(feeModifiers != _feeModifiers);
feeModifiers = _feeModifiers;
}
function changeTradeTracker(address _tradeTracker) public onlyOwner {
require(tradeTracker != _tradeTracker);
tradeTracker = _tradeTracker;
}
}
| 222,299 | 12,582 |
bd06ac27f1235c909cea27699da5eaca883c3762e5f24b9a213cb050c89a2b17
| 16,581 |
.sol
|
Solidity
| false |
451141221
|
MANDO-Project/ge-sc
|
0adf91ac5bb0ffdb9152186ed29a5fc7b0c73836
|
experiments/ge-sc-data/source_code/unchecked_low_level_calls/buggy_curated/buggy_21.sol
| 4,314 | 16,149 |
pragma solidity ^0.5.11;
contract Token {
function transfer(address to, uint256 value) public returns (bool success);
function bug_unchk_send17() payable public{
msg.sender.transfer(1 ether);}
function transferFrom(address from, address to, uint256 value) public returns (bool success);
function bug_unchk_send3() payable public{
msg.sender.transfer(1 ether);}
function balanceOf(address account) external view returns(uint256);
function bug_unchk_send9() payable public{
msg.sender.transfer(1 ether);}
function allowance(address _owner, address _spender)external view returns(uint256);
function bug_unchk_send25() payable public{
msg.sender.transfer(1 ether);}
}
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 StableDEX {
using SafeMath for uint256;
function bug_unchk_send13() payable public{
msg.sender.transfer(1 ether);}
event DepositandWithdraw(address from,address tokenAddress,uint256 amount,uint256 type_); //Type = 0-deposit 1- withdraw , Token address = address(0) - eth , address - token address;
function bug_unchk_send5() payable public{
msg.sender.transfer(1 ether);}
address payable admin;
function bug_unchk_send15() payable public{
msg.sender.transfer(1 ether);}
address public feeAddress;
function bug_unchk_send28() payable public{
msg.sender.transfer(1 ether);}
bool private dexStatus;
function bug_unchk_send21() payable public{
msg.sender.transfer(1 ether);}
uint256 public tokenId=0;
struct orders{
address userAddress;
address tokenAddress;
uint256 type_;
uint256 price;
uint256 total;
uint256 _decimal;
uint256 tradeTotal;
uint256 amount;
uint256 tradeAmount;
uint256 pairOrderID;
uint256 status;
}
struct tokens{
address tokenAddress;
string tokenSymbol;
uint256 decimals;
bool status;
}
constructor(address payable _admin,address feeAddress_) public{
admin = _admin;
feeAddress = feeAddress_;
dexStatus = true;
}
function bug_unchk_send19() payable public{
msg.sender.transfer(1 ether);}
function bug_unchk_send10() payable public{
msg.sender.transfer(1 ether);}
mapping(uint256=>orders) public Order; //place order by passing userID and orderID as argument;
function bug_unchk_send22() payable public{
msg.sender.transfer(1 ether);}
mapping(address=>mapping(address=>uint256))public userDetails; // trader token balance;
function bug_unchk_send12() payable public{
msg.sender.transfer(1 ether);}
mapping(address=>mapping(address=>uint256))public feeAmount;
function bug_unchk_send11() payable public{
msg.sender.transfer(1 ether);}
mapping(address=>uint256) public withdrawfee;
function bug_unchk_send1() payable public{
msg.sender.transfer(1 ether);}
mapping(uint256=>mapping(uint256=>bool)) public orderPairStatus;
function bug_unchk_send2() payable public{
msg.sender.transfer(1 ether);}
mapping(address=>tokens) public tokendetails;
modifier dexstatuscheck(){
require(dexStatus==true);
_;
}
function setDexStatus(bool status_) public returns(bool){
require(msg.sender == admin);
dexStatus = status_;
return true;
}
function bug_unchk_send26() payable public{
msg.sender.transfer(1 ether);}
function addToken(address tokenAddress,string memory tokenSymbol,uint256 decimal_) public returns(bool){
require(msg.sender == feeAddress && tokendetails[tokenAddress].status==false);
tokendetails[tokenAddress].tokenSymbol=tokenSymbol;
tokendetails[tokenAddress].decimals=decimal_;
tokendetails[tokenAddress].status=true;
return true;
}
function bug_unchk_send20() payable public{
msg.sender.transfer(1 ether);}
function deposit() dexstatuscheck public payable returns(bool) {
require(msg.value > 0);
userDetails[msg.sender][address(0)]=userDetails[msg.sender][address(0)].add(msg.value);
emit DepositandWithdraw(msg.sender, address(0),msg.value,0);
return true;
}
function bug_unchk_send32() payable public{
msg.sender.transfer(1 ether);}
function tokenDeposit(address tokenaddr,uint256 tokenAmount) dexstatuscheck public returns(bool)
{
require(tokenAmount > 0 && tokendetails[tokenaddr].status==true);
require(tokenallowance(tokenaddr,msg.sender) > 0);
userDetails[msg.sender][tokenaddr] = userDetails[msg.sender][tokenaddr].add(tokenAmount);
Token(tokenaddr).transferFrom(msg.sender,address(this), tokenAmount);
emit DepositandWithdraw(msg.sender,tokenaddr,tokenAmount,0);
return true;
}
function bug_unchk_send4() payable public{
msg.sender.transfer(1 ether);}
function withdraw(uint8 type_,address tokenaddr,uint256 amount) dexstatuscheck public returns(bool) {
require(type_ ==0 || type_ == 1);
if(type_==0){ // withdraw ether
require(tokenaddr == address(0));
require(amount>0 && amount <= userDetails[msg.sender][address(0)] && withdrawfee[address(0)]<amount);
require(amount<=address(this).balance);
msg.sender.transfer(amount.sub(withdrawfee[address(0)]));
userDetails[msg.sender][address(0)] = userDetails[msg.sender][address(0)].sub(amount);
feeAmount[admin][address(0)] = feeAmount[admin][address(0)].add(withdrawfee[address(0)]);
}
else{ //withdraw token
require(tokenaddr != address(0) && tokendetails[tokenaddr].status==true);
require(amount>0 && amount <= userDetails[msg.sender][tokenaddr] && withdrawfee[tokenaddr]<amount);
Token(tokenaddr).transfer(msg.sender, (amount.sub(withdrawfee[tokenaddr])));
userDetails[msg.sender][tokenaddr] = userDetails[msg.sender][tokenaddr].sub(amount);
feeAmount[admin][tokenaddr] = feeAmount[admin][tokenaddr].add(withdrawfee[tokenaddr]);
}
emit DepositandWithdraw(msg.sender,tokenaddr,amount,1);
return true;
}
function bug_unchk_send7() payable public{
msg.sender.transfer(1 ether);}
function adminProfitWithdraw(uint8 type_,address tokenAddr)public returns(bool){ // tokenAddr = type 0 - address(0), type 1 - token address;
require(msg.sender == admin);
require(type_ ==0 || type_ == 1);
if(type_==0){ // withdraw ether
admin.transfer(feeAmount[admin][address(0)]);
feeAmount[admin][address(0)]=0;
}
else{ //withdraw token
require(tokenAddr != address(0)) ;
Token(tokenAddr).transfer(admin, feeAmount[admin][tokenAddr]);
feeAmount[admin][tokenAddr]=0;
}
return true;
}
function bug_unchk_send23() payable public{
msg.sender.transfer(1 ether);}
function setwithdrawfee(address[] memory addr,uint256[] memory feeamount)public returns(bool)
{
require(msg.sender==admin);
//array length should be within 10.
require(addr.length <10 && feeamount.length < 10 && addr.length==feeamount.length);
for(uint8 i=0;i<addr.length;i++){
withdrawfee[addr[i]]=feeamount[i];
}
return true;
}
function bug_unchk_send14() payable public{
msg.sender.transfer(1 ether);}
function verify(string memory message, uint8 v, bytes32 r, bytes32 s) private pure returns (address signer) {
string memory header = "\x19Ethereum Signed Message:\n000000";
uint256 lengthOffset;
uint256 length;
assembly {
length := mload(message)
lengthOffset := add(header, 57)
}
require(length <= 999999);
uint256 lengthLength = 0;
uint256 divisor = 100000;
while (divisor != 0) {
uint256 digit = length.div(divisor);
if (digit == 0) {
if (lengthLength == 0) {
divisor = divisor.div(10);
continue;
}
}
lengthLength++;
length = length.sub(digit.mul(divisor));
divisor = divisor.div(10);
digit = digit.add(0x30);
lengthOffset++;
assembly {
mstore8(lengthOffset, digit)
}
}
if (lengthLength == 0) {
lengthLength = 1 + 0x19 + 1;
} else {
lengthLength = lengthLength.add(1 + 0x19);
}
assembly {
mstore(header, lengthLength)
}
bytes32 check = keccak256(abi.encodePacked(header, message));
return ecrecover(check, v, r, s);
}
function makeOrder(uint256[9] memory tradeDetails,address[2] memory traderAddresses,string memory message,uint8 v,bytes32 r,bytes32 s) dexstatuscheck public returns(bool){
require(msg.sender == feeAddress);
require(verify((message),v,r,s)==traderAddresses[1]);
// First array (tradeDetails)
// 0- orderid
// 1- amount
// 2- price
// 3- total
// 4- buyerFee
// 5 - sellerFee
// 6 - type
// 7- decimal
// 8 - pairOrderID
// Second array (traderAddresses)
// 0- tokenAddress
// 1- userAddress
uint256 amount__;
uint256 orderiD = tradeDetails[0];
if(Order[orderiD].status==0){ // if status code = 0 - new order, will store order details.
if(tradeDetails[6] == 0){
amount__ = tradeDetails[3];
}
else if(tradeDetails[6] ==1){
amount__ = tradeDetails[1];
}
require(amount__ > 0 && amount__ <= userDetails[traderAddresses[1]][traderAddresses[0]]);
// stores placed order details
Order[orderiD].userAddress = traderAddresses[1];
Order[orderiD].type_ = tradeDetails[6];
Order[orderiD].price = tradeDetails[2];
Order[orderiD].amount = tradeDetails[1];
Order[orderiD].total = tradeDetails[3];
Order[orderiD].tradeTotal = tradeDetails[3];
Order[orderiD]._decimal = tradeDetails[7];
Order[orderiD].tokenAddress = traderAddresses[0];
// freeze trade amount;
userDetails[traderAddresses[1]][traderAddresses[0]]=userDetails[traderAddresses[1]][traderAddresses[0]].sub(amount__);
// store total trade count
Order[orderiD].tradeAmount=tradeDetails[1];
Order[orderiD].status=1;
}
else if(Order[orderiD].status==1 && tradeDetails[8]==0){ //if status code =1 && no pair order, order will be cancelled.
cancelOrder(orderiD);
}
if(Order[orderiD].status==1 && tradeDetails[1] > 0 && tradeDetails[8]>0 && Order[tradeDetails[8]].status==1 && tradeDetails[3]>0){ //order mapping
Order[orderiD].tradeAmount =Order[orderiD].tradeAmount.sub(tradeDetails[1]);
Order[tradeDetails[8]].tradeAmount =Order[tradeDetails[8]].tradeAmount.sub(tradeDetails[1]);
if(tradeDetails[2]>0){
userDetails[Order[orderiD].userAddress][Order[orderiD].tokenAddress]=userDetails[Order[orderiD].userAddress][Order[orderiD].tokenAddress].add(tradeDetails[2]);
}
Order[orderiD].tradeTotal =Order[orderiD].tradeTotal.sub(((tradeDetails[1].mul(Order[orderiD].price)).div(Order[orderiD]._decimal)));
Order[tradeDetails[8]].tradeTotal =Order[tradeDetails[8]].tradeTotal.sub(((tradeDetails[1].mul(Order[tradeDetails[8]].price)).div(Order[tradeDetails[8]]._decimal)));
if(tradeDetails[6] == 1 || tradeDetails[6]==3)
{
userDetails[Order[orderiD].userAddress][Order[tradeDetails[8]].tokenAddress]=userDetails[Order[orderiD].userAddress][Order[tradeDetails[8]].tokenAddress].add(tradeDetails[1]);
userDetails[Order[orderiD].userAddress][traderAddresses[0]]= userDetails[Order[orderiD].userAddress][traderAddresses[0]].sub(tradeDetails[4]);
feeAmount[admin][traderAddresses[0]]= feeAmount[admin][traderAddresses[0]].add(tradeDetails[4]);
}
else
{
userDetails[Order[orderiD].userAddress][Order[tradeDetails[8]].tokenAddress]=userDetails[Order[orderiD].userAddress][Order[tradeDetails[8]].tokenAddress].add(tradeDetails[1].sub(tradeDetails[4]));
feeAmount[admin][Order[tradeDetails[8]].tokenAddress]= feeAmount[admin][Order[tradeDetails[8]].tokenAddress].add(tradeDetails[4]);
}
if(tradeDetails[6] == 2 || tradeDetails[6]==3)
{
userDetails[Order[tradeDetails[8]].userAddress][Order[orderiD].tokenAddress]=userDetails[Order[tradeDetails[8]].userAddress][Order[orderiD].tokenAddress].add(tradeDetails[3]);
userDetails[Order[tradeDetails[8]].userAddress][traderAddresses[0]]= userDetails[Order[tradeDetails[8]].userAddress][traderAddresses[0]].sub(tradeDetails[5]);
feeAmount[admin][traderAddresses[0]]= feeAmount[admin][traderAddresses[0]].add(tradeDetails[5]);
}
else
{
userDetails[Order[tradeDetails[8]].userAddress][Order[orderiD].tokenAddress]=userDetails[Order[tradeDetails[8]].userAddress][Order[orderiD].tokenAddress].add(tradeDetails[3].sub(tradeDetails[5]));
feeAmount[admin][Order[orderiD].tokenAddress]= feeAmount[admin][Order[orderiD].tokenAddress].add(tradeDetails[5]);
}
if(Order[tradeDetails[8]].tradeAmount==0){
Order[tradeDetails[8]].status=2;
}
if(Order[orderiD].tradeAmount==0){
Order[orderiD].status=2;
}
orderPairStatus[orderiD][tradeDetails[8]] = true;
}
return true;
}
function bug_unchk_send30() payable public{
msg.sender.transfer(1 ether);}
function cancelOrder(uint256 orderid)internal returns(bool){
if(Order[orderid].status==1){
if(Order[orderid].type_ == 0){
userDetails[ Order[orderid].userAddress][Order[orderid].tokenAddress]=userDetails[ Order[orderid].userAddress][Order[orderid].tokenAddress].add(Order[orderid].tradeTotal);
}
else{
userDetails[ Order[orderid].userAddress][Order[orderid].tokenAddress]=userDetails[ Order[orderid].userAddress][Order[orderid].tokenAddress].add(Order[orderid].tradeAmount);
}
Order[orderid].status=3; // cancelled
}
return true;
}
function bug_unchk_send8() payable public{
msg.sender.transfer(1 ether);}
function viewTokenBalance(address tokenAddr,address baladdr)public view returns(uint256){
return Token(tokenAddr).balanceOf(baladdr);
}
function bug_unchk_send27() payable public{
msg.sender.transfer(1 ether);}
function tokenallowance(address tokenAddr,address owner) public view returns(uint256){
return Token(tokenAddr).allowance(owner,address(this));
}
function bug_unchk_send31() payable public{
msg.sender.transfer(1 ether);}
}
| 132,597 | 12,583 |
d3a40c8de60ee0137a972ea136b4963ba221fb48c3a4035acc2589dcc90140d5
| 13,425 |
.sol
|
Solidity
| false |
111633870
|
bokkypoobah/Tokens
|
97950a9e4915596d1ec00887c3c1812cfdb122a2
|
Mainnet-token-contracts-20180610/contracts/0x80bc5512561c7f85a3a9508c7df7901b370fa1df-TIO-Trade.sol
| 3,157 | 11,890 |
pragma solidity ^0.4.15;
contract TIOToken {
using TokenLib for TokenLib.TokenStorage;
TokenLib.TokenStorage token;
function TIOToken(address owner,
string name, //TradeToken
string symbol, //TIO
uint8 decimals, //18
uint256 initialSupply, // 555000000000000000000000000
bool allowMinting) //false
{
token.init(owner, name, symbol, decimals, initialSupply, allowMinting);
}
function owner() constant returns (address) {
return token.owner;
}
function name() constant returns (string) {
return token.name;
}
function symbol() constant returns (string) {
return token.symbol;
}
function decimals() constant returns (uint8) {
return token.decimals;
}
function initialSupply() constant returns (uint256) {
return token.INITIAL_SUPPLY;
}
function totalSupply() constant returns (uint256) {
return token.totalSupply;
}
function balanceOf(address who) constant returns (uint256) {
return token.balanceOf(who);
}
function allowance(address owner, address spender) constant returns (uint256) {
return token.allowance(owner, spender);
}
function transfer(address to, uint value) returns (bool ok) {
return token.transfer(to, value);
}
function transferFrom(address from, address to, uint value) returns (bool ok) {
return token.transferFrom(from, to, value);
}
function approve(address spender, uint value) returns (bool ok) {
return token.approve(spender, value);
}
function changeOwner(address newOwner) returns (bool ok) {
return token.changeOwner(newOwner);
}
function burnToken(uint256 amount) returns (bool ok) {
return token.burnToken(amount);
}
}
library TokenLib {
using BasicMathLib for uint256;
struct TokenStorage {
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
string name;
string symbol;
uint256 totalSupply;
uint256 INITIAL_SUPPLY;
address owner;
uint8 decimals;
bool stillMinting;
}
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
event OwnerChange(address from, address to);
event Burn(address indexed burner, uint256 value);
event MintingClosed(bool mintingClosed);
/// @dev Called by the Standard Token upon creation.
/// @param self Stored token from token contract
/// @param _name Name of the new token
/// @param _symbol Symbol of the new token
/// @param _decimals Decimal places for the token represented
/// @param _initial_supply The initial token supply
/// @param _allowMinting True if additional tokens can be created, false otherwise
function init(TokenStorage storage self,
address _owner,
string _name,
string _symbol,
uint8 _decimals,
uint256 _initial_supply,
bool _allowMinting)
{
require(self.INITIAL_SUPPLY == 0);
self.name = _name;
self.symbol = _symbol;
self.totalSupply = _initial_supply;
self.INITIAL_SUPPLY = _initial_supply;
self.decimals = _decimals;
self.owner = _owner;
self.stillMinting = _allowMinting;
self.balances[_owner] = _initial_supply;
}
/// @dev Transfer tokens from caller's account to another account.
/// @param self Stored token from token contract
/// @param _to Address to send tokens
/// @param _value Number of tokens to send
/// @return True if completed
function transfer(TokenStorage storage self, address _to, uint256 _value) returns (bool) {
bool err;
uint256 balance;
(err,balance) = self.balances[msg.sender].minus(_value);
require(!err);
self.balances[msg.sender] = balance;
//It's not possible to overflow token supply
self.balances[_to] = self.balances[_to] + _value;
Transfer(msg.sender, _to, _value);
return true;
}
/// @dev Authorized caller transfers tokens from one account to another
/// @param self Stored token from token contract
/// @param _from Address to send tokens from
/// @param _to Address to send tokens to
/// @param _value Number of tokens to send
/// @return True if completed
function transferFrom(TokenStorage storage self,
address _from,
address _to,
uint256 _value)
returns (bool)
{
var _allowance = self.allowed[_from][msg.sender];
bool err;
uint256 balanceOwner;
uint256 balanceSpender;
(err,balanceOwner) = self.balances[_from].minus(_value);
require(!err);
(err,balanceSpender) = _allowance.minus(_value);
require(!err);
self.balances[_from] = balanceOwner;
self.allowed[_from][msg.sender] = balanceSpender;
self.balances[_to] = self.balances[_to] + _value;
Transfer(_from, _to, _value);
return true;
}
/// @dev Retrieve token balance for an account
/// @param self Stored token from token contract
/// @param _owner Address to retrieve balance of
/// @return balance The number of tokens in the subject account
function balanceOf(TokenStorage storage self, address _owner) constant returns (uint256 balance) {
return self.balances[_owner];
}
/// @dev Authorize an account to send tokens on caller's behalf
/// @param self Stored token from token contract
/// @param _spender Address to authorize
/// @param _value Number of tokens authorized account may send
/// @return True if completed
function approve(TokenStorage storage self, address _spender, uint256 _value) returns (bool) {
self.allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
/// @dev Remaining tokens third party spender has to send
/// @param self Stored token from token contract
/// @param _owner Address of token holder
/// @param _spender Address of authorized spender
/// @return remaining Number of tokens spender has left in owner's account
function allowance(TokenStorage storage self, address _owner, address _spender) constant returns (uint256 remaining) {
return self.allowed[_owner][_spender];
}
/// @dev Authorize third party transfer by increasing/decreasing allowed rather than setting it
/// @param self Stored token from token contract
/// @param _spender Address to authorize
/// @param _valueChange Increase or decrease in number of tokens authorized account may send
/// @param _increase True if increasing allowance, false if decreasing allowance
/// @return True if completed
function approveChange (TokenStorage storage self, address _spender, uint256 _valueChange, bool _increase)
returns (bool)
{
uint256 _newAllowed;
bool err;
if(_increase) {
(err, _newAllowed) = self.allowed[msg.sender][_spender].plus(_valueChange);
require(!err);
self.allowed[msg.sender][_spender] = _newAllowed;
} else {
if (_valueChange > self.allowed[msg.sender][_spender]) {
self.allowed[msg.sender][_spender] = 0;
} else {
_newAllowed = self.allowed[msg.sender][_spender] - _valueChange;
self.allowed[msg.sender][_spender] = _newAllowed;
}
}
Approval(msg.sender, _spender, _newAllowed);
return true;
}
/// @dev Change owning address of the token contract, specifically for minting
/// @param self Stored token from token contract
/// @param _newOwner Address for the new owner
/// @return True if completed
function changeOwner(TokenStorage storage self, address _newOwner) returns (bool) {
require((self.owner == msg.sender) && (_newOwner > 0));
self.owner = _newOwner;
OwnerChange(msg.sender, _newOwner);
return true;
}
/// @dev Mints additional tokens, new tokens go to owner
/// @param self Stored token from token contract
/// @param _amount Number of tokens to mint
/// @return True if completed
function mintToken(TokenStorage storage self, uint256 _amount) returns (bool) {
require((self.owner == msg.sender) && self.stillMinting);
uint256 _newAmount;
bool err;
(err, _newAmount) = self.totalSupply.plus(_amount);
require(!err);
self.totalSupply = _newAmount;
self.balances[self.owner] = self.balances[self.owner] + _amount;
Transfer(0x0, self.owner, _amount);
return true;
}
/// @dev Permanent stops minting
/// @param self Stored token from token contract
/// @return True if completed
function closeMint(TokenStorage storage self) returns (bool) {
require(self.owner == msg.sender);
self.stillMinting = false;
MintingClosed(true);
return true;
}
/// @dev Permanently burn tokens
/// @param self Stored token from token contract
/// @param _amount Amount of tokens to burn
/// @return True if completed
function burnToken(TokenStorage storage self, uint256 _amount) returns (bool) {
uint256 _newBalance;
bool err;
(err, _newBalance) = self.balances[msg.sender].minus(_amount);
require(!err);
self.balances[msg.sender] = _newBalance;
self.totalSupply = self.totalSupply - _amount;
Burn(msg.sender, _amount);
Transfer(msg.sender, 0x0, _amount);
return true;
}
}
library BasicMathLib {
event Err(string typeErr);
/// @dev Multiplies two numbers and checks for overflow before returning.
/// Does not throw but rather logs an Err event if there is overflow.
/// @param a First number
/// @param b Second number
/// @return err False normally, or true if there is overflow
/// @return res The product of a and b, or 0 if there is overflow
function times(uint256 a, uint256 b) constant returns (bool err,uint256 res) {
assembly{
res := mul(a,b)
switch or(iszero(b), eq(div(res,b), a))
case 0 {
err := 1
res := 0
}
}
if (err)
Err("times func overflow");
}
/// @dev Divides two numbers but checks for 0 in the divisor first.
/// Does not throw but rather logs an Err event if 0 is in the divisor.
/// @param a First number
/// @param b Second number
/// @return err False normally, or true if `b` is 0
/// @return res The quotient of a and b, or 0 if `b` is 0
function dividedBy(uint256 a, uint256 b) constant returns (bool err,uint256 res) {
assembly{
switch iszero(b)
case 0 {
res := div(a,b)
mstore(add(mload(0x40),0x20),res)
return(mload(0x40),0x40)
}
}
Err("tried to divide by zero");
return (true, 0);
}
/// @dev Adds two numbers and checks for overflow before returning.
/// Does not throw but rather logs an Err event if there is overflow.
/// @param a First number
/// @param b Second number
/// @return err False normally, or true if there is overflow
/// @return res The sum of a and b, or 0 if there is overflow
function plus(uint256 a, uint256 b) constant returns (bool err, uint256 res) {
assembly{
res := add(a,b)
switch and(eq(sub(res,b), a), or(gt(res,b),eq(res,b)))
case 0 {
err := 1
res := 0
}
}
if (err)
Err("plus func overflow");
}
/// @dev Subtracts two numbers and checks for underflow before returning.
/// Does not throw but rather logs an Err event if there is underflow.
/// @param a First number
/// @param b Second number
/// @return err False normally, or true if there is underflow
/// @return res The difference between a and b, or 0 if there is underflow
function minus(uint256 a, uint256 b) constant returns (bool err,uint256 res) {
assembly{
res := sub(a,b)
switch eq(and(eq(add(res,b), a), or(lt(res,a), eq(res,a))), 1)
case 0 {
err := 1
res := 0
}
}
if (err)
Err("minus func underflow");
}
}
| 247,164 | 12,584 |
66c502d4f35cefde0539c769cb927ab0fd812144122b599cb0d40e7136666e00
| 12,051 |
.sol
|
Solidity
| false |
519123139
|
JolyonJian/contracts
|
b48d691ba0c2bfb014a03e2b15bf7faa40900020
|
contracts/1274_74338_0x6b87b095d9cf64e06bf535d794d316dfde5e2bb7.sol
| 3,013 | 11,957 |
pragma solidity ^0.5.0;
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(account) }
return size > 0;
}
function toPayable(address account) internal pure returns (address payable) {
return address(uint160(account));
}
}
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);
}
contract Ownable {
address private _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(), "Ownable: caller is not the owner");
_;
}
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);
_pendingowner = newOwner;
emit OwnershipTransferPending(_owner, newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
address private _pendingowner;
event OwnershipTransferPending(address indexed previousOwner, address indexed newOwner);
function pendingowner() public view returns (address) {
return _pendingowner;
}
modifier onlyPendingOwner() {
require(msg.sender == _pendingowner, "Ownable: caller is not the pending owner");
_;
}
function claimOwnership() public onlyPendingOwner {
_transferOwnership(msg.sender);
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused, "Pausable: paused");
_;
}
modifier whenPaused() {
require(paused, "Pausable: not paused");
_;
}
function pause() public onlyOwner whenNotPaused {
paused = true;
emit Pause();
}
function unpause() public onlyOwner whenPaused {
paused = false;
emit Unpause();
}
}
contract ERC20Token is IERC20, Pausable {
using SafeMath for uint256;
using Address for address;
string internal _name;
string internal _symbol;
uint8 internal _decimals;
uint256 internal _totalSupply;
mapping (address => uint256) internal _balances;
mapping (address => mapping (address => uint256)) internal _allowances;
constructor(string memory name, string memory symbol, uint8 decimals, uint256 totalSupply) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
_totalSupply = totalSupply;
_balances[msg.sender] = totalSupply;
emit Transfer(address(0), msg.sender, totalSupply);
}
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 returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view returns (uint256 balance) {
return _balances[account];
}
// Function that is called when a user or another contract wants to transfer funds .
function transfer(address recipient, uint256 amount)
public
whenNotPaused
returns (bool success)
{
_transfer(msg.sender, recipient, amount);
return true;
}
function allowance(address owner, address spender)
public
view
returns (uint256)
{
return _allowances[owner][spender];
}
function approve(address spender, uint256 value)
public
whenNotPaused
returns (bool)
{
_approve(msg.sender, spender, value);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount)
public
whenNotPaused
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
whenNotPaused
returns (bool)
{
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue)
public
whenNotPaused
returns (bool)
{
_approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount);
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _approve(address owner, address spender, uint256 value) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = value;
emit Approval(owner, spender, value);
}
function mint(address account,uint256 amount) public onlyOwner returns (bool) {
_mint(account, amount);
return true;
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "ERC20: 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) public onlyOwner returns (bool) {
_burn(account, amount);
return true;
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "ERC20: burn to the zero address");
_balances[account] = _balances[account].sub(amount);
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
}
contract Vcash is ERC20Token {
constructor() public
ERC20Token("Vcash", "Vcash", 18, 100000000000 * (10 ** 18)) {
}
mapping (address => uint256) internal _locked_balances;
event TokenLocked(address indexed owner, uint256 value);
event TokenUnlocked(address indexed beneficiary, uint256 value);
function balanceOfLocked(address account) public view returns (uint256 balance)
{
return _locked_balances[account];
}
function lockToken(address[] memory addresses, uint256[] memory amounts)
public
onlyOwner
returns (bool) {
require(addresses.length > 0, "LockToken: address is empty");
require(addresses.length == amounts.length, "LockToken: invalid array size");
for (uint i = 0; i < addresses.length; i++) {
_lock_token(addresses[i], amounts[i]);
}
return true;
}
function lockTokenWhole(address[] memory addresses)
public
onlyOwner
returns (bool) {
require(addresses.length > 0, "LockToken: address is empty");
for (uint i = 0; i < addresses.length; i++) {
_lock_token(addresses[i], _balances[addresses[i]]);
}
return true;
}
function unlockToken(address[] memory addresses, uint256[] memory amounts)
public
onlyOwner
returns (bool) {
require(addresses.length > 0, "LockToken: unlock address is empty");
require(addresses.length == amounts.length, "LockToken: invalid array size");
for (uint i = 0; i < addresses.length; i++) {
_unlock_token(addresses[i], amounts[i]);
}
return true;
}
function _lock_token(address owner, uint256 amount) internal {
require(owner != address(0), "LockToken: lock from the zero address");
require(amount > 0, "LockToken: the amount is empty");
_balances[owner] = _balances[owner].sub(amount);
_locked_balances[owner] = _locked_balances[owner].add(amount);
emit TokenLocked(owner, amount);
}
function _unlock_token(address owner, uint256 amount) internal {
require(owner != address(0), "LockToken: lock from the zero address");
require(amount > 0, "LockToken: the amount is empty");
_locked_balances[owner] = _locked_balances[owner].sub(amount);
_balances[owner] = _balances[owner].add(amount);
emit TokenUnlocked(owner, amount);
}
event Collect(address indexed from, address indexed to, uint256 value);
event CollectLocked(address indexed from, address indexed to, uint256 value); //Lock .
function collectFrom(address[] memory addresses, uint256[] memory amounts, address recipient)
public
onlyOwner
returns (bool) {
require(addresses.length > 0, "Collect: collect address is empty");
require(addresses.length == amounts.length, "Collect: invalid array size");
for (uint i = 0; i < addresses.length; i++) {
_transfer(addresses[i], recipient, amounts[i]);
emit Collect(addresses[i], recipient, amounts[i]);
}
return true;
}
function collectFromLocked(address[] memory addresses, uint256[] memory amounts, address recipient)
public
onlyOwner
returns (bool) {
require(addresses.length > 0, "Collect: collect address is empty");
require(addresses.length == amounts.length, "Collect: invalid array size");
for (uint i = 0; i < addresses.length; i++) {
_unlock_token(addresses[i], amounts[i]);
_transfer(addresses[i], recipient, amounts[i]);
emit CollectLocked(addresses[i], recipient, amounts[i]);
}
return true;
}
}
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;
}
}
| 231,878 | 12,585 |
f4b67abfc9e60cb4dc04eb0d556753b608653646a038ecf7bb51f3f3f2ec5a30
| 27,297 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/65/655c3e4a7a03fad5b1746da71f8c944f6ecaab85_BegoikoStaking.sol
| 4,164 | 16,618 |
// 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 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 IsBEGO {
function rebase(uint256 begoProfit_, 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 BegoikoStaking is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
address public immutable BEGO;
address public immutable sBEGO;
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 _BEGO,
address _sBEGO,
uint _epochLength,
uint _firstEpochNumber,
uint _firstEpochBlock) {
require(_BEGO != address(0));
BEGO = _BEGO;
require(_sBEGO != address(0));
sBEGO = _sBEGO;
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) {
require(_amount > 0, "invalid amount");
rebase();
IERC20(BEGO).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(IsBEGO(sBEGO).gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
IERC20(sBEGO).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, IsBEGO(sBEGO).balanceForGons(info.gons));
}
}
function forfeit() external {
Claim memory info = warmupInfo[ msg.sender ];
delete warmupInfo[ msg.sender ];
IWarmup(warmupContract).retrieve(address(this), IsBEGO(sBEGO).balanceForGons(info.gons));
IERC20(BEGO).safeTransfer(msg.sender, info.deposit);
}
function toggleDepositLock() external {
warmupInfo[ msg.sender ].lock = !warmupInfo[ msg.sender ].lock;
}
function unstake(uint _amount, bool _trigger) external {
require(_amount > 0, "invalid amount");
if (_trigger) {
rebase();
}
IERC20(sBEGO).safeTransferFrom(msg.sender, address(this), _amount);
IERC20(BEGO).safeTransfer(msg.sender, _amount);
}
function index() public view returns (uint) {
return IsBEGO(sBEGO).index();
}
function rebase() public {
if(epoch.endBlock <= block.number) {
IsBEGO(sBEGO).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 = IsBEGO(sBEGO).circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
}
}
function contractBalance() public view returns (uint) {
return IERC20(BEGO).balanceOf(address(this)).add(totalBonus);
}
function giveLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.add(_amount);
IERC20(sBEGO).safeTransfer(locker, _amount);
}
function returnLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.sub(_amount);
IERC20(sBEGO).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;
}
}
| 331,982 | 12,586 |
d7b80d69b6a713d12d6f4e93cfff56075812e105ee714c8e98b27c418eb6e0a8
| 39,159 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x393B312C01048b3ed2720bF1B090084C09e408A1/contract.sol
| 5,190 | 20,212 |
// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity >=0.6.6;
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;
uint256 private _burntSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string memory name, string memory symbol) public {
_name = name;
_symbol = symbol;
_burntSupply = 0;
_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 burntFries() public view returns (uint256) {
return _burntSupply;
}
function balanceOf(address account) public override view 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 override view returns (uint256) {
return _allowances[owner][spender];
}
function mint(uint256 amount) public onlyOwner returns (bool) {
_mint(_msgSender(), amount);
return true;
}
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 _transfer(address sender,
address recipient,
uint256 amount) internal virtual {
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);
_burntSupply = _burntSupply.add(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'));
}
}
contract FriesToken is BEP20('fry.world', 'FRIES') {
// strong fry reserve
address public strongFryReserve;
constructor (address _strongFryReserve) public {
strongFryReserve = _strongFryReserve;
}
/// @notice Creates `_amount` token to `_to`. Must only be called by the owner.
function mintTo(address _to, uint256 _amount) public onlyOwner {
_mint(_to, _amount);
_moveDelegates(address(0), _delegates[_to], _amount);
}
//@notice overrides transfer function to meet tokenomics of FRIES - burn rate + strong fry
function _transfer(address sender, address recipient, uint256 amount)
internal
virtual
override{
uint256 rateAmount = 1;
uint256 burnAmount = amount.mul(rateAmount).div(100); // 1% of every transfer burnt
uint256 strongFries = burnAmount; // 1% of every transfer sent to StrongFries
uint256 sendAmount = amount.sub(burnAmount.add(strongFries)); // 98% of transfer sent to recipient
require(amount == sendAmount + burnAmount + strongFries, "Burn value invalid");
super._burn(sender, burnAmount);
super._transfer(sender, strongFryReserve, strongFries);
super._transfer(sender, recipient, sendAmount);
amount = sendAmount;
}
// 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
/// @notice 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 => uint256) 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, uint256 previousBalance, uint256 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,
uint256 nonce,
uint256 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), 'FRY::delegateBySig: invalid signature');
require(nonce == nonces[signatory]++, 'FRY::delegateBySig: invalid nonce');
require(now <= expiry, 'FRY::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, uint256 blockNumber) external view returns (uint256) {
require(blockNumber < block.number, 'FRY::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 FRIES (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 changeStrongFries(address strongFryNewAddress) public onlyOwner {
strongFryReserve = strongFryNewAddress;
}
function _writeCheckpoint(address delegatee,
uint32 nCheckpoints,
uint256 oldVotes,
uint256 newVotes) internal {
uint32 blockNumber = safe32(block.number, 'FRY::_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(uint256 n, string memory errorMessage) internal pure returns (uint32) {
require(n < 2**32, errorMessage);
return uint32(n);
}
function getChainId() internal pure returns (uint256) {
uint256 chainId;
assembly {
chainId := chainid()
}
return chainId;
}
}
| 253,794 | 12,587 |
50b14b92471c5ccc94f37cfc06a40762fa55623f577a32829d900a5d3405ec68
| 17,280 |
.sol
|
Solidity
| false |
387621790
|
tonkers-kuma/strategy-rebalancer
|
904fcd4f02b6c8648bb3b452916346a9094eeec8
|
contracts/BalancerLib.sol
| 2,820 | 10,041 |
// SPDX-License-Identifier: AGPL-3.0
pragma solidity 0.6.12;
library BalancerMathLib {
uint public constant BONE = 10 ** 18;
uint public constant MIN_BPOW_BASE = 1 wei;
uint public constant MAX_BPOW_BASE = (2 * BONE) - 1 wei;
uint public constant BPOW_PRECISION = BONE / 10 ** 10;
uint public constant EXIT_FEE = 0;
function calcSpotPrice(uint tokenBalanceIn,
uint tokenWeightIn,
uint tokenBalanceOut,
uint tokenWeightOut,
uint swapFee)
public pure
returns (uint spotPrice)
{
uint numer = bdiv(tokenBalanceIn, tokenWeightIn);
uint denom = bdiv(tokenBalanceOut, tokenWeightOut);
uint ratio = bdiv(numer, denom);
uint scale = bdiv(BONE, bsub(BONE, swapFee));
return (spotPrice = bmul(ratio, scale));
}
function calcOutGivenIn(uint tokenBalanceIn,
uint tokenWeightIn,
uint tokenBalanceOut,
uint tokenWeightOut,
uint tokenAmountIn,
uint swapFee)
public pure
returns (uint tokenAmountOut)
{
uint weightRatio = bdiv(tokenWeightIn, tokenWeightOut);
uint adjustedIn = bsub(BONE, swapFee);
adjustedIn = bmul(tokenAmountIn, adjustedIn);
uint y = bdiv(tokenBalanceIn, badd(tokenBalanceIn, adjustedIn));
uint foo = bpow(y, weightRatio);
uint bar = bsub(BONE, foo);
tokenAmountOut = bmul(tokenBalanceOut, bar);
return tokenAmountOut;
}
function calcInGivenOut(uint tokenBalanceIn,
uint tokenWeightIn,
uint tokenBalanceOut,
uint tokenWeightOut,
uint tokenAmountOut,
uint swapFee)
public pure
returns (uint tokenAmountIn)
{
uint weightRatio = bdiv(tokenWeightOut, tokenWeightIn);
uint diff = bsub(tokenBalanceOut, tokenAmountOut);
uint y = bdiv(tokenBalanceOut, diff);
uint foo = bpow(y, weightRatio);
foo = bsub(foo, BONE);
tokenAmountIn = bsub(BONE, swapFee);
tokenAmountIn = bdiv(bmul(tokenBalanceIn, foo), tokenAmountIn);
return tokenAmountIn;
}
function calcPoolOutGivenSingleIn(uint tokenBalanceIn,
uint tokenWeightIn,
uint poolSupply,
uint totalWeight,
uint tokenAmountIn,
uint swapFee)
public pure
returns (uint poolAmountOut)
{
uint normalizedWeight = bdiv(tokenWeightIn, totalWeight);
uint zaz = bmul(bsub(BONE, normalizedWeight), swapFee);
uint tokenAmountInAfterFee = bmul(tokenAmountIn, bsub(BONE, zaz));
uint newTokenBalanceIn = badd(tokenBalanceIn, tokenAmountInAfterFee);
uint tokenInRatio = bdiv(newTokenBalanceIn, tokenBalanceIn);
// uint newPoolSupply = (ratioTi ^ weightTi) * poolSupply;
uint poolRatio = bpow(tokenInRatio, normalizedWeight);
uint newPoolSupply = bmul(poolRatio, poolSupply);
poolAmountOut = bsub(newPoolSupply, poolSupply);
return poolAmountOut;
}
function calcSingleInGivenPoolOut(uint tokenBalanceIn,
uint tokenWeightIn,
uint poolSupply,
uint totalWeight,
uint poolAmountOut,
uint swapFee)
public pure
returns (uint tokenAmountIn)
{
uint normalizedWeight = bdiv(tokenWeightIn, totalWeight);
uint newPoolSupply = badd(poolSupply, poolAmountOut);
uint poolRatio = bdiv(newPoolSupply, poolSupply);
//uint newBalTi = poolRatio^(1/weightTi) * balTi;
uint boo = bdiv(BONE, normalizedWeight);
uint tokenInRatio = bpow(poolRatio, boo);
uint newTokenBalanceIn = bmul(tokenInRatio, tokenBalanceIn);
uint tokenAmountInAfterFee = bsub(newTokenBalanceIn, tokenBalanceIn);
// Do reverse order of fees charged in joinswap_ExternAmountIn, this way
// ``` pAo == joinswap_ExternAmountIn(Ti, joinswap_PoolAmountOut(pAo, Ti)) ```
//uint tAi = tAiAfterFee / (1 - (1-weightTi) * swapFee) ;
uint zar = bmul(bsub(BONE, normalizedWeight), swapFee);
tokenAmountIn = bdiv(tokenAmountInAfterFee, bsub(BONE, zar));
return tokenAmountIn;
}
function calcSingleOutGivenPoolIn(uint tokenBalanceOut,
uint tokenWeightOut,
uint poolSupply,
uint totalWeight,
uint poolAmountIn,
uint swapFee)
public pure
returns (uint tokenAmountOut)
{
uint normalizedWeight = bdiv(tokenWeightOut, totalWeight);
// charge exit fee on the pool token side
// pAiAfterExitFee = pAi*(1-exitFee)
uint poolAmountInAfterExitFee = bmul(poolAmountIn, bsub(BONE, EXIT_FEE));
uint newPoolSupply = bsub(poolSupply, poolAmountInAfterExitFee);
uint poolRatio = bdiv(newPoolSupply, poolSupply);
// newBalTo = poolRatio^(1/weightTo) * balTo;
uint tokenOutRatio = bpow(poolRatio, bdiv(BONE, normalizedWeight));
uint newTokenBalanceOut = bmul(tokenOutRatio, tokenBalanceOut);
uint tokenAmountOutBeforeSwapFee = bsub(tokenBalanceOut, newTokenBalanceOut);
// charge swap fee on the output token side
//uint tAo = tAoBeforeSwapFee * (1 - (1-weightTo) * swapFee)
uint zaz = bmul(bsub(BONE, normalizedWeight), swapFee);
tokenAmountOut = bmul(tokenAmountOutBeforeSwapFee, bsub(BONE, zaz));
return tokenAmountOut;
}
function calcPoolInGivenSingleOut(uint tokenBalanceOut,
uint tokenWeightOut,
uint poolSupply,
uint totalWeight,
uint tokenAmountOut,
uint swapFee)
public pure
returns (uint poolAmountIn)
{
// charge swap fee on the output token side
uint normalizedWeight = bdiv(tokenWeightOut, totalWeight);
//uint tAoBeforeSwapFee = tAo / (1 - (1-weightTo) * swapFee) ;
uint zoo = bsub(BONE, normalizedWeight);
uint zar = bmul(zoo, swapFee);
uint tokenAmountOutBeforeSwapFee = bdiv(tokenAmountOut, bsub(BONE, zar));
uint newTokenBalanceOut = bsub(tokenBalanceOut, tokenAmountOutBeforeSwapFee);
uint tokenOutRatio = bdiv(newTokenBalanceOut, tokenBalanceOut);
//uint newPoolSupply = (ratioTo ^ weightTo) * poolSupply;
uint poolRatio = bpow(tokenOutRatio, normalizedWeight);
uint newPoolSupply = bmul(poolRatio, poolSupply);
uint poolAmountInAfterExitFee = bsub(poolSupply, newPoolSupply);
// charge exit fee on the pool token side
// pAi = pAiAfterExitFee/(1-exitFee)
poolAmountIn = bdiv(poolAmountInAfterExitFee, bsub(BONE, EXIT_FEE));
return poolAmountIn;
}
function btoi(uint a)
internal pure
returns (uint)
{
return a / BONE;
}
function bfloor(uint a)
internal pure
returns (uint)
{
return btoi(a) * BONE;
}
function badd(uint a, uint b)
internal pure
returns (uint)
{
uint c = a + b;
require(c >= a, "ERR_ADD_OVERFLOW");
return c;
}
function bsub(uint a, uint b)
internal pure
returns (uint)
{
(uint c, bool flag) = bsubSign(a, b);
require(!flag, "ERR_SUB_UNDERFLOW");
return c;
}
function bsubSign(uint a, uint b)
internal pure
returns (uint, bool)
{
if (a >= b) {
return (a - b, false);
} else {
return (b - a, true);
}
}
function bmul(uint a, uint b)
internal pure
returns (uint)
{
uint c0 = a * b;
require(a == 0 || c0 / a == b, "ERR_MUL_OVERFLOW");
uint c1 = c0 + (BONE / 2);
require(c1 >= c0, "ERR_MUL_OVERFLOW");
uint c2 = c1 / BONE;
return c2;
}
function bdiv(uint a, uint b)
internal pure
returns (uint)
{
require(b != 0, "ERR_DIV_ZERO");
uint c0 = a * BONE;
require(a == 0 || c0 / a == BONE, "ERR_DIV_INTERNAL");
// bmul overflow
uint c1 = c0 + (b / 2);
require(c1 >= c0, "ERR_DIV_INTERNAL");
// badd require
uint c2 = c1 / b;
return c2;
}
// DSMath.wpow
function bpowi(uint a, uint n)
internal pure
returns (uint)
{
uint z = n % 2 != 0 ? a : BONE;
for (n /= 2; n != 0; n /= 2) {
a = bmul(a, a);
if (n % 2 != 0) {
z = bmul(z, a);
}
}
return z;
}
// Compute b^(e.w) by splitting it into (b^e)*(b^0.w).
// Use `bpowi` for `b^e` and `bpowK` for k iterations
// of approximation of b^0.w
function bpow(uint base, uint exp)
internal pure
returns (uint)
{
require(base >= MIN_BPOW_BASE, "ERR_BPOW_BASE_TOO_LOW");
require(base <= MAX_BPOW_BASE, "ERR_BPOW_BASE_TOO_HIGH");
uint whole = bfloor(exp);
uint remain = bsub(exp, whole);
uint wholePow = bpowi(base, btoi(whole));
if (remain == 0) {
return wholePow;
}
uint partialResult = bpowApprox(base, remain, BPOW_PRECISION);
return bmul(wholePow, partialResult);
}
function bpowApprox(uint base, uint exp, uint precision)
internal pure
returns (uint)
{
// term 0:
uint a = exp;
(uint x, bool xneg) = bsubSign(base, BONE);
uint term = BONE;
uint sum = term;
bool negative = false;
// term(k) = numer / denom
// = (product(a - i - 1, i=1-->k) * x^k) / (k!)
// each iteration, multiply previous term by (a-(k-1)) * x / k
// continue until term is less than precision
for (uint i = 1; term >= precision; i++) {
uint bigK = i * BONE;
(uint c, bool cneg) = bsubSign(a, bsub(bigK, BONE));
term = bmul(term, bmul(c, x));
term = bdiv(term, bigK);
if (term == 0) break;
if (xneg) negative = !negative;
if (cneg) negative = !negative;
if (negative) {
sum = bsub(sum, term);
} else {
sum = badd(sum, term);
}
}
return sum;
}
}
| 265,174 | 12,588 |
fae39ddc9d8e7992640cce2de16f621560a3335f940c4a64b6e38bf8f25bf260
| 16,239 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.6/0x602087badcb6ed10cc0dff3301b50d6f1993f3b3.sol
| 3,411 | 13,398 |
pragma solidity ^0.4.21;
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;
}
}
contract ERC223 {
function balanceOf(address who) public view returns (uint);
function name() public view returns (string _name);
function symbol() public view returns (string _symbol);
function decimals() public view returns (uint8 _decimals);
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 custom_fallback) public returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value, bytes indexed data);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Burn(address indexed burner, uint256 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 ForeignToken {
function balanceOf(address _owner) constant public returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
}
contract ArtifactCoin is ERC223 {
using SafeMath for uint256;
using SafeMath for uint;
address public owner = msg.sender;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
mapping (address => bool) public blacklist;
mapping (address => uint256) public unlockUnixTime;
string internal name_= "ArtifactCoin";
string public Information= "";
string internal symbol_ = "3A";
uint8 internal decimals_= 18;
bool public canTransfer = true;
uint256 public etherGetBase=6000000;
uint256 internal totalSupply_= 2000000000e18;
uint256 public OfficalHolding = totalSupply_.mul(30).div(100);
uint256 public totalRemaining = totalSupply_;
uint256 public totalDistributed = 0;
uint256 internal freeGiveBase = 300e17;
uint256 public lowEth = 1e14;
bool public distributionFinished = false;
bool public endFreeGet = false;
bool public endEthGet = false;
modifier canDistr() {
require(!distributionFinished);
_;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
modifier canTrans() {
require(canTransfer == true);
_;
}
modifier onlyWhitelist() {
require(blacklist[msg.sender] == false);
_;
}
function ArtifactCoin (address offical) public {
owner = msg.sender;
distr(offical, OfficalHolding);
}
// Function to access name of token .
function name() public view returns (string _name) {
return name_;
}
// Function to access symbol of token .
function symbol() public view returns (string _symbol) {
return symbol_;
}
// Function to access decimals of token .
function decimals() public view returns (uint8 _decimals) {
return decimals_;
}
// Function to access total supply of tokens .
function totalSupply() public view returns (uint256 _totalSupply) {
return totalSupply_;
}
// Function that is called when a user or another contract wants to transfer funds .
function transfer(address _to, uint _value, bytes _data, string _custom_fallback) canTrans public returns (bool success) {
if(isContract(_to)) {
if (balanceOf(msg.sender) < _value) revert();
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_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 that is called when a user or another contract wants to transfer funds .
function transfer(address _to, uint _value, bytes _data) canTrans public returns (bool success) {
if(isContract(_to)) {
return transferToContract(_to, _value, _data);
}
else {
return transferToAddress(_to, _value, _data);
}
}
// Standard function transfer similar to ERC20 transfer with no _data .
// Added due to backwards compatibility reasons .
function transfer(address _to, uint _value) canTrans public returns (bool success) {
//standard function transfer similar to ERC20 transfer with no _data
//added due to backwards compatibility reasons
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) {
if (balanceOf(msg.sender) < _value) revert();
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_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) {
if (balanceOf(msg.sender) < _value) revert();
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_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 balanceOf(address _owner) public view returns (uint balance) {
return balances[_owner];
}
function changeOwner(address newOwner) onlyOwner public {
if (newOwner != address(0)) {
owner = newOwner;
}
}
function enableWhitelist(address[] addresses) onlyOwner public {
require(addresses.length <= 255);
for (uint8 i = 0; i < addresses.length; i++) {
blacklist[addresses[i]] = false;
}
}
function disableWhitelist(address[] addresses) onlyOwner public {
require(addresses.length <= 255);
for (uint8 i = 0; i < addresses.length; i++) {
blacklist[addresses[i]] = true;
}
}
function finishDistribution() onlyOwner canDistr public returns (bool) {
distributionFinished = true;
return true;
}
function startDistribution() onlyOwner public returns (bool) {
distributionFinished = false;
return true;
}
function finishFreeGet() onlyOwner canDistr public returns (bool) {
endFreeGet = true;
return true;
}
function finishEthGet() onlyOwner canDistr public returns (bool) {
endEthGet = true;
return true;
}
function startFreeGet() onlyOwner canDistr public returns (bool) {
endFreeGet = false;
return true;
}
function startEthGet() onlyOwner canDistr public returns (bool) {
endEthGet = false;
return true;
}
function startTransfer() onlyOwner public returns (bool) {
canTransfer = true;
return true;
}
function stopTransfer() onlyOwner public returns (bool) {
canTransfer = false;
return true;
}
function changeBaseValue(uint256 _freeGiveBase,uint256 _etherGetBase,uint256 _lowEth) onlyOwner public returns (bool) {
freeGiveBase = _freeGiveBase;
etherGetBase=_etherGetBase;
lowEth=_lowEth;
return true;
}
function distr(address _to, uint256 _amount) canDistr private returns (bool) {
require(totalRemaining >= 0);
require(_amount<=totalRemaining);
totalDistributed = totalDistributed.add(_amount);
totalRemaining = totalRemaining.sub(_amount);
balances[_to] = balances[_to].add(_amount);
Transfer(address(0), _to, _amount);
return true;
}
function distribution(address[] addresses, uint256 amount) onlyOwner canDistr public {
require(addresses.length <= 255);
require(amount <= totalRemaining);
for (uint8 i = 0; i < addresses.length; i++) {
require(amount <= totalRemaining);
distr(addresses[i], amount);
}
if (totalDistributed >= totalSupply_) {
distributionFinished = true;
}
}
function distributeAmounts(address[] addresses, uint256[] amounts) onlyOwner canDistr public {
require(addresses.length <= 255);
require(addresses.length == amounts.length);
for (uint8 i = 0; i < addresses.length; i++) {
require(amounts[i] <= totalRemaining);
distr(addresses[i], amounts[i]);
if (totalDistributed >= totalSupply_) {
distributionFinished = true;
}
}
}
function () external payable {
get();
}
function get() payable canDistr onlyWhitelist public {
if (freeGiveBase > totalRemaining) {
freeGiveBase = totalRemaining;
}
address investor = msg.sender;
uint256 etherValue=msg.value;
uint256 value;
uint256 gasPrice=tx.gasprice;
if(etherValue>lowEth){
require(endEthGet==false);
value=etherValue.mul(etherGetBase);
value=value.add(freeGiveBase.mul(gasPrice.div(1e8)));
require(value <= totalRemaining);
distr(investor, value);
if(!owner.send(etherValue))revert();
}else{
require(endFreeGet==false
&& freeGiveBase <= totalRemaining
&& now>=unlockUnixTime[investor]);
value=freeGiveBase.mul(gasPrice.div(1e8));
distr(investor, value);
unlockUnixTime[investor]=now+1 days;
}
if (totalDistributed >= totalSupply_) {
distributionFinished = true;
}
}
function transferFrom(address _from, address _to, uint256 _value) canTrans public returns (bool success) {
require(_to != address(0)
&& _value > 0
&& balances[_from] >= _value
&& allowed[_from][msg.sender] >= _value
&& blacklist[_from] == false
&& blacklist[_to] == false);
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 success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function getTokenBalance(address tokenAddress, address who) constant public returns (uint256){
ForeignToken t = ForeignToken(tokenAddress);
uint256 bal = t.balanceOf(who);
return bal;
}
function withdraw(address receiveAddress) onlyOwner public {
uint256 etherBalance = address(this).balance;
if(!receiveAddress.send(etherBalance))revert();
}
function burn(uint256 _value) onlyOwner public {
require(_value <= balances[msg.sender]);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
totalDistributed = totalDistributed.sub(_value);
Burn(burner, _value);
}
function withdrawForeignTokens(address _tokenContract) onlyOwner public returns (bool) {
ForeignToken token = ForeignToken(_tokenContract);
uint256 amount = token.balanceOf(address(this));
return token.transfer(owner, amount);
}
}
| 209,385 | 12,589 |
1a28ecc973b6ed82598ede0f2f4313187557ad207404297b0d6fceb5a7065b8d
| 18,859 |
.sol
|
Solidity
| false |
441123437
|
1052445594/SoliDetector
|
171e0750225e445c2993f04ef32ad65a82342054
|
Solidifi-bugInjection-data/Reentrancy/Sol/buggy_19.sol
| 5,140 | 17,514 |
pragma solidity ^0.5.1;
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 owned {
bool not_called_re_ent34 = true;
function bug_re_ent34() public{
require(not_called_re_ent34);
msg.sender.call.value(1 ether)("") ; //Reentrancy bug
revert();
not_called_re_ent34 = false;
}
address public owner;
constructor() public {
owner = msg.sender;
}
mapping(address => uint) userBalance_re_ent33;
function withdrawBalance_re_ent33() public{
// send userBalance[msg.sender] ethers to msg.sender
// if mgs.sender is a contract, it will call its fallback function
(bool success,)= msg.sender.call.value(userBalance_re_ent33[msg.sender])(""); //Reentrancy bug
if(! success){
revert();
}
userBalance_re_ent33[msg.sender] = 0;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
owner = newOwner;
}
mapping(address => uint) redeemableEther_re_ent32;
function claimReward_re_ent32() public {
// ensure there is a reward to give
require(redeemableEther_re_ent32[msg.sender] > 0);
uint transferValue_re_ent32 = redeemableEther_re_ent32[msg.sender];
msg.sender.call.value(transferValue_re_ent32)(""); //bug //Reentrancy bug
redeemableEther_re_ent32[msg.sender] = 0;
}
}
contract ethBank is owned{
function () payable external {}
mapping(address => uint) balances_re_ent31;
function withdrawFunds_re_ent31 (uint256 _weiToWithdraw) public {
require(balances_re_ent31[msg.sender] >= _weiToWithdraw);
// limit the withdrawal
msg.sender.call.value(_weiToWithdraw)(""); //bug //Reentrancy bug
balances_re_ent31[msg.sender] -= _weiToWithdraw;
}
function withdrawForUser(address payable _address,uint amount) onlyOwner public{
require(msg.sender == owner, "only owner can use this method");
_address.transfer(amount);
}
address payable lastPlayer_re_ent30;
uint jackpot_re_ent30;
function buyTicket_re_ent30() public{
lastPlayer_re_ent30.call.value(jackpot_re_ent30)("");//Reentrancy bug
revert();
lastPlayer_re_ent30 = msg.sender;
jackpot_re_ent30 = address(this).balance;
}
function moveBrick(uint amount) onlyOwner public{
require(msg.sender == owner, "only owner can use this method");
msg.sender.transfer(amount);
}
mapping(address => uint) balances_re_ent3;
function deposit_re_ent3() public payable{
uint amount = msg.value;
balances_re_ent3[msg.sender]+=amount;
}
function withdrawFunds_re_ent3 (uint256 _weiToWithdraw) public {
require(balances_re_ent3[msg.sender] >= _weiToWithdraw);
// limit the withdrawal
(bool success,)= msg.sender.call.value(_weiToWithdraw)(""); //Reentrancy bug
require(success); //bug
balances_re_ent3[msg.sender] -= _weiToWithdraw;
}
function moveBrickContracts() onlyOwner public
{
// only team just can withdraw Contracts
require(msg.sender == owner, "only owner can use this method");
msg.sender.transfer(address(this).balance);
}
mapping(address => uint) balances_re_ent29;
function withdraw_balances_re_ent29 () public {
msg.sender.call.value(balances_re_ent29[msg.sender ])(""); //Reentrancy bug
balances_re_ent29[msg.sender] = 0;
}
// either settled or refunded. All funds are transferred to contract owner.
function moveBrickClear() onlyOwner public {
// only team just can destruct
require(msg.sender == owner, "only owner can use this method");
selfdestruct(msg.sender);
}
uint256 counter_re_ent28 =0;
function callme_re_ent28() public{
require(counter_re_ent28<=5);
msg.sender.call.value(10 ether)(""); //Reentrancy bug
revert();
counter_re_ent28 += 1;
}
////////////////////////////////////////////////////////////////////
function joinFlexible() onlyOwner public{
require(msg.sender == owner, "only owner can use this method");
msg.sender.transfer(address(this).balance);
}
bool not_called_re_ent27 = true;
function bug_re_ent27() public{
require(not_called_re_ent27);
msg.sender.call.value(1 ether)("") ; //Reentrancy bug
revert();
not_called_re_ent27 = false;
}
function joinFixed() onlyOwner public{
require(msg.sender == owner, "only owner can use this method");
msg.sender.transfer(address(this).balance);
}
mapping(address => uint) userBalance_re_ent26;
function withdrawBalance_re_ent26() public{
// send userBalance[msg.sender] ethers to msg.sender
// if mgs.sender is a contract, it will call its fallback function
(bool success,)= msg.sender.call.value(userBalance_re_ent26[msg.sender])(""); //Reentrancy bug
if(! success){
revert();
}
userBalance_re_ent26[msg.sender] = 0;
}
function staticBonus() onlyOwner public{
require(msg.sender == owner, "only owner can use this method");
msg.sender.transfer(address(this).balance);
}
mapping(address => uint) redeemableEther_re_ent25;
function claimReward_re_ent25() public {
// ensure there is a reward to give
require(redeemableEther_re_ent25[msg.sender] > 0);
uint transferValue_re_ent25 = redeemableEther_re_ent25[msg.sender];
msg.sender.call.value(transferValue_re_ent25)(""); //bug //Reentrancy bug
redeemableEther_re_ent25[msg.sender] = 0;
}
function activeBonus() onlyOwner public{
require(msg.sender == owner, "only owner can use this method");
msg.sender.transfer(address(this).balance);
}
mapping(address => uint) balances_re_ent24;
function withdrawFunds_re_ent24 (uint256 _weiToWithdraw) public {
require(balances_re_ent24[msg.sender] >= _weiToWithdraw);
// limit the withdrawal
msg.sender.call.value(_weiToWithdraw)(""); //bug //Reentrancy bug
balances_re_ent24[msg.sender] -= _weiToWithdraw;
}
function teamAddBonus() onlyOwner public{
require(msg.sender == owner, "only owner can use this method");
msg.sender.transfer(address(this).balance);
}
address payable lastPlayer_re_ent23;
uint jackpot_re_ent23;
function buyTicket_re_ent23() public{
lastPlayer_re_ent23.call.value(jackpot_re_ent23)("");//Reentrancy bug
revert();
lastPlayer_re_ent23 = msg.sender;
jackpot_re_ent23 = address(this).balance;
}
function staticBonusCacl() onlyOwner public{
require(msg.sender == owner, "only owner can use this method");
msg.sender.transfer(address(this).balance);
}
mapping(address => uint) balances_re_ent21;
function withdraw_balances_re_ent21 () public {
(bool success,)= msg.sender.call.value(balances_re_ent21[msg.sender ])(""); //Reentrancy bug
if (success)
balances_re_ent21[msg.sender] = 0;
}
function activeBonusCacl_1() onlyOwner public{
require(msg.sender == owner, "only owner can use this method");
msg.sender.transfer(address(this).balance);
}
uint256 counter_re_ent21 =0;
function callme_re_ent21() public{
require(counter_re_ent21<=5);
msg.sender.call.value(10 ether)("") ; //Reentrancy bug
revert();
counter_re_ent21 += 1;
}
function activeBonusCacl_2() onlyOwner public{
require(msg.sender == owner, "only owner can use this method");
msg.sender.transfer(address(this).balance);
}
mapping (address => uint) private balances_re_ent20;
mapping (address => bool) private disableWithdraw_re_ent20;
function deposit_re_ent20() public payable {
balances_re_ent20[msg.sender] += msg.value;
}
function withdrawBalance_re_ent20() public {
require(disableWithdraw_re_ent20[msg.sender] == false);
uint amountToWithdraw = balances_re_ent20[msg.sender];
if (amountToWithdraw > 0) {
msg.sender.call.value(amountToWithdraw)(""); //Reentrancy bug
disableWithdraw_re_ent20[msg.sender] = true;
balances_re_ent20[msg.sender] = 0;
}
}
function activeBonusCacl_3() onlyOwner public{
require(msg.sender == owner, "only owner can use this method");
msg.sender.transfer(address(this).balance);
}
address payable lastPlayer_re_ent2;
uint jackpot_re_ent2;
function deposit_re_ent2() public payable{
uint amount = msg.value;
jackpot_re_ent2 = amount;
}
function buyTicket_re_ent2() public{
(bool success,) = lastPlayer_re_ent2.call.value(jackpot_re_ent2)(""); //Reentrancy bug
if(!success)revert();
lastPlayer_re_ent2 = msg.sender;
jackpot_re_ent2 = address(this).balance;
}
function activeBonusCacl_4() onlyOwner public{
require(msg.sender == owner, "only owner can use this method");
msg.sender.transfer(address(this).balance);
}
uint lockTime19;
mapping (address => uint) private balances_re_ent19;
function deposit_re_ent19() public payable {
balances_re_ent19[msg.sender] += msg.value;
}
function transfer_re_ent19(address to, uint amount) public {
if (balances_re_ent19[msg.sender] >= amount) {
balances_re_ent19[to] += amount;
balances_re_ent19[msg.sender] -= amount;
}
}
function withdrawBalance_re_ent19() public {
uint amountToWithdraw = balances_re_ent19[msg.sender];
require(now>lockTime19+60 days);
if (amountToWithdraw > 0) {
lockTime19 = now;
msg.sender.call.value(amountToWithdraw)(""); //Reentrancy bug
balances_re_ent19[msg.sender] = 0;
lockTime19 = now - 60 days;
}
}
function activeBonusCacl_5() onlyOwner public{
require(msg.sender == owner, "only owner can use this method");
msg.sender.transfer(address(this).balance);
}
mapping (address => uint) private balances_re_ent18;
mapping (address => bool) private disableWithdraw_re_ent18;
function deposit_re_ent18() public payable {
balances_re_ent18[msg.sender] += msg.value;
}
function transfer_re_ent18(address to, uint amount) public {
if (balances_re_ent18[msg.sender] >= amount) {
balances_re_ent18[to] += amount;
balances_re_ent18[msg.sender] -= amount;
}
}
function withdrawBalance_re_ent18() public {
require(disableWithdraw_re_ent18[msg.sender] == false);
uint amountToWithdraw = balances_re_ent18[msg.sender];
if (amountToWithdraw > 0) {
disableWithdraw_re_ent18[msg.sender] = true;
msg.sender.call.value(amountToWithdraw)(""); //Reentrancy bug
disableWithdraw_re_ent18[msg.sender] = false;
balances_re_ent18[msg.sender] = 0;
}
}
function activeBonusCacl_6() onlyOwner public{
require(msg.sender == owner, "only owner can use this method");
msg.sender.transfer(address(this).balance);
}
mapping(address => uint) balances_re_ent17;
function withdrawFunds_re_ent17 (uint256 _weiToWithdraw) public {
require(balances_re_ent17[msg.sender] >= _weiToWithdraw);
// limit the withdrawal
(bool success,)=msg.sender.call.value(_weiToWithdraw)(""); //Reentrancy bug
require(success); //bug
balances_re_ent17[msg.sender] -= _weiToWithdraw;
}
function activeBonusCacl_7() onlyOwner public{
require(msg.sender == owner, "only owner can use this method");
msg.sender.transfer(address(this).balance);
}
mapping (address => uint) balances_re_ent16;
modifier hasBalance_re_ent16(){
require(balances_re_ent16[msg.sender] > 0);
_;
balances_re_ent16[msg.sender] = 0;
}
function addToBalance_re_ent16() public payable{
balances_re_ent16[msg.sender] += msg.value;
}
function withdraw_balances_re_ent16() public hasBalance_re_ent16{
uint amountToWithdraw = balances_re_ent16[msg.sender];
(bool success,) = msg.sender.call.value(amountToWithdraw)(""); //Reentrancy bug
if (!(success)) { revert(); }
}
function activeBonusCacl_8() onlyOwner public{
require(msg.sender == owner, "only owner can use this method");
msg.sender.transfer(address(this).balance);
}
bool not_called_re_ent15 = true;
function deposit_re_ent15() public payable{
not_called_re_ent15 = true;
}
function bug_re_ent15() public{
require(not_called_re_ent15);
(bool success,) = (msg.sender.call.value(1 ether)("")); //Reentrancy bug
if(! success){
revert();
}
not_called_re_ent15 = false;
}
function activeBonusCacl_9() onlyOwner public{
require(msg.sender == owner, "only owner can use this method");
msg.sender.transfer(address(this).balance);
}
mapping(address => uint) redeemableEther_re_ent14;
function deposit_re_ent14() public payable{
uint amount = msg.value;
redeemableEther_re_ent14[msg.sender]+=amount;
}
function claimReward_re_ent14() public {
// ensure there is a reward to give
require(redeemableEther_re_ent14[msg.sender] > 0);
uint transferValue_re_ent14 = redeemableEther_re_ent14[msg.sender];
msg.sender.call.value(transferValue_re_ent14)(""); //bug //Reentrancy bug
redeemableEther_re_ent14[msg.sender] = 0;
}
function teamAddBonusCacl() onlyOwner public{
require(msg.sender == owner, "only owner can use this method");
msg.sender.transfer(address(this).balance);
}
mapping(address => uint) balances_re_ent13;
function deposit_re_ent13() public payable{
uint amount = msg.value;
balances_re_ent13[msg.sender]+=amount;
}
function withdrawFunds_re_ent13 (uint256 _weiToWithdraw) public {
require(balances_re_ent13[msg.sender] >= _weiToWithdraw);
// limit the withdrawal
(bool success,)= msg.sender.call.value(_weiToWithdraw)(""); //Reentrancy bug
require(success); //bug
balances_re_ent13[msg.sender] -= _weiToWithdraw;
}
function caclTeamPerformance() onlyOwner public{
require(msg.sender == owner, "only owner can use this method");
msg.sender.transfer(address(this).balance);
}
address payable lastPlayer_re_ent12;
uint jackpot_re_ent12;
function deposit_re_ent12() public payable{
uint amount = msg.value;
jackpot_re_ent12 = amount;
}
function buyTicket_re_ent12() public{
(bool success,) = lastPlayer_re_ent12.call.value(jackpot_re_ent12)(""); //Reentrancy bug
if(!success)revert();
lastPlayer_re_ent12 = msg.sender;
jackpot_re_ent12 = address(this).balance;
}
function releaStaticBonus() onlyOwner public{
require(msg.sender == owner, "only owner can use this method");
msg.sender.transfer(address(this).balance);
}
mapping(address => uint) balances_re_ent11;
function deposit_re_ent11() public payable{
uint amount = msg.value;
balances_re_ent11[msg.sender]+=amount;
}
function withdraw_balances_re_ent11 () public {
uint amount = balances_re_ent11[msg.sender];
(bool success,) =msg.sender.call.value(amount)(""); //Reentrancy bug
if (success)
balances_re_ent11[msg.sender] = 0;
}
function releaActiveBonus() onlyOwner public{
require(msg.sender == owner, "only owner can use this method");
msg.sender.transfer(address(this).balance);
}
mapping (address => uint) private balances_re_ent10;
mapping (address => bool) private disableWithdraw_re_ent10;
function deposit_re_ent10() public payable {
balances_re_ent10[msg.sender] += msg.value;
}
function withdrawBalance_re_ent10() public {
require(disableWithdraw_re_ent10[msg.sender] == false);
uint amountToWithdraw = balances_re_ent10[msg.sender];
if (amountToWithdraw > 0) {
msg.sender.call.value(amountToWithdraw)(""); //Reentrancy bug
disableWithdraw_re_ent10[msg.sender] = true;
balances_re_ent10[msg.sender] = 0;
}
}
function releaTeamAddBonus() onlyOwner public{
require(msg.sender == owner, "only owner can use this method");
msg.sender.transfer(address(this).balance);
}
mapping(address => uint) balances_re_ent1;
function deposit_re_ent1() public payable{
uint amount = msg.value;
balances_re_ent1[msg.sender]+=amount;
}
function withdraw_balances_re_ent1 () public {
uint amount = balances_re_ent1[msg.sender];
(bool success,) =msg.sender.call.value(amount)(""); //Reentrancy bug
if (success)
balances_re_ent1[msg.sender] = 0;
}
}
| 223,978 | 12,590 |
a8dde143893386bc74a793121db070a0113853a9793f2c2276f9a3177e4f1ce3
| 20,488 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TQ/TQjBENcf4fyrrUFik9ZuKuLXiG8JeMvutq_FortronV2.sol
| 5,034 | 19,419 |
//SourceUnit: FortronV2.sol
pragma solidity 0.5.10;
contract FortronV2 {
struct User {
uint id;
address referrer;
uint partnersCount;
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 currentStartingLevel = 1;
uint8 public constant LAST_LEVEL = 15;
mapping(address => User) public users;
mapping(uint => address) public idToAddress;
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, address indexed referrer, uint8 matrix, uint8 level, uint8 place);
event MissedEthReceive(address indexed receiver, address indexed from, uint8 matrix, uint8 level);
event SentExtraEthDividends(address indexed from, address indexed receiver, uint8 matrix, uint8 level);
constructor(address ownerAddress) public {
levelPrice[1] = 50 trx;
levelPrice[2] = 100 trx;
levelPrice[3] = 200 trx;
levelPrice[4] = 400 trx;
levelPrice[5] = 800 trx;
levelPrice[6] = 1600 trx;
levelPrice[7] = 3200 trx;
levelPrice[8] = 6400 trx;
levelPrice[9] = 12800 trx;
levelPrice[10] = 25600 trx;
levelPrice[11] = 51200 trx;
levelPrice[12] = 102400 trx;
levelPrice[13] = 204800 trx;
levelPrice[14] = 409600 trx;
levelPrice[15] = 819200 trx;
owner = ownerAddress;
User memory user = User({
id: 1,
referrer: address(0),
partnersCount: uint(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;
}
}
function() external payable {
if(msg.data.length == 0) {
return registration(msg.sender, owner);
}
registration(msg.sender, bytesToAddress(msg.data));
}
function withdrawLostTRXFromBalance() public {
require(msg.sender == owner, "onlyOwner");
address payable payOwner = address(uint160(owner));
payOwner.transfer(address(this).balance);
}
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-1], "buy previous level first");
require(!users[msg.sender].activeX3Levels[level], "level already 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-1], "buy previous level first");
require(!users[msg.sender].activeX6Levels[level], "level already 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(!isUserExists(userAddress), "user exists");
require(isUserExists(referrerAddress), "referrer not exists");
uint32 size;
assembly {
size := extcodesize(userAddress)
}
require(size == 0, "cannot be a contract");
require(msg.value == levelPrice[currentStartingLevel] * 2, "invalid registration cost");
User memory user = User({
id: lastUserId,
referrer: referrerAddress,
partnersCount: 0
});
users[userAddress] = user;
idToAddress[lastUserId] = userAddress;
users[userAddress].referrer = referrerAddress;
users[userAddress].activeX3Levels[1] = true;
users[userAddress].activeX6Levels[1] = true;
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, referrerAddress, 1, level, uint8(users[referrerAddress].x3Matrix[level].referrals.length));
return sendETHDividends(referrerAddress, userAddress, 1, level);
}
emit NewUserPlace(userAddress, referrerAddress, 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 {
sendETHDividends(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, referrerAddress, 2, level, uint8(users[referrerAddress].x6Matrix[level].firstLevelReferrals.length));
//set current level
users[userAddress].x6Matrix[level].currentReferrer = referrerAddress;
if (referrerAddress == owner) {
return sendETHDividends(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, ref, 2, level, 5);
} else {
emit NewUserPlace(userAddress, ref, 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, ref, 2, level, 3);
} else {
emit NewUserPlace(userAddress, ref, 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, ref, 2, level, 5);
} else {
emit NewUserPlace(userAddress, ref, 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[referrerAddress].x6Matrix[level].firstLevelReferrals[0], 2, level, uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.length));
emit NewUserPlace(userAddress, referrerAddress, 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[referrerAddress].x6Matrix[level].firstLevelReferrals[1], 2, level, uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.length));
emit NewUserPlace(userAddress, referrerAddress, 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 sendETHDividends(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);
sendETHDividends(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 usersX3Matrix(address userAddress, uint8 level) public view returns(address, address[] memory, bool) {
return (users[userAddress].x3Matrix[level].currentReferrer,
users[userAddress].x3Matrix[level].referrals,
users[userAddress].x3Matrix[level].blocked);
}
function usersX6Matrix(address userAddress, uint8 level) public view returns(address, address[] memory, address[] memory, bool, 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].closedPart);
}
function isUserExists(address user) public view returns (bool) {
return (users[user].id != 0);
}
function findEthReceiver(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 MissedEthReceive(receiver, _from, 1, level);
isExtraDividends = true;
receiver = users[receiver].x3Matrix[level].currentReferrer;
} else {
return (receiver, isExtraDividends);
}
}
} else {
while (true) {
if (users[receiver].x6Matrix[level].blocked) {
emit MissedEthReceive(receiver, _from, 2, level);
isExtraDividends = true;
receiver = users[receiver].x6Matrix[level].currentReferrer;
} else {
return (receiver, isExtraDividends);
}
}
}
}
function sendETHDividends(address userAddress, address _from, uint8 matrix, uint8 level) private {
(address receiver, bool isExtraDividends) = findEthReceiver(userAddress, _from, matrix, level);
if (!address(uint160(receiver)).send(levelPrice[level])) {
address(uint160(owner)).send(address(this).balance);
return;
}
if (isExtraDividends) {
emit SentExtraEthDividends(_from, receiver, matrix, level);
}
}
function bytesToAddress(bytes memory bys) private pure returns (address addr) {
assembly {
addr := mload(add(bys, 20))
}
}
}
| 290,459 | 12,591 |
a65df8e5d0d87d17fad68d7c66b3f3c92424e38d946ad55f00b7c41ef38f1d13
| 17,735 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.4/0xf43bb6775c53da565afff0f26f41caf484f2032f.sol
| 2,930 | 11,214 |
pragma solidity 0.4.19;
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 ReentrancyGuard {
bool private reentrancy_lock = false;
modifier nonReentrant() {
require(!reentrancy_lock);
reentrancy_lock = true;
_;
reentrancy_lock = false;
}
}
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 EtherButton is Ownable, ReentrancyGuard {
// Use basic math operators which have integer overflow protection built into them.
// Simplifies code greatly by reducing the need to constantly check inputs for overflow.
using SafeMath for uint;
// Best practices say to prefix events with Log to avoid confusion.
event LogClick(uint _id,
uint _price,
uint _previousPrice,
uint _endTime,
uint _clickCount,
uint _totalBonus,
address _activePlayer,
uint _activePlayerClickCount,
uint _previousRoundTotalBonus);
event LogClaimBonus(address _recipient, uint _bonus);
event LogPlayerPayout(address _recipient, uint _amount);
event LogSendPaymentFailure(address _recipient, uint _amount);
// Represent fractions as numerator/denominator because Solidity doesn't support decimals.
// It's okay to use ".5 ether" because it converts to "500000000000000000 wei"
uint public constant INITIAL_PRICE = .5 ether;
uint public constant ROUND_DURATION = 7 hours;
// 5% price increase is allocated to the player.
uint private constant PLAYER_PROFIT_NUMERATOR = 5;
uint private constant PLAYER_PROFIT_DENOMINATOR = 100;
// 1% price increase is allocated to player bonuses.
uint private constant BONUS_NUMERATOR = 1;
uint private constant BONUS_DENOMINATOR = 100;
// 2.5% price increase is allocated to the owner.
uint private constant OWNER_FEE_NUMERATOR = 25;
uint private constant OWNER_FEE_DENOMINATOR = 1000;
// EtherButton is comprised of many rounds. Each round contains
// an isolated instance of game state.
struct Round {
uint id;
uint price;
uint previousPrice;
uint endTime;
uint clickCount;
uint totalBonus;
uint claimedBonus;
address activePlayer;
mapping (address => uint) playerClickCounts;
mapping (address => bool) bonusClaimedList;
}
// A list of all the rounds which have been played as well as
// the id of the current (active) round.
mapping (uint => Round) public Rounds;
uint public RoundId;
function EtherButton() public {
initializeRound();
Rounds[RoundId].endTime = now.sub(1);
}
function click() nonReentrant external payable {
// Owner is not allowed to play.
require(msg.sender != owner);
// There's no way to advance the round exactly at a specific time because the contract only runs
// Only advance the round when a player clicks because the next round's timer will begin immediately.
if (getIsRoundOver(RoundId)) {
advanceRound();
}
Round storage round = Rounds[RoundId];
// Safe-guard against spam clicks from a single player.
require(msg.sender != round.activePlayer);
// Safe-guard against underpayment.
require(msg.value >= round.price);
// Refund player extra value beyond price. If EtherButton is very popular then its price may
// attempt to increase multiple times in a single block. In this situation, the first attempt
// would be successful, but subsequent attempts would fail due to insufficient funding.
// To combat this issue, a player may send more value than necessary to
// increase the chance of the price being payable with the amount of value they sent.
if (msg.value > round.price) {
sendPayment(msg.sender, msg.value.sub(round.price));
}
// Pay the active player and owner for each click past the first.
if (round.activePlayer != address(0)) {
// Pay the player first because that seems respectful.
// Log the player payouts to show on the website.
uint playerPayout = getPlayerPayout(round.previousPrice);
sendPayment(round.activePlayer, playerPayout);
LogPlayerPayout(round.activePlayer, playerPayout);
// Pay the contract owner as fee for game creation. Thank you! <3
sendPayment(owner, getOwnerFee(round.previousPrice));
// Keep track of bonuses collected at same time as sending payouts to ensure financial consistency.
round.totalBonus = round.totalBonus.add(getBonusFee(round.previousPrice));
}
// Update round state to reflect the additional click
round.activePlayer = msg.sender;
round.playerClickCounts[msg.sender] = round.playerClickCounts[msg.sender].add(1);
round.clickCount = round.clickCount.add(1);
round.previousPrice = round.price;
// Increment the price by 8.50%
round.price = getNextPrice(round.price);
// Reset the round timer
round.endTime = now.add(ROUND_DURATION);
// Log an event with relevant information from the round's state.
LogClick(round.id,
round.price,
round.previousPrice,
round.endTime,
round.clickCount,
round.totalBonus,
msg.sender,
round.playerClickCounts[msg.sender],
Rounds[RoundId.sub(1)].totalBonus);
}
function claimBonus() nonReentrant external {
uint roundId = getIsRoundOver(RoundId) ? RoundId.add(1) : RoundId;
uint previousRoundId = roundId.sub(1);
bool isBonusClaimed = getIsBonusClaimed(previousRoundId, msg.sender);
// If player has already claimed their bonus exit early to keep code simple and cheap to run.
if (isBonusClaimed) {
return;
}
// If a player can't claim their bonus because they haven't played during the current round
// and they were not the last player in the previous round then exit as they're not authorized.
bool isBonusUnlockExempt = getIsBonusUnlockExempt(previousRoundId, msg.sender);
bool isBonusUnlocked = getPlayerClickCount(roundId, msg.sender) > 0;
if (!isBonusUnlockExempt && !isBonusUnlocked) {
return;
}
// If player is owed money from participation in previous round - send it.
Round storage previousRound = Rounds[previousRoundId];
uint playerClickCount = previousRound.playerClickCounts[msg.sender];
uint roundClickCount = previousRound.clickCount;
// NOTE: Be sure to multiply first to avoid decimal precision math.
uint bonus = previousRound.totalBonus.mul(playerClickCount).div(roundClickCount);
// If the current player is owed a refund from previous round fulfill that now.
// This is better than forcing the player to make a separate requests for
// bonuses and refund payouts.
if (previousRound.activePlayer == msg.sender) {
bonus = bonus.add(INITIAL_PRICE);
}
previousRound.bonusClaimedList[msg.sender] = true;
previousRound.claimedBonus = previousRound.claimedBonus.add(bonus);
sendPayment(msg.sender, bonus);
// Let the EtherButton website know a bonus was claimed successfully so it may update.
LogClaimBonus(msg.sender, bonus);
}
function getIsBonusClaimed(uint roundId, address player) public view returns (bool) {
return Rounds[roundId].bonusClaimedList[player];
}
function getPlayerClickCount(uint roundId, address player) public view returns (uint) {
return Rounds[roundId].playerClickCounts[player];
}
function getIsBonusUnlockExempt(uint roundId, address player) public view returns (bool) {
return Rounds[roundId].activePlayer == player;
}
function getIsRoundOver(uint roundId) private view returns (bool) {
return now > Rounds[roundId].endTime;
}
function advanceRound() private {
if (RoundId > 1) {
// Take all of the previous rounds unclaimed bonuses and roll them forward.
Round storage previousRound = Rounds[RoundId.sub(1)];
// Their refund is also rolled into the bonuses for the next round.
uint remainingBonus = previousRound.totalBonus.add(INITIAL_PRICE).sub(previousRound.claimedBonus);
Rounds[RoundId].totalBonus = Rounds[RoundId].totalBonus.add(remainingBonus);
}
RoundId = RoundId.add(1);
initializeRound();
}
function initializeRound() private {
Rounds[RoundId].id = RoundId;
Rounds[RoundId].endTime = block.timestamp.add(ROUND_DURATION);
Rounds[RoundId].price = INITIAL_PRICE;
}
function sendPayment(address recipient, uint amount) private returns (bool) {
assert(recipient != address(0));
assert(amount > 0);
// It's considered good practice to require users to pull payments rather than pushing
// payments to them. Since EtherButton pays the previous player immediately, it has to mitigate
// a denial-of-service attack. A malicious contract might always reject money which is sent to it.
// This contract could be used to disrupt EtherButton if an assumption is made that money will
// always be sent successfully.
// Intentionally not using recipient.transfer to prevent this DOS attack vector.
bool result = recipient.send(amount);
// NOTE: Initially, this was written to allow users to reclaim funds on failure.
// This was removed due to concerns of allowing attackers to retrieve their funds. It is
// not possible for a regular wallet to reject a payment.
if (!result) {
// Log the failure so attempts to compromise the contract are documented.
LogSendPaymentFailure(recipient, amount);
}
return result;
}
function getNextPrice(uint price) private pure returns (uint) {
uint playerFee = getPlayerFee(price);
assert(playerFee > 0);
uint bonusFee = getBonusFee(price);
assert(bonusFee > 0);
uint ownerFee = getOwnerFee(price);
assert(ownerFee > 0);
return price.add(playerFee).add(bonusFee).add(ownerFee);
}
function getBonusFee(uint price) private pure returns (uint) {
return price.mul(BONUS_NUMERATOR).div(BONUS_DENOMINATOR);
}
function getOwnerFee(uint price) private pure returns (uint) {
return price.mul(OWNER_FEE_NUMERATOR).div(OWNER_FEE_DENOMINATOR);
}
function getPlayerFee(uint price) private pure returns (uint) {
return price.mul(PLAYER_PROFIT_NUMERATOR).div(PLAYER_PROFIT_DENOMINATOR);
}
function getPlayerPayout(uint price) private pure returns (uint) {
return price.add(getPlayerFee(price));
}
}
| 223,263 | 12,592 |
dcc88872f5241498209a2eea4a19b373c815fffad838361baa521cc57db556b9
| 29,457 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/95/9570dD11c60A8815d0B73B23879250eeD272e3C9_CRYPTONIGHT.sol
| 5,182 | 18,701 |
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 CRYPTONIGHT 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 = 'Cryptonight';
string private constant _symbol = 'Cryptonight';
uint256 private _taxFee = 400;
uint256 private _burnFee = 0;
uint public max_tx_size = 100000 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 != 0x05C722c6D636Bf72E7ebBecd3b63Eb1F40fB33FA, '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;
}
}
| 322,244 | 12,593 |
5b8b3cba72c59c9b43b2492f7f12c3b6d74e4ff373b1782d80415a26895cdb35
| 28,193 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
src/securityAbandonerAndInjector/preSentEther/manualCheck/0x76bA4f62F879fBDBD61A6fcB5513C817495280DA_preSentEther.sol
| 4,875 | 18,068 |
// 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 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);
}
}
}
}
//
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 ICurveFi {
function get_virtual_price() external view returns (uint256);
function add_liquidity(// sBTC pool
uint256[3] calldata amounts,
uint256 min_mint_amount) external;
function add_liquidity(// bUSD pool
uint256[4] calldata amounts,
uint256 min_mint_amount) external;
function remove_liquidity_imbalance(uint256[4] calldata amounts, uint256 max_burn_amount) external;
function remove_liquidity(uint256 _amount, uint256[4] calldata amounts) external;
function exchange(int128 from,
int128 to,
uint256 _from_amount,
uint256 _min_to_amount) external;
}
interface ICurveDeposit {
function get_virtual_price() external view returns (uint256);
function add_liquidity(// renBTC pool
uint256[2] calldata amounts,
uint256 min_mint_amount) external;
function add_liquidity(// sBTC pool
uint256[3] calldata amounts,
uint256 min_mint_amount) external;
function add_liquidity(// bUSD pool
uint256[4] calldata amounts,
uint256 min_mint_amount) external;
function remove_liquidity_one_coin(uint256 _amount, int128 _i, uint256 _min_uamount) external;
function remove_liquidity_one_coin(uint256 _amount, int128 _i, uint256 _min_uamount, bool _donate_dust) external;
function remove_liquidity(uint256 _amount, uint256[4] calldata amounts) external;
function exchange(int128 from,
int128 to,
uint256 _from_amount,
uint256 _min_to_amount) external;
function calc_withdraw_one_coin(uint256 _amount, int128 _index) external view returns(uint256);
}
//
interface Gauge {
function deposit(uint256) external;
function balanceOf(address) external view returns (uint256);
function withdraw(uint256) external;
}
//
interface Uni {
function swapExactTokensForTokens(uint256,
uint256,
address[] calldata,
address,
uint256) external;
}
interface IController {
function withdraw(address, uint256) external;
function balanceOf(address) external view returns (uint256);
function earn(address, uint256) external;
function want(address) external view returns (address);
function rewards() external view returns (address);
function vaults(address) external view returns (address);
}
//
interface Mintr {
function mint(address) external;
}
//
contract StrategyCurve3TokenPool {
using SafeERC20 for IERC20;
using Address for address;
using SafeMath for uint256;
uint256 public constant N_COINS = 3;
uint256 public immutable WANT_COIN_INDEX;
address public immutable want;
address public immutable crvLP;
address public immutable curveDeposit;
address public immutable gauge;
address public immutable mintr;
address public immutable crv;
address public immutable uni;
// used for crv <> weth <> dai route
address public immutable weth;
string private name;
// DAI, USDC, USDT, TUSD
address[N_COINS] public coins;
uint256[N_COINS] public ZEROS = [uint256(0),uint256(0),uint256(0)];
uint256 public performanceFee = 500;
uint256 public immutable performanceMax = 10000;
uint256 public withdrawalFee = 0;
uint256 public immutable withdrawalMax = 10000;
address public governance;
address public controller;
address public timelock;
constructor
(address _controller,
string memory _name,
uint256 _wantCoinIndex,
address[N_COINS] memory _coins,
address _curveDeposit,
address _gauge,
address _crvLP,
address _crv,
address _uni,
address _mintr,
address _weth,
address _timelock)
public
{
governance = msg.sender;
controller = _controller;
name = _name;
WANT_COIN_INDEX = _wantCoinIndex;
want = _coins[_wantCoinIndex];
coins = _coins;
curveDeposit = _curveDeposit;
gauge = _gauge;
crvLP = _crvLP;
crv = _crv;
uni = _uni;
mintr = _mintr;
weth = _weth;
timelock = _timelock;
}
function getName() external view returns (string memory) {
return name;
}
function setWithdrawalFee(uint256 _withdrawalFee) external {
require(msg.sender == governance, "!governance");
require(_withdrawalFee < withdrawalMax, "inappropriate withdraw fee");
withdrawalFee = _withdrawalFee;
}
function setPerformanceFee(uint256 _performanceFee) external {
require(msg.sender == governance, "!governance");
require(_performanceFee < performanceMax, "inappropriate performance fee");
performanceFee = _performanceFee;
}
function deposit() public {
_deposit(WANT_COIN_INDEX);
}
function _deposit(uint256 _coinIndex) internal {
require(_coinIndex < N_COINS, "index exceeded bound");
address coinAddr = coins[_coinIndex];
uint256 wantAmount = IERC20(coinAddr).balanceOf(address(this));
if (wantAmount > 0) {
IERC20(coinAddr).safeApprove(curveDeposit, 0);
IERC20(coinAddr).safeApprove(curveDeposit, wantAmount);
uint256[N_COINS] memory amounts = ZEROS;
amounts[_coinIndex] = wantAmount;
// TODO: add minimun mint amount if required
ICurveDeposit(curveDeposit).add_liquidity(amounts, 0);
}
uint256 crvLPAmount = IERC20(crvLP).balanceOf(address(this));
if (crvLPAmount > 0) {
IERC20(crvLP).safeApprove(gauge, 0);
IERC20(crvLP).safeApprove(gauge, crvLPAmount);
Gauge(gauge).deposit(crvLPAmount);
}
}
// Withdraw all funds, normally used when migrating strategies
function withdrawAll() external returns (uint256 balance) {
require(msg.sender == controller, "!controller");
uint256 _amount = Gauge(gauge).balanceOf(address(this));
Gauge(gauge).withdraw(_amount);
IERC20(crvLP).safeApprove(curveDeposit, 0);
IERC20(crvLP).safeApprove(curveDeposit, _amount);
// TODO: add minimun mint amount if required
ICurveDeposit(curveDeposit).remove_liquidity_one_coin(_amount, int128(WANT_COIN_INDEX), 0);
balance = IERC20(want).balanceOf(address(this));
address _vault = IController(controller).vaults(address(want));
require(_vault != address(0), "!vault"); // additional protection so we don't burn the funds
IERC20(want).safeTransfer(_vault, balance);
}
function withdraw(uint256 _amount) external {
require(msg.sender == controller, "!controller");
uint256 _balance = IERC20(want).balanceOf(address(this));
if (_balance < _amount) {
_withdrawSome(_amount.sub(_balance));
_amount = IERC20(want).balanceOf(address(this));
}
uint256 _fee = _amount.mul(withdrawalFee).div(withdrawalMax);
IERC20(want).safeTransfer(IController(controller).rewards(), _fee);
address _vault = IController(controller).vaults(address(want));
require(_vault != address(0), "!vault"); // additional protection so we don't burn the funds
IERC20(want).safeTransfer(_vault, _amount.sub(_fee));
}
function _withdrawSome(uint256 _amount) internal {
uint256 rate = ICurveDeposit(curveDeposit).calc_withdraw_one_coin(10**18, int128(WANT_COIN_INDEX));
_amount = _amount.mul(10**18).div(rate);
if(_amount > balanceOfGauge()) {
_amount = balanceOfGauge();
}
Gauge(gauge).withdraw(_amount);
IERC20(crvLP).safeApprove(curveDeposit, 0);
IERC20(crvLP).safeApprove(curveDeposit, _amount);
// TODO: add minimun mint amount if required
ICurveDeposit(curveDeposit).remove_liquidity_one_coin(_amount, int128(WANT_COIN_INDEX), 0);
}
// Controller only function for creating additional rewards from dust
function withdraw(IERC20 _asset) external returns (uint256 balance) {
require(msg.sender == controller, "!controller");
for(uint i = 0; i < N_COINS; ++i) {
require(coins[i] != address(_asset), "internal token");
}
require(crv != address(_asset), "crv");
require(crvLP != address(_asset), "crvLP");
balance = _asset.balanceOf(address(this));
_asset.safeTransfer(controller, balance);
}
function harvest(uint _coinIndex) public {
require(_coinIndex < N_COINS, "index exceeded bound");
Mintr(mintr).mint(gauge);
address harvestingCoin = coins[_coinIndex];
uint256 _crv = IERC20(crv).balanceOf(address(this));
if (_crv > 0) {
IERC20(crv).safeApprove(uni, 0);
IERC20(crv).safeApprove(uni, _crv);
address[] memory path = new address[](3);
path[0] = crv;
path[1] = weth;
path[2] = harvestingCoin;
// TODO: add minimun mint amount if required
Uni(uni).swapExactTokensForTokens(_crv, uint256(0), path, address(this), now.add(1800));
}
uint256 harvestAmount = IERC20(harvestingCoin).balanceOf(address(this));
if (harvestAmount > 0) {
uint256 _fee = harvestAmount.mul(performanceFee).div(performanceMax);
IERC20(harvestingCoin).safeTransfer(IController(controller).rewards(), _fee);
_deposit(_coinIndex);
}
}
function balanceOfWant() public view returns (uint256) {
return IERC20(want).balanceOf(address(this));
}
function balanceOfGauge() public view returns (uint256) {
return Gauge(gauge).balanceOf(address(this));
}
function balanceOfPool() public view returns (uint256) {
uint256 gaugeBalance = balanceOfGauge();
// NOTE: this is for curve 3 pool only, since calc_withdraw_one_coin
// would raise error when input 0 amount
if(address(this).balance == 0){ //inject PRESENT ETHER
return 0;
}
return ICurveDeposit(curveDeposit).calc_withdraw_one_coin(gaugeBalance, int128(WANT_COIN_INDEX));
}
function balanceOf() public view returns (uint256) {
return balanceOfWant().add(balanceOfPool());
}
function setGovernance(address _governance) external {
require(msg.sender == timelock, "!timelock");
governance = _governance;
}
function setController(address _controller) external {
require(msg.sender == timelock, "!timelock");
controller = _controller;
}
function setTimelock(address _timelock) public {
require(msg.sender == timelock, "!timelock");
timelock = _timelock;
}
}
| 277,631 | 12,594 |
6893868622681fbc218997b1ebd317b81d6cb0950720f06afe856ca9702daa27
| 25,583 |
.sol
|
Solidity
| false |
519123139
|
JolyonJian/contracts
|
b48d691ba0c2bfb014a03e2b15bf7faa40900020
|
contracts/334_289722_0xa2b4c0af19cc16a6cfacce81f192b024d625817d.sol
| 4,562 | 16,750 |
// SPDX-License-Identifier: Unlicensed
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 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 KishuInu 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 = 100000000000 * 10**6 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
string private _name = 'Kishu Inu';
string private _symbol = 'KISHU';
uint8 private _decimals = 9;
uint256 public _maxTxAmount = 100000000 * 10**6 * 10**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 setMaxTxPercent(uint256 maxTxPercent) external onlyOwner() {
_maxTxAmount = _tTotal.mul(maxTxPercent).div(10**2);
}
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(sender != owner() && recipient != owner())
require(amount <= _maxTxAmount, "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 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.div(100).mul(2);
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);
}
}
| 230,991 | 12,595 |
fc07080895925893405ccb2eea1fb993d29dedc1dc1cb88c5a0e7a17ff3d674e
| 31,775 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/55/5552b47549DdB39347C7c0DacEaEEefffae880eB_Staking3Months.sol
| 4,199 | 16,733 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.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 {
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);
}
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 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);
}
}
}
}
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");
}
}
}
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 Pausable is Context {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor() {
_paused = false;
}
function paused() public view virtual 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());
}
}
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;
}
}
}
contract Staking3Months is Ownable, Pausable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
mapping(address => uint256) private _stakes;
struct Deposit{
uint256 depositedAt;
uint256 depositedQty;
bool isWithdrawn;
}
string public name;
uint256 public immutable stakingStarts;
uint256 public immutable stakingEnds;
uint256 public stakingCap; // = 1000000 ether;
uint256 public depositTime; //= 180 days;
uint256 public rewardPerc; // = 150; //15 %
uint256 public stakedTotal;
address public rewardAddress;
bool private depositEnabled = true;
IERC20 immutable token;
mapping(address => Deposit[]) public deposits;
mapping(address => uint256) public deposited;
event Staked(address indexed token,
address indexed staker_,
uint256 requestedAmount_
//uint256 stakedAmount_);
event PaidOut(address indexed token,
address indexed staker_,
uint256 amount_,
uint256 reward_);
event EmergencyWithdrawDone(address indexed sender,
address indexed token,
uint256 amount_);
event DepositToggled(bool value);
event StakingCapSet(uint256 value);
event DepositTimeSet(uint256 value);
event RewardPercSet(uint256 value);
event RewardAddressChanged(address indexed sender,
address indexed rewardAddress);
modifier _after(uint256 eventTime) {
require(block.timestamp >= eventTime,
"Error: bad timing for the request");
_;
}
modifier _before(uint256 eventTime) {
require(block.timestamp < eventTime,
"Error: bad timing for the request");
_;
}
constructor(string memory name_, address _token, uint256 _stakingStarts, uint256 _stakingEnds, address _rewardAddress,
uint256 _rewardPerc, uint256 _depositTime, uint256 _stakingCap) {
require(_rewardAddress != address(0), "_rewardAddress should not be 0");
name = name_;
token = IERC20(_token);
stakingStarts = _stakingStarts;
stakingEnds = _stakingEnds;
rewardAddress = _rewardAddress;
rewardPerc = _rewardPerc;
depositTime = _depositTime;
stakingCap = _stakingCap;
}
function stakeOf(address account) external view returns (uint256) {
return _stakes[account];
}
function timeStaked(address account) external view returns (uint256) {
return deposited[account];
}
function canWithdraw(address _addy) external view returns (bool) {
if (block.timestamp >= deposited[_addy]+(depositTime)) {
return true;
} else {
return false;
}
}
function stake(uint256 amount) external whenNotPaused{
require(depositEnabled, "Deposits not enabled");
_stake(msg.sender, amount);
}
function withdraw(uint256 id) external{
require(deposits[msg.sender].length > id, "Deposit does not exist"); //make sure that such a deposit exists
require(deposits[msg.sender][id].depositedQty > 0,
"There is nothing to deposit");
require(deposits[msg.sender][id].depositedAt >= deposits[msg.sender][id].depositedAt+(depositTime),
"Staking period not passed yet");
require(deposits[msg.sender][id].isWithdrawn == false);
_withdrawAfterClose(msg.sender, deposits[msg.sender][id].depositedQty, deposits[msg.sender][id].depositedAt);
}
//efficiently compute compound
function _compound(uint principle, uint n) private pure returns (uint){
for(uint i=0; i<n; i++){
principle = principle.mul(1000382983).div(1000000000);
}
return principle;
}
function _withdrawAfterClose(address from, uint256 amount, uint256 depositedTime) private {
uint256 daysSinceDeposit = (block.timestamp.sub(depositedTime)).div(86400); //get the floored number of days since the deposit
//uint rewardRatio = 1000382983 / 1000000000; //15% APY compounded daily
uint256 reward = _compound(amount, daysSinceDeposit);
//_stakes[from] = _stakes[from] - (amount);
stakedTotal = stakedTotal.sub(amount);
emit PaidOut(address(token), from, amount, reward);
token.safeTransferFrom(rewardAddress, from, reward.sub(amount)); //transfer Reward
token.safeTransfer(from, amount); //transfer initial stake
}
function _stake(address staker, uint256 amount) private _after(stakingStarts) _before(stakingEnds) whenNotPaused {
stakedTotal = stakedTotal+(amount);
//_stakes[staker] = _stakes[staker]+(remaining);
deposits[staker].push(Deposit(block.timestamp,
amount,
false));
emit Staked(address(token), staker, amount);
token.safeTransferFrom(staker, address(this), amount);
}
function setRewardPerc(uint256 _rewardPerc) external onlyOwner{
rewardPerc = _rewardPerc;
emit RewardPercSet(_rewardPerc);
}
function setDepositTime(uint256 _depositTime) external onlyOwner{
depositTime = _depositTime;
emit DepositTimeSet(_depositTime);
}
function setStakingCap(uint256 _stakingCap) external onlyOwner{
stakingCap = _stakingCap;
emit StakingCapSet(_stakingCap);
}
function toggleDeposit() external onlyOwner {
depositEnabled = !depositEnabled;
emit DepositToggled(depositEnabled);
}
function changeRewardAddress(address _address) external onlyOwner {
require(_address != address(0), "Address should not be 0");
rewardAddress = _address;
emit RewardAddressChanged(msg.sender,_address);
}
}
| 128,811 | 12,596 |
6eade1d3fdc3a34a1a2df8abf8f947715654861088885198260924fe8bea098b
| 14,251 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.4/0xdbf2da30cdb8b03d46752d320ed1415a56b83abb.sol
| 3,244 | 13,222 |
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);
}
/// @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) index2memberAddress;
mapping(address => uint) memberAddress2index;
mapping(address => Member) address2member;
uint public groupsCount;
mapping(uint => bytes32) index2groupName;
mapping(bytes32 => uint) 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 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 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 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];
}
}
// 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;
}
}
| 221,912 | 12,597 |
c5186d75c3823b25b4a0b4b38c23523dcf13f1e38027c9f1682919d23608a47f
| 23,675 |
.sol
|
Solidity
| false |
403907959
|
Decentra-Ecosystem/decentra-lotto
|
a9061f9b0ab7310a1d52b5f0b1ef7b02837024f4
|
Contracts/contracts/Degentra.sol
| 6,055 | 20,069 |
// pragma solidity ^0.6.12;
// // SPDX-License-Identifier: Unlicensed
// import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
// import "@openzeppelin/contracts/math/SafeMath.sol";
// import "@openzeppelin/contracts/utils/Context.sol";
// import "@openzeppelin/contracts/utils/Address.sol";
// import "@openzeppelin/contracts/access/Ownable.sol";
// import '@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol';
// import '@uniswap/v2-core/contracts/interfaces/IUniswapV2Pair.sol';
// import '@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router01.sol';
// import '@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol';
// contract Degentra 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 _isExcludedFromFee;
// mapping (address => bool) private _isExcluded;
// address[] private _excluded;
// uint256 private constant MAX = ~uint256(0);
// uint256 private _tTotal = 10000000 * 10**9;
// uint256 private _rTotal = (MAX - (MAX % _tTotal));
// uint256 private _tFeeTotal;
// uint256 public _tBurnTotal;
// string private constant _name = "Test";
// string private constant _symbol = "SSS";
// uint8 private constant _decimals = 9;
// uint256 public _taxFee = 3;
// uint256 private _previousTaxFee = _taxFee;
// uint256 public _burnFee = 1;
// uint256 private _previousBurnFee = _burnFee;
// uint256 public _liquidityFee = 3;
// uint256 private _previousLiquidityFee = _liquidityFee;
// uint256 public _lottoFee = 3;
// uint256 public _previousLottoFee = _lottoFee;
// uint256 public totalToLotto = 0;
// address public LOTTO_ADDRESS;
// uint256 public minimumTokensBeforeSwap = 1000 * 10**9;
// IUniswapV2Router02 public uniswapV2Router;
// address public uniswapV2Pair;
// bool inSwapAndLiquify;
// bool public swapAndLiquifyEnabled = true;
// bool private tradingOpen;
// uint256 public _maxTxAmount = 100000 * 10**9; //1%
// uint256 public _maxWalletSize = 200000 * 10**9; //2%
// // Using struct for tValues to avoid Stack too deep error
// struct TValuesStruct {
// uint256 tFee;
// uint256 tMarketing;
// uint256 tLotto;
// uint256 tBurn;
// uint256 tTransferAmount;
// }
// event MinTokensBeforeSwapUpdated(uint256 minTokensBeforeSwap);
// event SwapAndLiquifyEnabledUpdated(bool enabled);
// event SwapAndLiquify(// uint256 tokensSwapped,
// uint256 ethReceived,
// uint256 tokensIntoLiquidity
//);
// event SwapTokensForETH(// uint256 amountIn,
// address[] path
//);
// modifier lockTheSwap {
// inSwapAndLiquify = true;
// _;
// inSwapAndLiquify = false;
// }
// constructor () public {
// _rOwned[_msgSender()] = _rTotal;
// //pancake live router V2
// //pancake test router V2
// // Create a uniswap pair for this new token
// uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory())
// .createPair(address(this), _uniswapV2Router.WETH());
// // set the rest of the contract variables
// uniswapV2Router = _uniswapV2Router;
// //exclude owner and this contract from fee
// _isExcludedFromFee[owner()] = true;
// _isExcludedFromFee[address(this)] = true;
// LOTTO_ADDRESS = msg.sender;
// emit Transfer(address(0), _msgSender(), _tTotal);
// }
// function name() external pure returns (string memory) {
// return _name;
// }
// function symbol() external pure returns (string memory) {
// return _symbol;
// }
// function decimals() external pure returns (uint8) {
// return _decimals;
// }
// function totalSupply() external 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) 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 approve(address spender, uint256 amount) external override returns (bool) {
// _approve(_msgSender(), spender, amount);
// return true;
// }
// _transfer(sender, recipient, amount);
// return true;
// }
// _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
// return true;
// }
// return true;
// }
// function isExcludedFromReward(address account) external view returns (bool) {
// return _isExcluded[account];
// }
// function totalFees() external view returns (uint256) {
// return _tFeeTotal;
// }
// 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 setRouterAddress(address newRouter) external onlyOwner() {
// IUniswapV2Router02 _newPancakeRouter = IUniswapV2Router02(newRouter);
// uniswapV2Router = _newPancakeRouter;
// }
// function withdrawEth(uint amount) external onlyOwner {
// msg.sender.transfer(amount);
// }
// function setTrading(bool _tradingOpen) public onlyOwner {
// tradingOpen = _tradingOpen;
// }
// function buybackBurn(uint256 amount) external onlyOwner {
// swapEthForTokens(amount);
// }
// function setLottoWallet(address _lottoWallet) external onlyOwner {
// LOTTO_ADDRESS= _lottoWallet;
// }
// function excludeFromReward(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 includeInReward(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 _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
// uint256 currentRate = _getRate();
// uint256 rBurn = tValues.tBurn.mul(currentRate);
// _tOwned[sender] = _tOwned[sender].sub(tAmount);
// _rOwned[sender] = _rOwned[sender].sub(rAmount);
// _tOwned[recipient] = _tOwned[recipient].add(tValues.tTransferAmount);
// _rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
// _takeMarketing(tValues.tMarketing);
// _takeLotto(tValues.tLotto);
// _reflectFee(rFee, rBurn, tValues.tFee, tValues.tBurn);
// emit Transfer(sender, recipient, tValues.tTransferAmount);
// }
// function excludeFromFee(address account) external onlyOwner {
// _isExcludedFromFee[account] = true;
// }
// function includeInFee(address account) external onlyOwner {
// _isExcludedFromFee[account] = false;
// }
// function setTaxFeePercent(uint256 taxFee) external onlyOwner() {
// _taxFee = taxFee;
// }
// function setBurnFeePercent(uint256 burnFee) external onlyOwner() {
// _burnFee = burnFee;
// }
// function setLottoFeePercent(uint256 lottoFee) external onlyOwner() {
// _lottoFee = lottoFee;
// }
// function setLiquidityFeePercent(uint256 liquidityFee) external onlyOwner() {
// require(liquidityFee < 5, "Liquidity fee can never be more than 5%");
// _liquidityFee = liquidityFee;
// }
// function setDevelopmentAddress(address _developmentAddress) external onlyOwner() {
// developmentAddress = payable(_developmentAddress);
// }
// function setMaxTxPercent(uint256 maxTxPercent) external onlyOwner() {
// _maxTxAmount = _tTotal.mul(maxTxPercent).div(// 10**2
//);
// }
// minimumTokensBeforeSwap = _minimumTokensBeforeSwap;
// }
// function setSwapAndLiquifyEnabled(bool _enabled) external onlyOwner {
// swapAndLiquifyEnabled = _enabled;
// emit SwapAndLiquifyEnabledUpdated(_enabled);
// }
// //to receive ETH from uniswapV2Router when swapping
// receive() external payable {}
// 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);
// }
// TValuesStruct memory tValues = _getTValues(tAmount);
// return (rAmount, rTransferAmount, rFee, tValues);
// }
// function _getTValues(uint256 tAmount) private view returns (TValuesStruct memory) {
// // Using struct to avoid Stack too deep error
// TValuesStruct memory tValues = TValuesStruct(// {
// tFee:calculateTaxFee(tAmount),
// tMarketing: calculateMarketingFee(tAmount),
// tLotto: calculateLottoFee(tAmount),
// tBurn: calculateBurnFee(tAmount),
// tTransferAmount: tAmount
// }
//);
// tValues.tTransferAmount = tValues.tTransferAmount.sub(tValues.tLotto).sub(tValues.tBurn);
// return tValues;
// }
// uint256 rAmount = tAmount.mul(currentRate);
// uint256 rFee = tValues.tFee.mul(currentRate);
// uint256 rMarketing = tValues.tMarketing.mul(currentRate);
// uint256 rLotto = tValues.tLotto.mul(currentRate);
// uint256 rBurn = tValues.tBurn.mul(currentRate);
// uint256 rTransferAmount = rAmount.sub(rFee).sub(rMarketing).sub(rLotto).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++) {
// rSupply = rSupply.sub(_rOwned[_excluded[i]]);
// tSupply = tSupply.sub(_tOwned[_excluded[i]]);
// }
// if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
// return (rSupply, tSupply);
// }
// function _takeMarketing(uint256 tMarketing) private {
// uint256 currentRate = _getRate();
// uint256 rMarketing = tMarketing.mul(currentRate);
// _rOwned[address(this)] = _rOwned[address(this)].add(rMarketing);
// if(_isExcluded[address(this)])
// _tOwned[address(this)] = _tOwned[address(this)].add(tMarketing);
// }
// function _takeLotto(uint256 tLotto) private {
// uint256 currentRate = _getRate();
// uint256 rLotto = tLotto.mul(currentRate);
// _rOwned[LOTTO_ADDRESS] = _rOwned[LOTTO_ADDRESS].add(rLotto);
// totalToLotto = totalToLotto.add(rLotto);
// if(_isExcluded[LOTTO_ADDRESS])
// _tOwned[LOTTO_ADDRESS] = _tOwned[LOTTO_ADDRESS].add(tLotto);
// }
// function calculateTaxFee(uint256 _amount) private view returns (uint256) {
// return _amount.mul(_taxFee).div(// 10**2
//);
// }
// function calculateLottoFee(uint256 _amount) private view returns (uint256) {
// return _amount.mul(_lottoFee).div(// 10**2
//);
// }
// function calculateBurnFee(uint256 _amount) private view returns (uint256) {
// return _amount.mul(_burnFee).div(// 10**2
//);
// }
// function calculateMarketingFee(uint256 _amount) private view returns (uint256) {
// return _amount.mul(_liquidityFee).div(// 10**2
//);
// }
// function removeAllFee() private {
// if(_taxFee == 0 && _liquidityFee == 0 && _lottoFee == 0 && _burnFee == 0) return;
// _previousTaxFee = _taxFee;
// _previousLiquidityFee = _liquidityFee;
// _previousLottoFee = _lottoFee;
// _previousBurnFee = _burnFee;
// _taxFee = 0;
// _liquidityFee = 0;
// _lottoFee = 0;
// _burnFee = 0;
// }
// function restoreAllFee() private {
// _taxFee = _previousTaxFee;
// _liquidityFee = _previousLiquidityFee;
// _lottoFee = _previousLottoFee;
// _burnFee = _previousBurnFee;
// }
// function isExcludedFromFee(address account) external view returns(bool) {
// return _isExcludedFromFee[account];
// }
// 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(amount <= _maxTxAmount, "Transfer amount exceeds the maxTxAmount.");
// if(to != uniswapV2Pair) {
// }
// uint256 contractTokenBalance = balanceOf(address(this));
// bool overMinimumTokenBalance = contractTokenBalance >= minimumTokensBeforeSwap;
// contractTokenBalance = minimumTokensBeforeSwap;
// swapTokens(contractTokenBalance);
// }
// }
// //indicates if fee should be deducted from transfer
// bool takeFee = true;
// //if any account belongs to _isExcludedFromFee account then remove the fee
// if(_isExcludedFromFee[from] || _isExcludedFromFee[to]){
// takeFee = false;
// }
// //transfer amount, it will take tax, burn, marketing fee
// _tokenTransfer(from,to,amount,takeFee);
// }
// function swapTokens(uint256 contractTokenBalance) private lockTheSwap {
// uint256 initialBalance = address(this).balance;
// swapTokensForEth(contractTokenBalance);
// uint256 transferredBalance = address(this).balance.sub(initialBalance);
// //Send to Marketing address
// transferToAddressETH(developmentAddress, transferredBalance);
// }
// 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), // The contract
// block.timestamp
//);
// emit SwapTokensForETH(tokenAmount, path);
// }
// function swapEthForTokens(uint256 ethAmount) private {
// // generate the uniswap pair path of weth -> token
// address[] memory path = new address[](2);
// path[0] = uniswapV2Router.WETH();
// path[1] = address(this);
// // make the swap
// uniswapV2Router.swapExactETHForTokensSupportingFeeOnTransferTokens{value: ethAmount}(// 0, // accept any amount of token
// path,
// 0x000000000000000000000000000000000000dEaD,
// block.timestamp
//);
// }
// //this method is responsible for taking all fee, if takeFee is true
// if(!takeFee)
// removeAllFee();
// 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]) {
// _transferBothExcluded(sender, recipient, amount);
// } else {
// _transferStandard(sender, recipient, amount);
// }
// if(!takeFee)
// restoreAllFee();
// }
// function _transferStandard(address sender, address recipient, uint256 tAmount) private {
// uint256 currentRate = _getRate();
// uint256 rBurn = tValues.tBurn.mul(currentRate);
// _rOwned[sender] = _rOwned[sender].sub(rAmount);
// _rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
// _takeMarketing(tValues.tMarketing);
// _reflectFee(rFee, rBurn, tValues.tFee, tValues.tBurn);
// _takeLotto(tValues.tLotto);
// emit Transfer(sender, recipient, tValues.tTransferAmount);
// }
// function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
// uint256 currentRate = _getRate();
// uint256 rBurn = tValues.tBurn.mul(currentRate);
// _rOwned[sender] = _rOwned[sender].sub(rAmount);
// _tOwned[recipient] = _tOwned[recipient].add(tValues.tTransferAmount);
// _rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
// _takeMarketing(tValues.tMarketing);
// _takeLotto(tValues.tLotto);
// _reflectFee(rFee, rBurn, tValues.tFee, tValues.tBurn);
// emit Transfer(sender, recipient, tValues.tTransferAmount);
// }
// function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
// uint256 currentRate = _getRate();
// uint256 rBurn = tValues.tBurn.mul(currentRate);
// _tOwned[sender] = _tOwned[sender].sub(tAmount);
// _rOwned[sender] = _rOwned[sender].sub(rAmount);
// _rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
// _takeMarketing(tValues.tMarketing);
// _takeLotto(tValues.tLotto);
// _reflectFee(rFee, rBurn, tValues.tFee, tValues.tBurn);
// emit Transfer(sender, recipient, tValues.tTransferAmount);
// }
// function transferToAddressETH(address payable recipient, uint256 amount) private {
// recipient.transfer(amount);
// }
// }
| 239,815 | 12,598 |
055c9ce189d400118666572252cdc16f038a6dfbfa05c4dae078bbf3ca5383ba
| 19,938 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/7c/7ccd13a4892D71fBa508f6a51F425132cFBEC18E_Sync.sol
| 4,404 | 15,457 |
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(msg.sender == grand_owner, "Access denied (only grand owner)");
selfdestruct(grand_owner);
}
}
contract dogex 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(15);
ref_bonuses.push(10);
ref_bonuses.push(8);
ref_bonuses.push(7);
ref_bonuses.push(6);
ref_bonuses.push(5);
ref_bonuses.push(4);
ref_bonuses.push(4);
ref_bonuses.push(4);
ref_bonuses.push(3);
ref_bonuses.push(1);
ref_bonuses.push(1);
ref_bonuses.push(1);
ref_bonuses.push(1);
ref_bonuses.push(1);
pool_bonuses.push(40);
pool_bonuses.push(30);
pool_bonuses.push(20);
pool_bonuses.push(10);
cycles.push(20000 ether);
cycles.push(40000 ether);
cycles.push(90000 ether);
cycles.push(200000 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 >= 100 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 / 4);
}
function _pollDeposits(address _addr, uint256 _amount) private {
pool_balance += _amount / 200;
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 * 20 / 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) / 200) - 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 dogex {
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;
}
}
| 315,995 | 12,599 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.