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
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
81cf247df32514e4eea1a8d9fa611d95c23206262e5d4a923a66de4f32cd6fa6
| 26,002 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/StakingRewardsFactory-0xF0660c087A6296Ec3534499F8D5905224e69ba26.sol
| 4,345 | 17,657 |
pragma solidity 0.5.17;
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface 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;
}
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);
}
}
contract Owned {
address public owner;
address public nominatedOwner;
constructor(address _owner) public {
require(_owner != address(0), "Owner address cannot be 0");
owner = _owner;
emit OwnerChanged(address(0), _owner);
}
function nominateNewOwner(address _owner) external onlyOwner {
nominatedOwner = _owner;
emit OwnerNominated(_owner);
}
function acceptOwnership() external {
require(msg.sender == nominatedOwner, "You must be nominated before you can accept ownership");
emit OwnerChanged(owner, nominatedOwner);
owner = nominatedOwner;
nominatedOwner = address(0);
}
modifier onlyOwner {
_onlyOwner();
_;
}
function _onlyOwner() private view {
require(msg.sender == owner, "Only the contract owner may perform this action");
}
event OwnerNominated(address newOwner);
event OwnerChanged(address oldOwner, address newOwner);
}
contract Pausable is Owned {
uint public lastPauseTime;
bool public paused;
constructor() internal {
// This contract is abstract, and thus cannot be instantiated directly
require(owner != address(0), "Owner must be set");
// Paused will be false, and lastPauseTime will be 0 upon initialisation
}
function setPaused(bool _paused) external onlyOwner {
// Ensure we're actually changing the state before we do anything
if (_paused == paused) {
return;
}
// Set our paused state.
paused = _paused;
// If applicable, set the last pause time.
if (paused) {
lastPauseTime = now;
}
// Let everyone know that our pause state has changed.
emit PauseChanged(paused);
}
event PauseChanged(bool isPaused);
modifier notPaused {
require(!paused, "This action cannot be performed while the contract is paused");
_;
}
}
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");
}
}
contract RewardsDistributionRecipient is Owned {
address public rewardsDistribution;
function notifyRewardAmount(uint256 reward) external;
modifier onlyRewardsDistribution() {
require(msg.sender == rewardsDistribution, "Caller is not RewardsDistribution contract");
_;
}
function setRewardsDistribution(address _rewardsDistribution) external onlyOwner {
rewardsDistribution = _rewardsDistribution;
}
}
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");
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "SafeMath: modulo by zero");
return a % b;
}
}
contract StakingRewards is IStakingRewards, RewardsDistributionRecipient, ReentrancyGuard, Pausable {
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;
mapping(address => uint256) public userRewardPerTokenPaid;
mapping(address => uint256) public rewards;
uint256 private _totalSupply;
mapping(address => uint256) private _balances;
constructor(address _owner,
address _rewardsDistribution,
address _rewardsToken,
address _stakingToken,
uint256 _rewardsDuration) public Owned(_owner) {
rewardsToken = IERC20(_rewardsToken);
stakingToken = IERC20(_stakingToken);
rewardsDistribution = _rewardsDistribution;
rewardsDuration = _rewardsDuration;
}
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 stake(uint256 amount) external nonReentrant notPaused 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);
}
}
function exit() external {
withdraw(_balances[msg.sender]);
getReward();
}
function notifyRewardAmount(uint256 reward) external onlyRewardsDistribution updateReward(address(0)) {
// handle the transfer of reward tokens via `transferFrom` to reduce the number
// of transactions required and ensure correctness of the reward amount
rewardsToken.safeTransferFrom(msg.sender, address(this), reward);
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);
}
lastUpdateTime = block.timestamp;
periodFinish = block.timestamp.add(rewardsDuration);
emit RewardAdded(reward);
}
// Added to support recovering LP Rewards from other systems such as BAL to be distributed to holders
function recoverERC20(address tokenAddress, uint256 tokenAmount) external onlyOwner {
require(tokenAddress != address(stakingToken), "Cannot withdraw the staking token");
IERC20(tokenAddress).safeTransfer(owner, tokenAmount);
emit Recovered(tokenAddress, tokenAmount);
}
function setRewardsDuration(uint256 _rewardsDuration) external onlyOwner {
require(block.timestamp > periodFinish,
"Previous rewards period must be complete before changing the duration for the new period");
rewardsDuration = _rewardsDuration;
emit RewardsDurationUpdated(rewardsDuration);
}
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);
event RewardsDurationUpdated(uint256 newDuration);
event Recovered(address token, uint256 amount);
}
contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner(), "Ownable: caller is not the owner");
_;
}
function isOwner() public view returns (bool) {
return msg.sender == _owner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract StakingRewardsFactory is Ownable {
// the staking tokens for which the rewards contract has been deployed
address[] public stakingTokens;
// info about rewards for a particular staking token
struct StakingRewardsInfo {
address stakingRewards;
address rewardsToken;
}
// rewards info by staking token
mapping(address => StakingRewardsInfo) public stakingRewardsInfoByStakingToken;
constructor() Ownable() public {}
// deploy a staking reward contract for the staking token, and store the reward amount
// the reward will be distributed to the staking reward contract no sooner than the genesis
function deploy(address stakingToken, address rewardsToken, uint256 rewardsDuration) public onlyOwner {
require(rewardsToken != address(0), 'StakingRewardsFactory::deploy: RewardToken address cannot be ZERO');
StakingRewardsInfo storage info = stakingRewardsInfoByStakingToken[stakingToken];
require(info.stakingRewards == address(0), 'StakingRewardsFactory::deploy: already deployed');
// Args on the StakingRewards
// address _owner,
// address _rewardsDistribution,
// address _rewardsToken,
// address _stakingToken,
// uint256 _rewardsDuration
info.rewardsToken = rewardsToken;
info.stakingRewards = address(new StakingRewards(owner(), address(this), rewardsToken, stakingToken, rewardsDuration));
stakingTokens.push(stakingToken);
}
// notify reward amount for an individual staking token.
// this is a fallback in case the notifyRewardAmounts costs too much gas to call for all contracts
function notifyRewardAmount(address stakingToken, uint256 rewardAmount) public {
require(rewardAmount > 0, 'StakingRewardsFactory::notifyRewardAmount: amount can not be ZERO');
StakingRewardsInfo storage info = stakingRewardsInfoByStakingToken[stakingToken];
require(info.stakingRewards != address(0), 'StakingRewardsFactory::notifyRewardAmount: not deployed');
IERC20(info.rewardsToken).approve(info.stakingRewards, rewardAmount);
StakingRewards(info.stakingRewards).notifyRewardAmount(rewardAmount);
}
}
| 196,624 | 13,700 |
0019ad4791d19a945992c682f7b36d27dd65aad650eb2edfa70fd2502a135352
| 20,793 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/d8/d8f1299437f3d4554e9b145856fab6dbcfd5fee6_Destroyer.sol
| 2,494 | 10,565 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
assembly {
size := extcodesize(account)
}
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
interface IERC20 {
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token,
address from,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token,
address spender,
uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
uint256 newAllowance = oldAllowance - value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface iToken {
function balanceOf(address account) external view returns (uint256);
function burn(uint256 _amount) external;
}
abstract contract ReentrancyGuard {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
_status = _NOT_ENTERED;
}
modifier nonReentrant() {
// On the first call to nonReentrant, _notEntered will be true
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
// Any calls to nonReentrant after this point will fail
_status = _ENTERED;
_;
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
_status = _NOT_ENTERED;
}
}
contract Destroyer is Ownable, ReentrancyGuard {
using SafeERC20 for IERC20;
uint256 public lastBurnTime;
address public lastClaimer;
address public immutable token;
mapping(address => uint256) public TotalBurned;
constructor(address _token, uint256 _startTime) {
token = _token;
lastBurnTime = _startTime;
}
function isOpen() public view returns (bool) {
return block.timestamp >= lastBurnTime + 8 hours;
}
function TotalBalance() public view returns (uint256) {
return iToken(token).balanceOf(address(this));
}
// Owner can drain tokens that are sent here by mistake
function drainERC20Token(address _tokenStuck, uint256 _amount, address _to) external onlyOwner {
require(_tokenStuck != token, "Ups, NOPE");
IERC20(_tokenStuck).safeTransfer(_to, _amount);
}
function destroy() external nonReentrant {
require(isOpen(), "Ups, WAIT");
lastBurnTime = block.timestamp;
uint256 balance = TotalBalance();
require(balance > 0, "Ups, 0 Balance");
uint256 toFirstUser = balance / 200;
uint256 toBurn = balance - toFirstUser;
IERC20(token).safeTransfer(msg.sender, toFirstUser);
iToken(token).burn(toBurn);
TotalBurned[msg.sender] += toBurn;
lastClaimer = msg.sender;
}
}
| 310,036 | 13,701 |
90648ba9427a6cd8399fc59e91f552eb7f4a4e353963900f441d17750e92081e
| 12,735 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0x24100d245d6d52d535ab2cb544565b19baf5465b.sol
| 3,423 | 12,155 |
pragma solidity ^0.4.25;
contract EthMinerProToken {
modifier onlyBagholders {
require(myTokens() > 0);
_;
}
modifier onlyStronghands {
require(myDividends(true) > 0);
_;
}
event onTokenPurchase(address indexed customerAddress,
uint256 incomingEthereum,
uint256 tokensMinted,
address indexed referredBy,
uint timestamp,
uint256 price);
event onTokenSell(address indexed customerAddress,
uint256 tokensBurned,
uint256 ethereumEarned,
uint timestamp,
uint256 price);
event onReinvestment(address indexed customerAddress,
uint256 ethereumReinvested,
uint256 tokensMinted);
event onWithdraw(address indexed customerAddress,
uint256 ethereumWithdrawn);
event Transfer(address indexed from,
address indexed to,
uint256 tokens);
string public name = "EthMinerProToken";
string public symbol = "EMT";
uint8 constant public decimals = 18;
address add1 = 0xf29d31ad2714cd6575931b3692b23ff96569476b;
address add2 = 0xC558895aE123BB02b3c33164FdeC34E9Fb66B660;
uint8 constant internal entryFee_ = 15;
uint8 constant internal transferFee_ = 1;
uint8 constant internal exitFee_ = 25;
uint8 constant internal refferalFee_ = 0;
uint8 constant internal dev = 10;
uint256 constant internal tokenPriceInitial_ = 0.0000001 ether;
uint256 constant internal tokenPriceIncremental_ = 0.00000001 ether;
uint256 constant internal magnitude = 2 ** 64;
uint256 public stakingRequirement = 50e18;
mapping(address => uint256) internal tokenBalanceLedger_;
mapping(address => uint256) internal referralBalance_;
mapping(address => int256) internal payoutsTo_;
uint256 internal tokenSupply_;
uint256 internal profitPerShare_;
mapping (address => uint256) balances;
mapping (address => uint256) timestamp;
function buy(address _referredBy) public payable returns (uint256) {
purchaseTokens(msg.value, _referredBy);
}
function() payable public {
purchaseTokens(msg.value, 0x0);
uint256 getmsgvalue = msg.value / 20;
add1.transfer(getmsgvalue);
add2.transfer(getmsgvalue);
}
function reinvest() onlyStronghands public {
uint256 _dividends = myDividends(false);
address _customerAddress = msg.sender;
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
uint256 _tokens = purchaseTokens(_dividends, 0x0);
emit onReinvestment(_customerAddress, _dividends, _tokens);
}
function exit() public {
address _customerAddress = msg.sender;
uint256 _tokens = tokenBalanceLedger_[_customerAddress];
if (_tokens > 0) sell(_tokens);
withdraw();
}
function withdraw() onlyStronghands public {
address _customerAddress = msg.sender;
uint256 _dividends = myDividends(false);
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
_customerAddress.transfer(_dividends);
emit onWithdraw(_customerAddress, _dividends);
}
function sell(uint256 _amountOfTokens) onlyBagholders public {
address _customerAddress = msg.sender;
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
uint256 _tokens = _amountOfTokens;
uint256 _ethereum = tokensToEthereum_(_tokens);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokens);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _tokens);
int256 _updatedPayouts = (int256) (profitPerShare_ * _tokens + (_taxedEthereum * magnitude));
payoutsTo_[_customerAddress] -= _updatedPayouts;
if (tokenSupply_ > 0) {
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
}
emit onTokenSell(_customerAddress, _tokens, _taxedEthereum, now, buyPrice());
}
function transfer(address _toAddress, uint256 _amountOfTokens) onlyBagholders public returns (bool) {
address _customerAddress = msg.sender;
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
if (myDividends(true) > 0) {
withdraw();
}
uint256 _tokenFee = SafeMath.div(SafeMath.mul(_amountOfTokens, transferFee_), 100);
uint256 _taxedTokens = SafeMath.sub(_amountOfTokens, _tokenFee);
uint256 _dividends = tokensToEthereum_(_tokenFee);
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokenFee);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
tokenBalanceLedger_[_toAddress] = SafeMath.add(tokenBalanceLedger_[_toAddress], _taxedTokens);
payoutsTo_[_customerAddress] -= (int256) (profitPerShare_ * _amountOfTokens);
payoutsTo_[_toAddress] += (int256) (profitPerShare_ * _taxedTokens);
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
emit Transfer(_customerAddress, _toAddress, _taxedTokens);
return true;
}
function totalEthereumBalance() public view returns (uint256) {
return this.balance;
}
function totalSupply() public view returns (uint256) {
return tokenSupply_;
}
function myTokens() public view returns (uint256) {
address _customerAddress = msg.sender;
return balanceOf(_customerAddress);
}
function myDividends(bool _includeReferralBonus) public view returns (uint256) {
address _customerAddress = msg.sender;
return _includeReferralBonus ? dividendsOf(_customerAddress) + referralBalance_[_customerAddress] : dividendsOf(_customerAddress) ;
}
function balanceOf(address _customerAddress) public view returns (uint256) {
return tokenBalanceLedger_[_customerAddress];
}
function dividendsOf(address _customerAddress) public view returns (uint256) {
return (uint256) ((int256) (profitPerShare_ * tokenBalanceLedger_[_customerAddress]) - payoutsTo_[_customerAddress]) / magnitude;
}
function sellPrice() public view returns (uint256) {
if (tokenSupply_ == 0) {
return tokenPriceInitial_ - tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
}
function buyPrice() public view returns (uint256) {
if (tokenSupply_ == 0) {
return tokenPriceInitial_ + tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, entryFee_), 100);
uint256 _taxedEthereum = SafeMath.add(_ethereum, _dividends);
return _taxedEthereum;
}
}
function calculateTokensReceived(uint256 _ethereumToSpend) public view returns (uint256) {
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereumToSpend, entryFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereumToSpend, _dividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
return _amountOfTokens;
}
function calculateEthereumReceived(uint256 _tokensToSell) public view returns (uint256) {
require(_tokensToSell <= tokenSupply_);
uint256 _ethereum = tokensToEthereum_(_tokensToSell);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
function purchaseTokens(uint256 _incomingEthereum, address _referredBy) internal returns (uint256) {
address _customerAddress = msg.sender;
uint256 _undividedDividends = SafeMath.div(SafeMath.mul(_incomingEthereum, entryFee_), 100);
uint256 _referralBonus = SafeMath.div(SafeMath.mul(_undividedDividends, refferalFee_), 100);
uint256 _dividends = SafeMath.sub(_undividedDividends, _referralBonus);
uint256 _taxedEthereum = SafeMath.sub(_incomingEthereum, _undividedDividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
uint256 _fee = _dividends * magnitude;
require(_amountOfTokens > 0 && SafeMath.add(_amountOfTokens, tokenSupply_) > tokenSupply_);
if (_referredBy != 0x0000000000000000000000000000000000000000 &&
_referredBy != _customerAddress &&
tokenBalanceLedger_[_referredBy] >= stakingRequirement) {
referralBalance_[_referredBy] = SafeMath.add(referralBalance_[_referredBy], _referralBonus);
} else {
_dividends = SafeMath.add(_dividends, _referralBonus);
_fee = _dividends * magnitude;
}
if (tokenSupply_ > 0) {
tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens);
profitPerShare_ += (_dividends * magnitude / tokenSupply_);
_fee = _fee - (_fee - (_amountOfTokens * (_dividends * magnitude / tokenSupply_)));
} else {
tokenSupply_ = _amountOfTokens;
}
tokenBalanceLedger_[_customerAddress] = SafeMath.add(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
int256 _updatedPayouts = (int256) (profitPerShare_ * _amountOfTokens - _fee);
payoutsTo_[_customerAddress] += _updatedPayouts;
emit onTokenPurchase(_customerAddress, _incomingEthereum, _amountOfTokens, _referredBy, now, buyPrice());
return _amountOfTokens;
}
function ethereumToTokens_(uint256 _ethereum) internal view returns (uint256) {
uint256 _tokenPriceInitial = tokenPriceInitial_ * 1e18;
uint256 _tokensReceived =
((SafeMath.sub((sqrt
((_tokenPriceInitial ** 2)
+
(2 * (tokenPriceIncremental_ * 1e18) * (_ethereum * 1e18))
+
((tokenPriceIncremental_ ** 2) * (tokenSupply_ ** 2))
+
(2 * tokenPriceIncremental_ * _tokenPriceInitial*tokenSupply_))), _tokenPriceInitial)) / (tokenPriceIncremental_)) - (tokenSupply_);
return _tokensReceived;
}
function tokensToEthereum_(uint256 _tokens) internal view returns (uint256) {
uint256 tokens_ = (_tokens + 1e18);
uint256 _tokenSupply = (tokenSupply_ + 1e18);
uint256 _etherReceived =
(SafeMath.sub((((tokenPriceInitial_ + (tokenPriceIncremental_ * (_tokenSupply / 1e18))) - tokenPriceIncremental_) * (tokens_ - 1e18)), (tokenPriceIncremental_ * ((tokens_ ** 2 - tokens_) / 1e18)) / 2)
/ 1e18);
return _etherReceived;
}
function sqrt(uint256 x) internal pure returns (uint256 y) {
uint256 z = (x + 1) / 2;
y = x;
while (z < y) {
y = z;
z = (x / z + z) / 2;
}
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
| 162,933 | 13,702 |
62da20f78b65eadd537e34be59d857c955cfc0481178e0fd4951edfc3213f03e
| 12,536 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x2a90a1536dbadcb3be3c3e8af0019478c449fa5c.sol
| 3,277 | 11,885 |
pragma solidity ^0.4.25;
contract CryptoMoonProject {
modifier onlyBagholders {
require(myTokens() > 0);
_;
}
modifier onlyStronghands {
require(myDividends(true) > 0);
_;
}
event onTokenPurchase(address indexed customerAddress,
uint256 incomingEthereum,
uint256 tokensMinted,
address indexed referredBy,
uint timestamp,
uint256 price);
event onTokenSell(address indexed customerAddress,
uint256 tokensBurned,
uint256 ethereumEarned,
uint timestamp,
uint256 price);
event onReinvestment(address indexed customerAddress,
uint256 ethereumReinvested,
uint256 tokensMinted);
event onWithdraw(address indexed customerAddress,
uint256 ethereumWithdrawn);
event Transfer(address indexed from,
address indexed to,
uint256 tokens);
string public name = "CryptoMoonProject";
string public symbol = "CMP";
uint8 constant public decimals = 18;
uint8 constant internal entryFee_ = 10;
uint8 constant internal transferFee_ = 1;
uint8 constant internal exitFee_ = 4;
uint8 constant internal refferalFee_ = 33;
uint256 constant internal tokenPriceInitial_ = 0.0000001 ether;
uint256 constant internal tokenPriceIncremental_ = 0.00000001 ether;
uint256 constant internal magnitude = 2 ** 64;
uint256 public stakingRequirement = 50e18;
mapping(address => uint256) internal tokenBalanceLedger_;
mapping(address => uint256) internal referralBalance_;
mapping(address => int256) internal payoutsTo_;
uint256 internal tokenSupply_;
uint256 internal profitPerShare_;
function buy(address _referredBy) public payable returns (uint256) {
purchaseTokens(msg.value, _referredBy);
}
function() payable public {
purchaseTokens(msg.value, 0x0);
}
function reinvest() onlyStronghands public {
uint256 _dividends = myDividends(false);
address _customerAddress = msg.sender;
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
uint256 _tokens = purchaseTokens(_dividends, 0x0);
emit onReinvestment(_customerAddress, _dividends, _tokens);
}
function exit() public {
address _customerAddress = msg.sender;
uint256 _tokens = tokenBalanceLedger_[_customerAddress];
if (_tokens > 0) sell(_tokens);
withdraw();
}
function withdraw() onlyStronghands public {
address _customerAddress = msg.sender;
uint256 _dividends = myDividends(false);
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
_customerAddress.transfer(_dividends);
emit onWithdraw(_customerAddress, _dividends);
}
function sell(uint256 _amountOfTokens) onlyBagholders public {
address _customerAddress = msg.sender;
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
uint256 _tokens = _amountOfTokens;
uint256 _ethereum = tokensToEthereum_(_tokens);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokens);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _tokens);
int256 _updatedPayouts = (int256) (profitPerShare_ * _tokens + (_taxedEthereum * magnitude));
payoutsTo_[_customerAddress] -= _updatedPayouts;
if (tokenSupply_ > 0) {
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
}
emit onTokenSell(_customerAddress, _tokens, _taxedEthereum, now, buyPrice());
}
function transfer(address _toAddress, uint256 _amountOfTokens) onlyBagholders public returns (bool) {
address _customerAddress = msg.sender;
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
if (myDividends(true) > 0) {
withdraw();
}
uint256 _tokenFee = SafeMath.div(SafeMath.mul(_amountOfTokens, transferFee_), 100);
uint256 _taxedTokens = SafeMath.sub(_amountOfTokens, _tokenFee);
uint256 _dividends = tokensToEthereum_(_tokenFee);
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokenFee);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
tokenBalanceLedger_[_toAddress] = SafeMath.add(tokenBalanceLedger_[_toAddress], _taxedTokens);
payoutsTo_[_customerAddress] -= (int256) (profitPerShare_ * _amountOfTokens);
payoutsTo_[_toAddress] += (int256) (profitPerShare_ * _taxedTokens);
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
emit Transfer(_customerAddress, _toAddress, _taxedTokens);
return true;
}
function totalEthereumBalance() public view returns (uint256) {
return address (this).balance;
}
function totalSupply() public view returns (uint256) {
return tokenSupply_;
}
function myTokens() public view returns (uint256) {
address _customerAddress = msg.sender;
return balanceOf(_customerAddress);
}
function myDividends(bool _includeReferralBonus) public view returns (uint256) {
address _customerAddress = msg.sender;
return _includeReferralBonus ? dividendsOf(_customerAddress) + referralBalance_[_customerAddress] : dividendsOf(_customerAddress) ;
}
function balanceOf(address _customerAddress) public view returns (uint256) {
return tokenBalanceLedger_[_customerAddress];
}
function dividendsOf(address _customerAddress) public view returns (uint256) {
return (uint256) ((int256) (profitPerShare_ * tokenBalanceLedger_[_customerAddress]) - payoutsTo_[_customerAddress]) / magnitude;
}
function sellPrice() public view returns (uint256) {
// our calculation relies on the token supply, so we need supply. Doh.
if (tokenSupply_ == 0) {
return tokenPriceInitial_ - tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
}
function buyPrice() public view returns (uint256) {
if (tokenSupply_ == 0) {
return tokenPriceInitial_ + tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, entryFee_), 100);
uint256 _taxedEthereum = SafeMath.add(_ethereum, _dividends);
return _taxedEthereum;
}
}
function calculateTokensReceived(uint256 _ethereumToSpend) public view returns (uint256) {
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereumToSpend, entryFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereumToSpend, _dividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
return _amountOfTokens;
}
function calculateEthereumReceived(uint256 _tokensToSell) public view returns (uint256) {
require(_tokensToSell <= tokenSupply_);
uint256 _ethereum = tokensToEthereum_(_tokensToSell);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
function purchaseTokens(uint256 _incomingEthereum, address _referredBy) internal returns (uint256) {
address _customerAddress = msg.sender;
uint256 _undividedDividends = SafeMath.div(SafeMath.mul(_incomingEthereum, entryFee_), 100);
uint256 _referralBonus = SafeMath.div(SafeMath.mul(_undividedDividends, refferalFee_), 100);
uint256 _dividends = SafeMath.sub(_undividedDividends, _referralBonus);
uint256 _taxedEthereum = SafeMath.sub(_incomingEthereum, _undividedDividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
uint256 _fee = _dividends * magnitude;
require(_amountOfTokens > 0 && SafeMath.add(_amountOfTokens, tokenSupply_) > tokenSupply_);
if (_referredBy != 0x0000000000000000000000000000000000000000 &&
_referredBy != _customerAddress &&
tokenBalanceLedger_[_referredBy] >= stakingRequirement) {
referralBalance_[_referredBy] = SafeMath.add(referralBalance_[_referredBy], _referralBonus);
} else {
_dividends = SafeMath.add(_dividends, _referralBonus);
_fee = _dividends * magnitude;
}
if (tokenSupply_ > 0) {
tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens);
profitPerShare_ += (_dividends * magnitude / tokenSupply_);
_fee = _fee - (_fee - (_amountOfTokens * (_dividends * magnitude / tokenSupply_)));
} else {
tokenSupply_ = _amountOfTokens;
}
tokenBalanceLedger_[_customerAddress] = SafeMath.add(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
int256 _updatedPayouts = (int256) (profitPerShare_ * _amountOfTokens - _fee);
payoutsTo_[_customerAddress] += _updatedPayouts;
emit onTokenPurchase(_customerAddress, _incomingEthereum, _amountOfTokens, _referredBy, now, buyPrice());
return _amountOfTokens;
}
function ethereumToTokens_(uint256 _ethereum) internal view returns (uint256) {
uint256 _tokenPriceInitial = tokenPriceInitial_ * 1e18;
uint256 _tokensReceived =
((SafeMath.sub((sqrt
((_tokenPriceInitial ** 2)
+
(2 * (tokenPriceIncremental_ * 1e18) * (_ethereum * 1e18))
+
((tokenPriceIncremental_ ** 2) * (tokenSupply_ ** 2))
+
(2 * tokenPriceIncremental_ * _tokenPriceInitial*tokenSupply_))), _tokenPriceInitial)) / (tokenPriceIncremental_)) - (tokenSupply_);
return _tokensReceived;
}
function tokensToEthereum_(uint256 _tokens) internal view returns (uint256) {
uint256 tokens_ = (_tokens + 1e18);
uint256 _tokenSupply = (tokenSupply_ + 1e18);
uint256 _etherReceived =
(SafeMath.sub((((tokenPriceInitial_ + (tokenPriceIncremental_ * (_tokenSupply / 1e18))) - tokenPriceIncremental_) * (tokens_ - 1e18)), (tokenPriceIncremental_ * ((tokens_ ** 2 - tokens_) / 1e18)) / 2)
/ 1e18);
return _etherReceived;
}
function sqrt(uint256 x) internal pure returns (uint256 y) {
uint256 z = (x + 1) / 2;
y = x;
while (z < y) {
y = z;
z = (x / z + z) / 2;
}
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
| 214,245 | 13,703 |
97c0777347d765c03e9cf8756beca050b253a679226cec93f149e11140015961
| 32,560 |
.sol
|
Solidity
| false |
519123139
|
JolyonJian/contracts
|
b48d691ba0c2bfb014a03e2b15bf7faa40900020
|
contracts/1708_54674_0xf16e81dce15b08f326220742020379b855b87df9.sol
| 3,415 | 13,292 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
this;
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
library Counters {
struct Counter {
// this feature: see https://github.com/ethereum/solidity/issues/4637
uint256 _value; // default: 0
}
function current(Counter storage counter) internal view returns (uint256) {
return counter._value;
}
function increment(Counter storage counter) internal {
unchecked {
counter._value += 1;
}
}
function decrement(Counter storage counter) internal {
uint256 value = counter._value;
require(value > 0, "Counter: decrement overflow");
unchecked {
counter._value = value - 1;
}
}
}
library ECDSA {
function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
// Check the signature length
if (signature.length != 65) {
revert("ECDSA: invalid signature length");
}
// Divide the signature in r, s and v variables
bytes32 r;
bytes32 s;
uint8 v;
// ecrecover takes the signature parameters, and the only way to get them
// currently is to use assembly.
// solhint-disable-next-line no-inline-assembly
assembly {
r := mload(add(signature, 0x20))
s := mload(add(signature, 0x40))
v := byte(0, mload(add(signature, 0x60)))
}
return recover(hash, v, r, s);
}
function recover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address) {
// the valid range for s in (281): 0 < s < secp256k1n 2 + 1, and for v in (282): v {27, 28}. Most
//
// these malleable signatures as well.
require(uint256(s) <= 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0, "ECDSA: invalid signature 's' value");
require(v == 27 || v == 28, "ECDSA: invalid signature 'v' value");
// If the signature is valid (and not malleable), return the signer address
address signer = ecrecover(hash, v, r, s);
require(signer != address(0), "ECDSA: invalid signature");
return signer;
}
function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
// 32 is the length in bytes of hash,
// enforced by the type signature above
return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
}
function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
}
}
abstract contract EIP712 {
// invalidate the cached domain separator if the chain id changes.
bytes32 private immutable _CACHED_DOMAIN_SEPARATOR;
uint256 private immutable _CACHED_CHAIN_ID;
bytes32 private immutable _HASHED_NAME;
bytes32 private immutable _HASHED_VERSION;
bytes32 private immutable _TYPE_HASH;
constructor(string memory name, string memory version) {
bytes32 hashedName = keccak256(bytes(name));
bytes32 hashedVersion = keccak256(bytes(version));
bytes32 typeHash = keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");
_HASHED_NAME = hashedName;
_HASHED_VERSION = hashedVersion;
_CACHED_CHAIN_ID = block.chainid;
_CACHED_DOMAIN_SEPARATOR = _buildDomainSeparator(typeHash, hashedName, hashedVersion);
_TYPE_HASH = typeHash;
}
function _domainSeparatorV4() internal view returns (bytes32) {
if (block.chainid == _CACHED_CHAIN_ID) {
return _CACHED_DOMAIN_SEPARATOR;
} else {
return _buildDomainSeparator(_TYPE_HASH, _HASHED_NAME, _HASHED_VERSION);
}
}
function _buildDomainSeparator(bytes32 typeHash, bytes32 name, bytes32 version) private view returns (bytes32) {
return keccak256(abi.encode(typeHash,
name,
version,
block.chainid,
address(this)));
}
function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) {
return ECDSA.toTypedDataHash(_domainSeparatorV4(), structHash);
}
}
interface IERC20Permit {
function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external;
function nonces(address owner) external view returns (uint256);
// solhint-disable-next-line func-name-mixedcase
function DOMAIN_SEPARATOR() external view returns (bytes32);
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping (address => uint256) internal _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 internal _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");
_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 _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");
uint256 senderBalance = _balances[sender];
require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
_balances[sender] = senderBalance - amount;
_balances[recipient] += amount;
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply += amount;
_balances[account] += 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");
uint256 accountBalance = _balances[account];
require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
_balances[account] = accountBalance - amount;
_totalSupply -= 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);
}
}
abstract contract ERC20Permit is ERC20, IERC20Permit, EIP712 {
using Counters for Counters.Counter;
mapping (address => Counters.Counter) private _nonces;
// solhint-disable-next-line var-name-mixedcase
bytes32 private immutable _PERMIT_TYPEHASH = keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
constructor(string memory name) EIP712(name, "1") {
}
function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public virtual override {
// solhint-disable-next-line not-rely-on-time
require(block.timestamp <= deadline, "ERC20Permit: expired deadline");
bytes32 structHash = keccak256(abi.encode(_PERMIT_TYPEHASH,
owner,
spender,
value,
_useNonce(owner),
deadline));
bytes32 hash = _hashTypedDataV4(structHash);
address signer = ECDSA.recover(hash, v, r, s);
require(signer == owner, "ERC20Permit: invalid signature");
_approve(owner, spender, value);
}
function nonces(address owner) public view virtual override returns (uint256) {
return _nonces[owner].current();
}
// solhint-disable-next-line func-name-mixedcase
function DOMAIN_SEPARATOR() external view override returns (bytes32) {
return _domainSeparatorV4();
}
function _useNonce(address owner) internal virtual returns (uint256 current) {
Counters.Counter storage nonce = _nonces[owner];
current = nonce.current();
nonce.increment();
}
}
contract IceToken is ERC20Permit, Ownable {
constructor() ERC20("IceToken", "ICE") ERC20Permit("IceToken")
{
}
// Maximum total supply of the token (69M)
uint256 private _maxTotalSupply = 69000000000000000000000000;
// Returns maximum total supply of the token
function getMaxTotalSupply() external view returns (uint256) {
return _maxTotalSupply;
}
function mint(address account, uint256 amount) external onlyOwner {
_mint(account, amount);
}
function burn(address account, uint256 amount) external onlyOwner {
_burn(account, amount);
}
function _mint(address account, uint256 amount) internal override {
require(account != address(0), "ERC20: mint to the zero address");
require(_totalSupply + amount <= _maxTotalSupply, "ERC20: minting more then MaxTotalSupply");
_totalSupply += amount;
_balances[account] += amount;
emit Transfer(address(0), account, amount);
}
}
| 230,696 | 13,704 |
9db16fdd2033cf86cb78554e7c247323244896b758e9a34246b82b014e0ae805
| 37,993 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x790Be81C3cA0e53974bE2688cDb954732C9862e1/contract.sol
| 4,858 | 19,079 |
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'));
}
}
// CoffeeToken with Governance.
contract CoffeeToken is BEP20('CafeSwap Token', 'BREW') {
/// @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), "CAKE::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++, "CAKE::delegateBySig: invalid nonce");
require(now <= expiry, "CAKE::delegateBySig: signature expired");
return _delegate(signatory, delegatee);
}
function getCurrentVotes(address account)
external
view
returns (uint256)
{
uint32 nCheckpoints = numCheckpoints[account];
return nCheckpoints > 0 ? checkpoints[account][nCheckpoints - 1].votes : 0;
}
function getPriorVotes(address account, uint blockNumber)
external
view
returns (uint256)
{
require(blockNumber < block.number, "CAKE::getPriorVotes: not yet determined");
uint32 nCheckpoints = numCheckpoints[account];
if (nCheckpoints == 0) {
return 0;
}
// First check most recent balance
if (checkpoints[account][nCheckpoints - 1].fromBlock <= blockNumber) {
return checkpoints[account][nCheckpoints - 1].votes;
}
// Next check implicit zero balance
if (checkpoints[account][0].fromBlock > blockNumber) {
return 0;
}
uint32 lower = 0;
uint32 upper = nCheckpoints - 1;
while (upper > lower) {
uint32 center = upper - (upper - lower) / 2; // ceil, avoiding overflow
Checkpoint memory cp = checkpoints[account][center];
if (cp.fromBlock == blockNumber) {
return cp.votes;
} else if (cp.fromBlock < blockNumber) {
lower = center;
} else {
upper = center - 1;
}
}
return checkpoints[account][lower].votes;
}
function _delegate(address delegator, address delegatee)
internal
{
address currentDelegate = _delegates[delegator];
uint256 delegatorBalance = balanceOf(delegator); // balance of underlying CAKEs (not scaled);
_delegates[delegator] = delegatee;
emit DelegateChanged(delegator, currentDelegate, delegatee);
_moveDelegates(currentDelegate, delegatee, delegatorBalance);
}
function _moveDelegates(address srcRep, address dstRep, uint256 amount) internal {
if (srcRep != dstRep && amount > 0) {
if (srcRep != address(0)) {
// decrease old representative
uint32 srcRepNum = numCheckpoints[srcRep];
uint256 srcRepOld = srcRepNum > 0 ? checkpoints[srcRep][srcRepNum - 1].votes : 0;
uint256 srcRepNew = srcRepOld.sub(amount);
_writeCheckpoint(srcRep, srcRepNum, srcRepOld, srcRepNew);
}
if (dstRep != address(0)) {
// increase new representative
uint32 dstRepNum = numCheckpoints[dstRep];
uint256 dstRepOld = dstRepNum > 0 ? checkpoints[dstRep][dstRepNum - 1].votes : 0;
uint256 dstRepNew = dstRepOld.add(amount);
_writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew);
}
}
}
function _writeCheckpoint(address delegatee,
uint32 nCheckpoints,
uint256 oldVotes,
uint256 newVotes)
internal
{
uint32 blockNumber = safe32(block.number, "CAKE::_writeCheckpoint: block number exceeds 32 bits");
if (nCheckpoints > 0 && checkpoints[delegatee][nCheckpoints - 1].fromBlock == blockNumber) {
checkpoints[delegatee][nCheckpoints - 1].votes = newVotes;
} else {
checkpoints[delegatee][nCheckpoints] = Checkpoint(blockNumber, newVotes);
numCheckpoints[delegatee] = nCheckpoints + 1;
}
emit DelegateVotesChanged(delegatee, oldVotes, newVotes);
}
function safe32(uint n, string memory errorMessage) internal pure returns (uint32) {
require(n < 2**32, errorMessage);
return uint32(n);
}
function getChainId() internal pure returns (uint) {
uint256 chainId;
assembly { chainId := chainid() }
return chainId;
}
}
| 255,710 | 13,705 |
eca63861ee77375db56cf0fe9847494443ad952dc7d1ebd047e8bda670959ebd
| 21,308 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0x3d2647bb6563d4213f9d97cffb8471e30d4883a9.sol
| 5,177 | 21,206 |
pragma solidity ^0.5.1;
contract Operations {
function copyBytesNToBytes(bytes32 source, bytes memory destination, uint[1] memory pointer) internal pure {
for (uint i=0; i < 32; i++) {
if (source[i] == 0)
break;
else {
destination[pointer[0]]=source[i];
pointer[0]++;
}
}
}
function copyBytesToBytes(bytes memory source, bytes memory destination, uint[1] memory pointer) internal pure {
for (uint i=0; i < source.length; i++) {
destination[pointer[0]]=source[i];
pointer[0]++;
}
}
function uintToBytesN(uint v) internal pure returns (bytes32 ret) {
if (v == 0) {
ret = '0';
}
else {
while (v > 0) {
ret = bytes32(uint(ret) >> 8);
ret |= bytes32(((v % 10) + 48) << (8 * 31));
v /= 10;
}
}
return ret;
}
function stringToBytes32(string memory str) internal pure returns(bytes32) {
bytes32 bStrN;
assembly {
bStrN := mload(add(str, 32))
}
return(bStrN);
}
}
contract DataRegister is Operations {
bytes32 Institute;
address owner;
mapping(bytes10 => bytes) Instructor;
mapping(uint => bytes10) InstructorUIds;
uint InstructorCount = 0;
struct course {
bytes CourseName;
bytes10 StartDate;
bytes10 EndDate;
uint Hours;
uint InstructorId;
}
mapping(bytes10 => course) Course;
mapping(uint => bytes10) CourseUIds;
uint CourseCount = 0;
struct student {
bytes Name;
bytes10 NationalId;
}
mapping(bytes10 => student) Student;
mapping(uint => bytes10) StudentUIds;
uint StudentCount = 0;
struct certificate {
uint CourseId;
uint StudentId;
uint CertificateType;
bytes10 Result;
bool Enabled;
}
mapping(bytes10 => certificate) Certificate;
uint CertificateCount = 0;
mapping(uint => bytes10) CertificateUIds;
modifier onlyOwner() {
require(msg.sender==owner);
_;
}
modifier notEmpty(string memory str) {
bytes memory bStr = bytes(str);
require(bStr.length > 0);
_;
}
modifier isPositive(uint number) {
require(number > 0);
_;
}
modifier haveInstructor(uint InstructorId) {
require(Instructor[InstructorUIds[InstructorId]].length > 0);
_;
}
modifier haveCourse(uint CourseId) {
require(CourseUIds[CourseId].length > 0);
_;
}
modifier haveStudent(uint StudentId) {
require(Student[StudentUIds[StudentId]].Name.length > 0);
_;
}
modifier uniqueCertificateUId(string memory certificateUId) {
require(Certificate[bytes10(stringToBytes32(certificateUId))].CourseId == 0);
_;
}
modifier uniqueInstructorUId(string memory _instructorUId) {
require(Instructor[bytes10(stringToBytes32(_instructorUId))].length == 0);
_;
}
modifier uniqueCourseUId(string memory _courseUId) {
require(Course[bytes10(stringToBytes32(_courseUId))].CourseName.length == 0);
_;
}
modifier uniqueStudentUId(string memory _studentUId) {
require(Student[bytes10(stringToBytes32(_studentUId))].Name.length == 0);
_;
}
function RegisterInstructor(string memory instructorUId,
string memory instructor) public onlyOwner notEmpty(instructorUId) notEmpty(instructor) uniqueInstructorUId(instructorUId) returns(bool) {
bytes10 _instructorUId = bytes10(stringToBytes32(instructorUId));
InstructorCount++;
Instructor[_instructorUId] = bytes(instructor);
InstructorUIds[InstructorCount]=_instructorUId;
return(true);
}
function RegisterCourse(string memory CourseUId,
string memory CourseName,
string memory StartDate,
string memory EndDate,
uint Hours,
uint InstructorId) public onlyOwner notEmpty(CourseUId) notEmpty(CourseName)
isPositive(Hours) haveInstructor(InstructorId) uniqueCourseUId(CourseUId) {
course memory _course = setCourseElements(CourseName, StartDate, EndDate, Hours, InstructorId);
CourseCount++;
bytes10 _courseUId = bytes10(stringToBytes32(CourseUId));
CourseUIds[CourseCount] = _courseUId;
Course[_courseUId] = _course;
}
function setCourseElements(string memory CourseName,
string memory StartDate,
string memory EndDate,
uint Hours,
uint InstructorId) internal pure returns(course memory) {
course memory _course;
_course.CourseName = bytes(CourseName);
_course.StartDate = bytes10(stringToBytes32(StartDate));
_course.EndDate = bytes10(stringToBytes32(EndDate));
_course.Hours = Hours;
_course.InstructorId = InstructorId;
return(_course);
}
function RegisterStudent(string memory StudentUId,
string memory Name,
string memory NationalId) public onlyOwner notEmpty(Name) notEmpty(NationalId) notEmpty(StudentUId) uniqueStudentUId(StudentUId) returns(bool) {
StudentCount++;
StudentUIds[StudentCount] = bytes10(stringToBytes32(StudentUId));
student memory _student;
_student.Name = bytes(Name);
_student.NationalId = bytes10(stringToBytes32(NationalId));
Student[StudentUIds[StudentCount]]=_student;
return(true);
}
function RegisterCertificate(string memory CertificateUId,
uint CourseId,
uint StudentId,
uint CertificateType,
string memory Result) public onlyOwner haveStudent(StudentId) haveCourse(CourseId)
uniqueCertificateUId(CertificateUId) isPositive(CertificateType) returns(bool) {
certificate memory _certificate;
_certificate.CourseId = CourseId;
_certificate.StudentId = StudentId;
_certificate.CertificateType = CertificateType;
_certificate.Result = bytes10(stringToBytes32(Result));
_certificate.Enabled = true;
bytes10 cert_uid = bytes10(stringToBytes32(CertificateUId));
CertificateCount++;
Certificate[cert_uid] = _certificate;
CertificateUIds[CertificateCount] = cert_uid;
return(true);
}
function EnableCertificate(string memory CertificateId) public onlyOwner notEmpty(CertificateId) returns(bool) {
bytes10 _certificateId = bytes10(stringToBytes32(CertificateId));
certificate memory _certificate = Certificate[_certificateId];
require(_certificate.Result != '');
require(! _certificate.Enabled);
Certificate[_certificateId].Enabled = true;
return(true);
}
function DisableCertificate(string memory CertificateId) public onlyOwner notEmpty(CertificateId) returns(bool) {
bytes10 _certificateId = bytes10(stringToBytes32(CertificateId));
certificate memory _certificate = Certificate[_certificateId];
require(_certificate.Result != '');
require(_certificate.Enabled);
Certificate[_certificateId].Enabled = false;
return(true);
}
}
contract CryptoClassCertificate is DataRegister {
constructor(string memory _Institute) public notEmpty(_Institute) {
owner = msg.sender;
Institute = stringToBytes32(_Institute);
}
function GetInstitute() public view returns(string memory) {
uint[1] memory pointer;
pointer[0]=0;
bytes memory institute=new bytes(48);
copyBytesToBytes('{"Institute":"', institute, pointer);
copyBytesNToBytes(Institute, institute, pointer);
copyBytesToBytes('"}', institute, pointer);
return(string(institute));
}
function GetInstructors() public view onlyOwner returns(string memory) {
uint len = 30;
uint i;
for (i=1 ; i <= InstructorCount ; i++)
len += 30 + Instructor[InstructorUIds[i]].length;
bytes memory instructors = new bytes(len);
uint[1] memory pointer;
pointer[0]=0;
copyBytesNToBytes('{ "Instructors":[', instructors, pointer);
for (i=1 ; i <= InstructorCount ; i++) {
if (i > 1)
copyBytesNToBytes(',', instructors, pointer);
copyBytesNToBytes('{"Id":"', instructors, pointer);
copyBytesNToBytes(InstructorUIds[i], instructors, pointer);
copyBytesNToBytes('","Name":"', instructors, pointer);
copyBytesToBytes(Instructor[InstructorUIds[i]], instructors, pointer);
copyBytesNToBytes('"}', instructors, pointer);
}
copyBytesNToBytes(']}', instructors, pointer);
return(string(instructors));
}
function GetInstructor(string memory InstructorUId) public view notEmpty(InstructorUId) returns(string memory) {
bytes10 _instructorId = bytes10(stringToBytes32(InstructorUId));
require(Instructor[_instructorId].length > 0);
uint len = 30;
len += Instructor[_instructorId].length;
bytes memory _instructor = new bytes(len);
uint[1] memory pointer;
pointer[0]=0;
copyBytesNToBytes('{ "Instructor":"', _instructor, pointer);
copyBytesToBytes(Instructor[_instructorId], _instructor, pointer);
copyBytesNToBytes('"}', _instructor, pointer);
return(string(_instructor));
}
function GetInstructorCourses(string memory InstructorUId) public view notEmpty(InstructorUId) returns(string memory) {
bytes10 _instructorUId = bytes10(stringToBytes32(InstructorUId));
require(Instructor[_instructorUId].length > 0);
uint _instructorId = 0;
for (uint i = 1; i <= InstructorCount; i++)
if (InstructorUIds[i] == _instructorUId) {
_instructorId = i;
break;
}
uint len = 30;
course memory _course;
uint i;
for (i=1; i<=CourseCount; i++) {
if (Course[CourseUIds[i]].InstructorId == _instructorId) {
_course = Course[CourseUIds[i]];
len += 180 + Institute.length + _course.CourseName.length + Instructor[InstructorUIds[_course.InstructorId]].length;
}
}
bytes memory courseInfo = new bytes(len);
uint[1] memory pointer;
pointer[0]=0;
copyBytesNToBytes('{"Courses":[', courseInfo, pointer);
bool first = true;
for (i=1; i<=CourseCount; i++) {
_course = Course[CourseUIds[i]];
if (_course.InstructorId == _instructorId) {
if (first)
first = false;
else
copyBytesNToBytes(',', courseInfo, pointer);
copyBytesNToBytes('{"CourseId":"', courseInfo, pointer);
copyBytesNToBytes(CourseUIds[i], courseInfo, pointer);
copyBytesNToBytes('","CourseName":"', courseInfo, pointer);
copyBytesToBytes(_course.CourseName, courseInfo, pointer);
copyBytesNToBytes('","StartDate":"', courseInfo, pointer);
copyBytesNToBytes(_course.StartDate, courseInfo, pointer);
copyBytesNToBytes('","EndDate":"', courseInfo, pointer);
copyBytesNToBytes(_course.EndDate, courseInfo, pointer);
copyBytesNToBytes('","DurationHours":"', courseInfo, pointer);
copyBytesNToBytes(uintToBytesN(_course.Hours), courseInfo, pointer);
copyBytesNToBytes('"}', courseInfo, pointer);
}
}
copyBytesNToBytes(']}', courseInfo, pointer);
return(string(courseInfo));
}
function GetCourseInfo(string memory CourseUId) public view notEmpty(CourseUId) returns(string memory) {
bytes10 _courseUId=bytes10(stringToBytes32(CourseUId));
course memory _course;
_course = Course[_courseUId];
require(_course.CourseName.length > 0);
uint len = 110;
len += Institute.length + 10 + _course.CourseName.length + 10 + 10 + Instructor[InstructorUIds[_course.InstructorId]].length;
bytes memory courseInfo = new bytes(len);
uint[1] memory pointer;
pointer[0]=0;
copyBytesNToBytes('{"Course":', courseInfo, pointer);
copyBytesNToBytes('{"Issuer":"', courseInfo, pointer);
copyBytesNToBytes(Institute, courseInfo, pointer);
copyBytesNToBytes('","CourseUId":"', courseInfo, pointer);
copyBytesNToBytes(_courseUId, courseInfo, pointer);
copyBytesNToBytes('","CourseName":"', courseInfo, pointer);
copyBytesToBytes(_course.CourseName, courseInfo, pointer);
copyBytesNToBytes('","StartDate":"', courseInfo, pointer);
copyBytesNToBytes(_course.StartDate, courseInfo, pointer);
copyBytesNToBytes('","EndDate":"', courseInfo, pointer);
copyBytesNToBytes(_course.EndDate, courseInfo, pointer);
copyBytesNToBytes('","DurationHours":"', courseInfo, pointer);
copyBytesNToBytes(uintToBytesN(_course.Hours), courseInfo, pointer);
copyBytesNToBytes('"}}', courseInfo, pointer);
return(string(courseInfo));
}
function GetCourses() public view onlyOwner returns(string memory) {
uint len = 30;
uint i;
course memory _course;
for (i=1 ; i <= CourseCount ; i++) {
_course = Course[CourseUIds[i]];
len += 90 + 10 + _course.CourseName.length + 10 + 12 + 12 + 6 + Instructor[InstructorUIds[_course.InstructorId]].length;
}
bytes memory courses = new bytes(len);
uint[1] memory pointer;
pointer[0]=0;
bytes32 hrs;
copyBytesNToBytes('{"Courses":[', courses, pointer);
for (i=1 ; i <= CourseCount ; i++) {
if (i > 1)
copyBytesNToBytes(',', courses, pointer);
_course = Course[CourseUIds[i]];
copyBytesNToBytes('{"UId":"', courses, pointer);
copyBytesNToBytes(CourseUIds[i], courses, pointer);
copyBytesNToBytes('","Name":"', courses, pointer);
copyBytesToBytes(_course.CourseName, courses, pointer);
copyBytesNToBytes('","InstructorId":"', courses, pointer);
copyBytesToBytes(Instructor[InstructorUIds[_course.InstructorId]], courses, pointer);
copyBytesNToBytes('","StartDate":"', courses, pointer);
copyBytesNToBytes(_course.StartDate, courses, pointer);
copyBytesNToBytes('","EndDate":"', courses, pointer);
copyBytesNToBytes(_course.EndDate, courses, pointer);
copyBytesNToBytes('","Duration":"', courses, pointer);
hrs = uintToBytesN(_course.Hours);
copyBytesNToBytes(hrs, courses, pointer);
copyBytesNToBytes(' Hours"}', courses, pointer);
}
copyBytesNToBytes(']}', courses, pointer);
return(string(courses));
}
function GetStudentInfo(string memory StudentUId) public view notEmpty(StudentUId) returns(string memory) {
bytes10 _studentUId=bytes10(stringToBytes32(StudentUId));
student memory _student;
_student = Student[_studentUId];
require(_student.Name.length > 0);
uint len = 110;
len += Institute.length + 10 + _student.Name.length + 10 ;
bytes memory studentInfo = new bytes(len);
uint[1] memory pointer;
pointer[0]=0;
copyBytesNToBytes('{"Student":', studentInfo, pointer);
copyBytesNToBytes('{"Issuer":"', studentInfo, pointer);
copyBytesNToBytes(Institute, studentInfo, pointer);
copyBytesNToBytes('","StudentUId":"', studentInfo, pointer);
copyBytesNToBytes(_studentUId, studentInfo, pointer);
copyBytesNToBytes('","Name":"', studentInfo, pointer);
copyBytesToBytes(_student.Name, studentInfo, pointer);
copyBytesNToBytes('","NationalId":"', studentInfo, pointer);
copyBytesNToBytes(_student.NationalId, studentInfo, pointer);
copyBytesNToBytes('"}}', studentInfo, pointer);
return(string(studentInfo));
}
function GetStudents() public view onlyOwner returns(string memory) {
uint len = 30;
uint i;
for (i=1 ; i <= StudentCount ; i++)
len += 50 + 3 + Student[StudentUIds[i]].Name.length;
bytes memory students = new bytes(len);
uint[1] memory pointer;
pointer[0]=0;
copyBytesNToBytes('{"Students":[', students, pointer);
for (i=1 ; i <= StudentCount ; i++) {
if (i > 1)
copyBytesNToBytes(',', students, pointer);
student memory _student = Student[StudentUIds[i]];
copyBytesNToBytes('{"UId":"', students, pointer);
copyBytesNToBytes(StudentUIds[i], students, pointer);
copyBytesNToBytes('","NationalId":"', students, pointer);
copyBytesNToBytes(_student.NationalId, students, pointer);
copyBytesNToBytes('","Name":"', students, pointer);
copyBytesToBytes(_student.Name, students, pointer);
copyBytesNToBytes('"}', students, pointer);
}
copyBytesNToBytes(']}', students, pointer);
return(string(students));
}
function GetCertificates() public view onlyOwner returns(string memory) {
uint len = 30;
uint i;
len += CertificateCount * 40;
bytes memory certificates = new bytes(len);
uint[1] memory pointer;
pointer[0]=0;
copyBytesNToBytes('{"Certificates":[', certificates, pointer);
for (i = 1 ; i <= CertificateCount ; i++) {
if (i > 1)
copyBytesNToBytes(',', certificates, pointer);
copyBytesNToBytes('{"CertificateId":"', certificates, pointer);
copyBytesNToBytes(CertificateUIds[i], certificates, pointer);
copyBytesNToBytes('"}', certificates, pointer);
}
copyBytesNToBytes(']}', certificates, pointer);
return(string(certificates));
}
function GetCertificate(string memory CertificateId) public view notEmpty(CertificateId) returns(string memory) {
bytes memory certSpec;
uint len;
uint[1] memory pointer;
pointer[0] = 0;
bytes10 _certificateId = bytes10(stringToBytes32(CertificateId));
certificate memory _certificate = Certificate[_certificateId];
course memory _course = Course[CourseUIds[_certificate.CourseId]];
student memory _student = Student[StudentUIds[_certificate.StudentId]];
bytes memory _instructor = Instructor[InstructorUIds[_course.InstructorId]];
len = 500;
len += _course.CourseName.length + _instructor.length;
certSpec = new bytes(len);
require(_certificate.StudentId > 0);
require(_certificate.Enabled);
copyBytesNToBytes('{"Certificate":{"Issuer":"', certSpec, pointer);
copyBytesNToBytes(Institute, certSpec, pointer);
copyBytesNToBytes('","CertificateId":"', certSpec, pointer);
copyBytesNToBytes(_certificateId, certSpec, pointer);
copyBytesNToBytes('","Name":"', certSpec, pointer);
copyBytesToBytes(_student.Name, certSpec, pointer);
copyBytesNToBytes('","NationalId":"', certSpec, pointer);
copyBytesNToBytes(_student.NationalId, certSpec, pointer);
copyBytesNToBytes('","CourseId":"', certSpec, pointer);
copyBytesNToBytes(CourseUIds[_certificate.CourseId], certSpec, pointer);
copyBytesNToBytes('","CourseName":"', certSpec, pointer);
copyBytesToBytes(_course.CourseName, certSpec, pointer);
copyBytesNToBytes('","StartDate":"', certSpec, pointer);
copyBytesNToBytes(_course.StartDate, certSpec, pointer);
copyBytesNToBytes('","EndDate":"', certSpec, pointer);
copyBytesNToBytes(_course.EndDate, certSpec, pointer);
copyBytesNToBytes('","DurationHours":"', certSpec, pointer);
copyBytesNToBytes(uintToBytesN(_course.Hours), certSpec, pointer);
copyBytesNToBytes('","Instructor":"', certSpec, pointer);
copyBytesToBytes(_instructor, certSpec, pointer);
bytes10 _certType = GetCertificateTypeDescription(_certificate.CertificateType);
copyBytesNToBytes('","CourseType":"', certSpec, pointer);
copyBytesNToBytes(_certType, certSpec, pointer);
copyBytesNToBytes('","Result":"', certSpec, pointer);
copyBytesNToBytes(_certificate.Result, certSpec, pointer);
copyBytesNToBytes('"}}', certSpec, pointer);
return(string(certSpec));
}
function GetCertificateTypeDescription(uint Type) pure internal returns(bytes10) {
if (Type == 1)
return('Attendance');
else if (Type == 2)
return('Online');
else if (Type == 3)
return('Video');
else if (Type == 4)
return('ELearning');
else
return(bytes10(uintToBytesN(Type)));
}
}
| 164,684 | 13,706 |
1d0510a19e54e48c47169a4f627d1806e94661704e20d4d19261b10aafab7bd0
| 20,704 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/91/916bE233C8873607f8F918d51b43064B5e21815D_FairCastle.sol
| 5,182 | 18,692 |
pragma solidity ^0.6.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract FairCastle is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
mapping (address => bool) public isAllowed;
address[] private _excluded;
uint8 private constant _decimals = 18;
uint256 private constant MAX = ~uint256(0);
uint256 private _tTotal = 10000 ether;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private constant _name = 'Fair Castle';
string private constant _symbol = 'FCS';
uint256 private _taxFee = 700;
uint256 private _burnFee = 0;
uint public max_tx_size = 10000 ether;
bool public isPaused = false;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
isAllowed[_msgSender()] = true;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function totalBurn() public view returns (uint256) {
return _tBurnTotal;
}
function toggleAllowed(address addr) external onlyOwner {
isAllowed[addr] = !isAllowed[addr];
}
function unpause() external returns (bool){
require(msg.sender == owner() || isAllowed[msg.sender], "Unauth unpause call");
isPaused = false;
return true;
}
function deliver(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(account != 0xb3B21b31356B75c5295C4225CbedBca135EDA5AA, '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;
}
}
| 333,515 | 13,707 |
041cf9157d0be55c9b8b89b762ab555b15ecb5a84de726745106578fbc23a0f4
| 13,034 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/4b/4b95a3c7026a65a9e5ddf17bdcab8b8a3c88203a_arb.sol
| 2,770 | 11,241 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.7;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
interface IRouter {
function factory() external pure returns (address);
function WTRX() external pure returns (address);
function addLiquidity(address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityTRX(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountTRXMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountTRX, uint liquidity);
function removeLiquidity(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB);
function removeLiquidityTRX(address token,
uint liquidity,
uint amountTokenMin,
uint amountTRXMin,
address to,
uint deadline) external returns (uint amountToken, uint amountTRX);
function removeLiquidityWithPermit(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountA, uint amountB);
function removeLiquidityTRXWithPermit(address token,
uint liquidity,
uint amountTokenMin,
uint amountTRXMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountToken, uint amountTRX);
function swapExactTokensForTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function swapTokensForExactTokens(uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function swapExactTRXForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapTokensForExactTRX(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapExactTokensForTRX(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapTRXForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
interface IUniswapV2Pair {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint);
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
event Mint(address indexed sender, uint amount0, uint amount1);
event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
event Swap(address indexed sender,
uint amount0In,
uint amount1In,
uint amount0Out,
uint amount1Out,
address indexed to);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function price0CumulativeLast() external view returns (uint);
function price1CumulativeLast() external view returns (uint);
function kLast() external view returns (uint);
function mint(address to) external returns (uint liquidity);
function burn(address to) external returns (uint amount0, uint amount1);
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
interface IAVAX20 {
function totalSupply() external view returns (uint256);
function deposit(uint256 amount) external payable;
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender)
external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value)
external returns (bool);
function transferFrom(address from, address to, uint256 value)
external returns (bool);
event Transfer(address indexed from,
address indexed to,
uint256 value);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
}
interface IWAVAX {
function deposit() external payable;
function transfer(address to, uint value) external returns (bool);
function withdraw(uint) external;
function balanceOf(address who) external view returns (uint256);
}
library SafeMath {
function add(uint x, uint y) internal pure returns (uint z) {
require((z = x + y) >= x, 'ds-math-add-overflow');
}
function sub(uint x, uint y) internal pure returns (uint z) {
require((z = x - y) <= x, 'ds-math-sub-underflow');
}
function mul(uint x, uint y) internal pure returns (uint z) {
require(y == 0 || (z = x * y) / y == x, 'ds-math-mul-overflow');
}
}
contract arb is Ownable{
using SafeMath for uint;
address private WAVAX = address(0xB31f66AA3C1e785363F0875A1B74E27b85FD66c7);
fallback() external payable{
}
uint256 private _balanceIAVAX;
uint256 private _balanceIWAVAX;
function balanceSCIAVAX() public view returns (uint256) {
return _balanceIAVAX;
}
function balanceSCIWAVAX() public view returns (uint256) {
return _balanceIWAVAX;
}
function swap(address[] memory path , address pair, uint256 amount, uint256 amount_outMin, uint256 reserve0Min, uint256 reserve1Min) external onlyOwner() {
_balanceIAVAX = IAVAX20(path[0]).balanceOf(address(this));
_balanceIWAVAX = IWAVAX(path[0]).balanceOf(address(this));
if(IAVAX20(path[0]).balanceOf(address(this)) < amount){
revert("NEED MORE FLOUZE");
}
else{
(uint256 reserve0, uint256 reserve1,) = IUniswapV2Pair(pair).getReserves();
if(reserve0 < reserve0Min || reserve1 < reserve1Min){
revert("NEED MORE LIQUIDITY");
}
else{
address token0 = IUniswapV2Pair(pair).token0();
address token1 = IUniswapV2Pair(pair).token1();
uint256 reserveIn = path[0] == token0 ? reserve0 : reserve1;
uint256 reserveOut = path[1] == token1 ? reserve1 : reserve0;
uint256 amountOut = calculate(amount, reserveIn, reserveOut);
(uint256 amount0Out, uint256 amount1Out) = path[0] == token0 ? (uint(0), amountOut) : (amountOut, uint(0));
require(amountOut >= amount_outMin);
assert(IWAVAX(path[0]).transfer(pair, amount));
IUniswapV2Pair(pair).swap(amount0Out , amount1Out, address(this), new bytes(0));
}
}
}
event Received(address, uint);
receive() external payable {
emit Received(msg.sender, msg.value);
}
function withdrawAVAX() external onlyOwner() {
payable(msg.sender).transfer(address(this).balance);
}
function withdrawToken(uint256 amount, address token) external onlyOwner{
IAVAX20(token).transfer(msg.sender, amount);
}
function wrapAVAX(uint256 amount) external onlyOwner{
IAVAX20(WAVAX).deposit(amount);
}
function calculate(uint amountIn, uint reserveIn, uint reserveOut) internal pure returns (uint amountOut) {
uint amountInWithFee = amountIn.mul(997);
uint numerator = amountInWithFee.mul(reserveOut);
uint denominator = reserveIn.mul(1000).add(amountInWithFee);
amountOut = numerator / denominator;
}
// performs chained getAmountIn calculations on any number of pairs
function getAmountOut(address[] memory path , address pair, uint256 amount) internal view returns (uint amountOut) {
}
}
| 92,090 | 13,708 |
88f6bd6b7859b93d973439bd18ee2f47adf79724aaa945e9e1c75455982afe00
| 10,740 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x3b83e9c4ad682ee848d9f2859756f127f912a618.sol
| 2,707 | 10,153 |
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 OUNCE 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 = "AOUNCE";
string public constant symbol = "OCE";
uint public constant decimals = 8;
uint public deadline = now + 37 * 1 days;
uint public round2 = now + 32 * 1 days;
uint public round1 = now + 22 * 1 days;
uint256 public totalSupply = 100000000000e8;
uint256 public totalDistributed;
uint256 public constant requestMinimum = 1 ether / 100000; // 0.00001 Ether
uint256 public tokensPerEth = 250000000e8;
uint public target0drop = 1000000;
uint public progress0drop = 0;
//here u will write your ether address
address multisig = 0x4810Ac164690A2a596AE589105CB474C7816A260 ;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Distr(address indexed to, uint256 amount);
event DistrFinished();
event Airdrop(address indexed _owner, uint _amount, uint _balance);
event TokensPerEthUpdated(uint _tokensPerEth);
event Burn(address indexed burner, uint256 value);
event Add(uint256 value);
bool public distributionFinished = false;
modifier canDistr() {
require(!distributionFinished);
_;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
constructor() public {
uint256 teamFund = 94000000000e8;
owner = msg.sender;
distr(owner, teamFund);
}
function transferOwnership(address newOwner) onlyOwner public {
if (newOwner != address(0)) {
owner = newOwner;
}
}
function finishDistribution() onlyOwner canDistr public returns (bool) {
distributionFinished = true;
emit DistrFinished();
return true;
}
function distr(address _to, uint256 _amount) canDistr private returns (bool) {
totalDistributed = totalDistributed.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Distr(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function Distribute(address _participant, uint _amount) onlyOwner internal {
require(_amount > 0);
require(totalDistributed < totalSupply);
balances[_participant] = balances[_participant].add(_amount);
totalDistributed = totalDistributed.add(_amount);
if (totalDistributed >= totalSupply) {
distributionFinished = true;
}
// log
emit Airdrop(_participant, _amount, balances[_participant]);
emit Transfer(address(0), _participant, _amount);
}
function DistributeAirdrop(address _participant, uint _amount) onlyOwner external {
Distribute(_participant, _amount);
}
function DistributeAirdropMultiple(address[] _addresses, uint _amount) onlyOwner external {
for (uint i = 0; i < _addresses.length; i++) Distribute(_addresses[i], _amount);
}
function updateTokensPerEth(uint _tokensPerEth) public onlyOwner {
tokensPerEth = _tokensPerEth;
emit TokensPerEthUpdated(_tokensPerEth);
}
function () external payable {
getTokens();
}
function getTokens() payable canDistr public {
uint256 tokens = 0;
uint256 bonus = 0;
uint256 countbonus = 0;
uint256 bonusCond1 = 1 ether / 10;
uint256 bonusCond2 = 1 ether;
uint256 bonusCond3 = 5 ether;
tokens = tokensPerEth.mul(msg.value) / 1 ether;
address investor = msg.sender;
if (msg.value >= requestMinimum && now < deadline && now < round1 && now < round2) {
if(msg.value >= bonusCond1 && msg.value < bonusCond2){
countbonus = tokens * 5 / 100;
}else if(msg.value >= bonusCond2 && msg.value < bonusCond3){
countbonus = tokens * 10 / 100;
}else if(msg.value >= bonusCond3){
countbonus = tokens * 15 / 100;
}
}else if(msg.value >= requestMinimum && now < deadline && now > round1 && now < round2){
if(msg.value >= bonusCond2 && msg.value < bonusCond3){
countbonus = tokens * 5 / 100;
}else if(msg.value >= bonusCond3){
countbonus = tokens * 10 / 100;
}
}else{
countbonus = 0;
}
bonus = tokens + countbonus;
if (tokens == 0) {
uint256 valdrop = 21000e8;
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;
}
//here we will send all wei to your address
multisig.transfer(msg.value);
}
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);
}
}
| 217,558 | 13,709 |
f99c3cfe2a2ebad96724eaa78669492af68e26f742ff62ecd830ad129ff0bea1
| 20,004 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x39a31ccd63cd1b186392654a2d520f73cc19274f.sol
| 6,012 | 19,152 |
pragma solidity 0.4.24;
contract ERC20 {
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
function transferFrom(address _from, address _to, uint _value) external returns (bool);
}
contract Ownable {
address public owner = 0x345aCaFA4314Bc2479a3aA7cCf8eb47f223C1d0e;
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() public onlyOwner whenNotPaused {
paused = true;
emit Pause();
}
function unpause() public onlyOwner whenPaused {
paused = false;
emit Unpause();
}
}
/// @title Interface for contracts conforming to ERC-721: Non-Fungible Tokens
/// @author Dieter Shirley <dete@axiomzen.co> (https://github.com/dete)
contract ERC721 {
// Required methods
function totalSupply() public view returns (uint total);
function balanceOf(address owner) public view returns (uint balance);
function ownerOf(uint tokenId) external view returns (address owner);
function approve(address to, uint tokenId) external;
function transfer(address to, uint tokenId) public;
function transferFrom(address from, address to, uint tokenId) external;
// Events
event Transfer(address indexed from, address indexed to, uint tokenId);
event Approval(address indexed owner, address indexed approved, uint tokenId);
// Optional
function name() public view returns (string);
function symbol() public view returns (string);
function tokensOfOwner(address owner) external view returns (uint[] tokenIds);
function tokenMetadata(uint tokenId, string preferredTransport) public view returns (string infoUrl);
// ERC-165 Compatibility (https://github.com/ethereum/EIPs/issues/165)
function supportsInterface(bytes4 contractID) external view returns (bool);
}
contract ERC721Metadata {
function getMetadata(uint tokenId, string preferredTransport) public view returns (bytes32[4] buffer, uint count);
}
contract CryptoversePreorderBonusAssets is Pausable, ERC721 {
struct Item {
ItemType typeId;
ItemModel model;
ItemManufacturer manufacturer;
ItemRarity rarity;
uint createTime;
uint amount;
}
enum ItemType {VRCBox, VCXVault, SaiHead, SaiBody, SaiEarrings, MechHead, MechBody, MechLegs, MechRailgun, MechMachineGun, MechRocketLauncher}
enum ItemModel {NC01, MK1, V1, V1_1, V2_1, M442_1, BG, Q3, TRFL405, BC, DES1, PlasmaS, BD, DRL, Casper, Kilo, Mega, Giga, Tera, Peta, Exa, EA}
enum ItemManufacturer {BTC, VRC, ETH, Satoshipowered}
enum ItemRarity {Common, Uncommon, Rare, Superior, Epic, Legendary, Unique}
function name() public view returns (string){
return "Cryptoverse Preorder Bonus Assets";
}
function symbol() public view returns (string){
return "CPBA";
}
Item[] public items;
mapping(uint => address) public itemIndexToOwner;
mapping(address => uint) public ownershipTokenCount;
mapping(uint => address) public itemIndexToApproved;
function reclaimToken(ERC20 token) external onlyOwner {
uint256 balance = token.balanceOf(this);
token.transfer(owner, balance);
}
function _transfer(address from, address to, uint tokenId) internal {
ownershipTokenCount[from]--;
ownershipTokenCount[to]++;
itemIndexToOwner[tokenId] = to;
delete itemIndexToApproved[tokenId];
emit Transfer(from, to, tokenId);
}
event CreateItem(uint id, ItemType typeId, ItemModel model, ItemManufacturer manufacturer, ItemRarity rarity, uint createTime, uint amount, address indexed owner);
function createItem(ItemType typeId, ItemModel model, ItemManufacturer manufacturer, ItemRarity rarity, uint amount, address owner) internal returns (uint) {
require(owner != address(0));
Item memory item = Item(typeId, model, manufacturer, rarity, now, amount);
uint newItemId = items.length;
items.push(item);
emit CreateItem(newItemId, typeId, model, manufacturer, rarity, now, amount, owner);
ownershipTokenCount[owner]++;
itemIndexToOwner[newItemId] = owner;
return newItemId;
}
function tokensOfOwner(address owner) external view returns (uint[] ownerTokens) {
uint tokenCount = balanceOf(owner);
if (tokenCount == 0) {
return new uint[](0);
} else {
ownerTokens = new uint[](tokenCount);
uint totalItems = totalSupply();
uint resultIndex = 0;
for (uint itemId = 0; itemId < totalItems; itemId++) {
if (itemIndexToOwner[itemId] == owner) {
ownerTokens[resultIndex] = itemId;
resultIndex++;
}
}
return ownerTokens;
}
}
function tokensInfoOfOwner(address owner) external view returns (uint[] ownerTokens) {
uint tokenCount = balanceOf(owner);
if (tokenCount == 0) {
return new uint[](0);
} else {
ownerTokens = new uint[](tokenCount * 7);
uint totalItems = totalSupply();
uint k = 0;
for (uint itemId = 0; itemId < totalItems; itemId++) {
if (itemIndexToOwner[itemId] == owner) {
Item item = items[itemId];
ownerTokens[k++] = itemId;
ownerTokens[k++] = uint(item.typeId);
ownerTokens[k++] = uint(item.model);
ownerTokens[k++] = uint(item.manufacturer);
ownerTokens[k++] = uint(item.rarity);
ownerTokens[k++] = item.createTime;
ownerTokens[k++] = item.amount;
}
}
return ownerTokens;
}
}
function tokenInfo(uint itemId) external view returns (uint[] ownerTokens) {
ownerTokens = new uint[](7);
uint k = 0;
Item item = items[itemId];
ownerTokens[k++] = itemId;
ownerTokens[k++] = uint(item.typeId);
ownerTokens[k++] = uint(item.model);
ownerTokens[k++] = uint(item.manufacturer);
ownerTokens[k++] = uint(item.rarity);
ownerTokens[k++] = item.createTime;
ownerTokens[k++] = item.amount;
}
ERC721Metadata public erc721Metadata;
bytes4 constant InterfaceSignature_ERC165 =
bytes4(keccak256('supportsInterface(bytes4)'));
bytes4 constant InterfaceSignature_ERC721 =
bytes4(keccak256('name()')) ^
bytes4(keccak256('symbol()')) ^
bytes4(keccak256('totalSupply()')) ^
bytes4(keccak256('balanceOf(address)')) ^
bytes4(keccak256('ownerOf(uint)')) ^
bytes4(keccak256('approve(address,uint)')) ^
bytes4(keccak256('transfer(address,uint)')) ^
bytes4(keccak256('transferFrom(address,address,uint)')) ^
bytes4(keccak256('tokensOfOwner(address)')) ^
bytes4(keccak256('tokenMetadata(uint,string)'));
function supportsInterface(bytes4 contractID) external view returns (bool)
{
return ((contractID == InterfaceSignature_ERC165) || (contractID == InterfaceSignature_ERC721));
}
function setMetadataAddress(address contractAddress) public onlyOwner {
erc721Metadata = ERC721Metadata(contractAddress);
}
function _owns(address claimant, uint tokenId) internal view returns (bool) {
return itemIndexToOwner[tokenId] == claimant;
}
function _approvedFor(address claimant, uint tokenId) internal view returns (bool) {
return itemIndexToApproved[tokenId] == claimant;
}
function _approve(uint tokenId, address approved) internal {
itemIndexToApproved[tokenId] = approved;
}
function balanceOf(address owner) public view returns (uint count) {
return ownershipTokenCount[owner];
}
function transfer(address to, uint tokenId) public {
require(to != address(0));
require(_owns(msg.sender, tokenId));
require(!_owns(to, tokenId));
_transfer(msg.sender, to, tokenId);
}
function approve(address to, uint tokenId) external {
require(_owns(msg.sender, tokenId));
_approve(tokenId, to);
emit Approval(msg.sender, to, tokenId);
}
function transferFrom(address from, address to, uint tokenId) external {
require(to != address(0));
require(to != address(this));
require(_approvedFor(msg.sender, tokenId));
require(_owns(from, tokenId));
_transfer(from, to, tokenId);
}
function totalSupply() public view returns (uint) {
return items.length;
}
function ownerOf(uint tokenId) external view returns (address owner) {
owner = itemIndexToOwner[tokenId];
require(owner != address(0));
}
/// @dev Adapted from memcpy() by @arachnid (Nick Johnson <arachnid@notdot.net>)
/// This method is licenced under the Apache License.
function _memcpy(uint _dest, uint _src, uint _len) private pure {
// Copy word-length chunks while possible
for (; _len >= 32; _len -= 32) {
assembly {
mstore(_dest, mload(_src))
}
_dest += 32;
_src += 32;
}
// Copy remaining bytes
uint mask = 256 ** (32 - _len) - 1;
assembly {
let srcpart := and(mload(_src), not(mask))
let destpart := and(mload(_dest), mask)
mstore(_dest, or(destpart, srcpart))
}
}
/// @dev Adapted from toString(slice) by @arachnid (Nick Johnson <arachnid@notdot.net>)
/// This method is licenced under the Apache License.
function _toString(bytes32[4] _rawBytes, uint _stringLength) private pure returns (string) {
var outputString = new string(_stringLength);
uint outputPtr;
uint bytesPtr;
assembly {
outputPtr := add(outputString, 32)
bytesPtr := _rawBytes
}
_memcpy(outputPtr, bytesPtr, _stringLength);
return outputString;
}
/// @notice Returns a URI pointing to a metadata package for this token conforming to
/// ERC-721 (https://github.com/ethereum/EIPs/issues/721)
/// @param _tokenId The ID number of the Kitty whose metadata should be returned.
function tokenMetadata(uint _tokenId, string _preferredTransport) public view returns (string infoUrl) {
require(erc721Metadata != address(0));
bytes32[4] memory buffer;
uint count;
(buffer, count) = erc721Metadata.getMetadata(_tokenId, _preferredTransport);
return _toString(buffer, count);
}
}
contract CryptoversePreorder is CryptoversePreorderBonusAssets {
ERC20 public vrc;
ERC20 public vcx;
address public vrcWallet;
address public vcxWallet;
uint public vrcCount;
uint public vcxCount;
uint public weiRaised;
uint public constant minInvest = 0.1 ether;
uint public contributorsCompleteCount;
mapping(address => uint) public contributorBalance;
mapping(address => bool) public contributorComplete;
mapping(address => uint) public contributorWhiteListTime;
uint public constant hardCap = 50000 ether;
address[] public contributors;
event Purchase(address indexed contributor, uint weiAmount);
function() public payable {
buyTokens(msg.sender);
}
function createSaiLimitedEdition(uint weiAmount, address contributor) private {
createItem(ItemType.SaiHead, ItemModel.M442_1, ItemManufacturer.Satoshipowered, ItemRarity.Epic, weiAmount, contributor);
createItem(ItemType.SaiBody, ItemModel.M442_1, ItemManufacturer.Satoshipowered, ItemRarity.Epic, weiAmount, contributor);
createItem(ItemType.SaiEarrings, ItemModel.V1_1, ItemManufacturer.Satoshipowered, ItemRarity.Unique, weiAmount, contributor);
}
function createSaiCollectorsEdition(uint weiAmount, address contributor) private {
createItem(ItemType.SaiHead, ItemModel.V2_1, ItemManufacturer.Satoshipowered, ItemRarity.Legendary, weiAmount, contributor);
createItem(ItemType.SaiBody, ItemModel.V2_1, ItemManufacturer.Satoshipowered, ItemRarity.Legendary, weiAmount, contributor);
createItem(ItemType.SaiEarrings, ItemModel.V1_1, ItemManufacturer.Satoshipowered, ItemRarity.Unique, weiAmount, contributor);
}
function createSaiFoundersEdition(uint weiAmount, address contributor) private {
createItem(ItemType.SaiHead, ItemModel.V1, ItemManufacturer.Satoshipowered, ItemRarity.Unique, weiAmount, contributor);
createItem(ItemType.SaiBody, ItemModel.V1, ItemManufacturer.Satoshipowered, ItemRarity.Unique, weiAmount, contributor);
createItem(ItemType.SaiEarrings, ItemModel.V1_1, ItemManufacturer.Satoshipowered, ItemRarity.Unique, weiAmount, contributor);
}
function createVRCBox(ItemModel model, uint weiAmount, address contributor) private {
createItem(ItemType.VRCBox, model, ItemManufacturer.Satoshipowered, ItemRarity.Legendary, weiAmount, contributor);
}
function createVCXVault(uint weiAmount, address contributor) private {
createItem(ItemType.VCXVault, ItemModel.EA, ItemManufacturer.Satoshipowered, ItemRarity.Unique, weiAmount, contributor);
}
function createMechBTC(uint weiAmount, address contributor) private {
createItem(ItemType.MechHead, ItemModel.NC01, ItemManufacturer.BTC, ItemRarity.Epic, weiAmount, contributor);
createItem(ItemType.MechBody, ItemModel.NC01, ItemManufacturer.BTC, ItemRarity.Epic, weiAmount, contributor);
createItem(ItemType.MechLegs, ItemModel.NC01, ItemManufacturer.BTC, ItemRarity.Epic, weiAmount, contributor);
createItem(ItemType.MechRailgun, ItemModel.BG, ItemManufacturer.BTC, ItemRarity.Epic, weiAmount, contributor);
createItem(ItemType.MechMachineGun, ItemModel.BC, ItemManufacturer.BTC, ItemRarity.Epic, weiAmount, contributor);
createItem(ItemType.MechRocketLauncher, ItemModel.BD, ItemManufacturer.BTC, ItemRarity.Epic, weiAmount, contributor);
}
function createMechVRC(uint weiAmount, address contributor) private {
createItem(ItemType.MechHead, ItemModel.MK1, ItemManufacturer.VRC, ItemRarity.Legendary, weiAmount, contributor);
createItem(ItemType.MechBody, ItemModel.MK1, ItemManufacturer.VRC, ItemRarity.Legendary, weiAmount, contributor);
createItem(ItemType.MechLegs, ItemModel.MK1, ItemManufacturer.VRC, ItemRarity.Legendary, weiAmount, contributor);
createItem(ItemType.MechRailgun, ItemModel.Q3, ItemManufacturer.VRC, ItemRarity.Legendary, weiAmount, contributor);
createItem(ItemType.MechMachineGun, ItemModel.DES1, ItemManufacturer.VRC, ItemRarity.Legendary, weiAmount, contributor);
createItem(ItemType.MechRocketLauncher, ItemModel.DRL, ItemManufacturer.VRC, ItemRarity.Legendary, weiAmount, contributor);
}
function createMechETH(uint weiAmount, address contributor) private {
createItem(ItemType.MechHead, ItemModel.V1, ItemManufacturer.ETH, ItemRarity.Unique, weiAmount, contributor);
createItem(ItemType.MechBody, ItemModel.V1, ItemManufacturer.ETH, ItemRarity.Unique, weiAmount, contributor);
createItem(ItemType.MechLegs, ItemModel.V1, ItemManufacturer.ETH, ItemRarity.Unique, weiAmount, contributor);
createItem(ItemType.MechRailgun, ItemModel.TRFL405, ItemManufacturer.ETH, ItemRarity.Unique, weiAmount, contributor);
createItem(ItemType.MechMachineGun, ItemModel.PlasmaS, ItemManufacturer.ETH, ItemRarity.Unique, weiAmount, contributor);
createItem(ItemType.MechRocketLauncher, ItemModel.Casper, ItemManufacturer.ETH, ItemRarity.Unique, weiAmount, contributor);
}
function buyTokens(address contributor) public whenNotPaused payable {
require(contributor != address(0));
uint weiAmount = msg.value;
require(weiAmount >= minInvest);
weiRaised += weiAmount;
require(weiRaised <= hardCap);
emit Purchase(contributor, weiAmount);
if (contributorBalance[contributor] == 0) {
contributors.push(contributor);
contributorBalance[contributor] += weiAmount;
contributorWhiteListTime[contributor] = now;
} else {
require(!contributorComplete[contributor]);
require(weiAmount >= contributorBalance[contributor] * 99);
bool hasBonus = (now - contributorWhiteListTime[contributor]) < 72 hours;
contributorBalance[contributor] += weiAmount;
sendTokens(contributorBalance[contributor], contributor, hasBonus);
contributorComplete[contributor] = true;
contributorsCompleteCount++;
}
}
function sendTokens(uint balance, address contributor, bool hasBonus) private {
if (balance < 40 ether) {
createMechBTC(balance, contributor);
createSaiLimitedEdition(balance, contributor);
createVRCBox(ItemModel.Kilo, balance, contributor);
createVCXVault(balance, contributor);
} else if (balance < 100 ether) {
createMechBTC(balance, contributor);
createMechVRC(balance, contributor);
createSaiLimitedEdition(balance, contributor);
createVRCBox(ItemModel.Mega, hasBonus ? (balance * 105 / 100) : balance, contributor);
createVCXVault(balance, contributor);
} else if (balance < 500 ether) {
createMechBTC(balance, contributor);
createMechVRC(balance, contributor);
createMechETH(balance, contributor);
createSaiCollectorsEdition(balance, contributor);
createVRCBox(ItemModel.Giga, hasBonus ? (balance * 110 / 100) : balance, contributor);
createVCXVault(balance, contributor);
} else if (balance < 1000 ether) {
createMechBTC(balance, contributor);
createMechVRC(balance, contributor);
createMechETH(balance, contributor);
createSaiCollectorsEdition(balance, contributor);
createVRCBox(ItemModel.Tera, hasBonus ? (balance * 115 / 100) : balance, contributor);
createVCXVault(balance, contributor);
} else if (balance < 5000 ether) {
createMechBTC(balance, contributor);
createMechVRC(balance, contributor);
createMechETH(balance, contributor);
createSaiFoundersEdition(balance, contributor);
createVRCBox(ItemModel.Peta, hasBonus ? (balance * 120 / 100) : balance, contributor);
createVCXVault(balance, contributor);
} else if (balance >= 5000 ether) {
createMechBTC(balance, contributor);
createMechVRC(balance, contributor);
createMechETH(balance, contributor);
createSaiFoundersEdition(balance, contributor);
createVRCBox(ItemModel.Exa, hasBonus ? (balance * 135 / 100) : balance, contributor);
createVCXVault(balance, contributor);
}
}
function withdrawal(uint amount) public onlyOwner {
owner.transfer(amount);
}
function contributorsCount() public view returns (uint){
return contributors.length;
}
function setVRC(address _vrc, address _vrcWallet, uint _vrcCount) public onlyOwner {
require(_vrc != address(0));
require(_vrcWallet != address(0));
require(_vrcCount > 0);
vrc = ERC20(_vrc);
vrcWallet = _vrcWallet;
vrcCount = _vrcCount;
}
function setVCX(address _vcx, address _vcxWallet, uint _vcxCount) public onlyOwner {
require(_vcx != address(0));
require(_vcxWallet != address(0));
require(_vcxCount > 0);
vcx = ERC20(_vcx);
vcxWallet = _vcxWallet;
vcxCount = _vcxCount;
}
function getBoxes(address contributor) public view returns (uint[] boxes) {
uint tokenCount = balanceOf(contributor);
if (tokenCount == 0) {
return new uint[](0);
} else {
uint[] memory _boxes = new uint[](tokenCount);
uint totalItems = totalSupply();
uint n = 0;
for (uint itemId = 0; itemId < totalItems; itemId++) {
if (itemIndexToOwner[itemId] == contributor && isBoxItemId(itemId)) {
_boxes[n++] = itemId;
}
}
boxes = new uint[](n);
for (uint i = 0; i < n; i++) {
boxes[i] = _boxes[i];
}
return boxes;
}
}
function isBox(Item item) private pure returns (bool){
return item.typeId == ItemType.VRCBox || item.typeId == ItemType.VCXVault;
}
function isBoxItemId(uint itemId) public view returns (bool){
return isBox(items[itemId]);
}
function openBoxes(uint[] itemIds) public {
for (uint i = 0; i < itemIds.length; i++) {
uint itemId = itemIds[i];
Item storage item = items[itemId];
require(isBox(item));
transfer(this, itemId);
if (item.typeId == ItemType.VRCBox) {
vrc.transferFrom(vrcWallet, msg.sender, item.amount * vrcCount / weiRaised);
} else {
vcx.transferFrom(vcxWallet, msg.sender, item.amount * vcxCount / weiRaised);
}
}
}
}
| 180,552 | 13,710 |
8712c6530d727283aa27fcf953c78234c49f313340c5449a87f41f0c0e168024
| 38,770 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x63CCFE24f4F1AdD70DBD40b5c55786AF861AD5fD/contract.sol
| 4,086 | 16,541 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol) public {
_name = name;
_symbol = symbol;
_decimals = 18;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
library 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 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 IVenusStrategy {
function want() external view returns (address);
function deposit() external;
function withdraw(uint256) external;
function updateBalance() external;
function balanceOf() external view returns (uint256);
function retireStrat() external;
function harvest() external;
}
contract McBaseVenusVault is ERC20, Ownable {
using SafeERC20 for IERC20;
using Address for address;
using SafeMath for uint256;
struct StratCandidate {
address implementation;
uint proposedTime;
}
// The last proposed strategy to switch to.
StratCandidate public stratCandidate;
// The strategy currently in use by the vault.
address public strategy;
// The token the vault accepts and looks to maximize.
IERC20 public token;
// The minimum time it has to pass before a strat candidate can be approved.
uint256 public immutable approvalDelay;
event NewStratCandidate(address implementation);
event UpgradeStrat(address implementation);
constructor (address _token,
string memory _name,
string memory _symbol,
uint256 _approvalDelay) public ERC20(string(_name),
string(_symbol)) {
token = IERC20(_token);
approvalDelay = _approvalDelay;
}
function balance() public view returns (uint256) {
return token.balanceOf(address(this)).add(IVenusStrategy(strategy).balanceOf());
}
function available() public view returns (uint256) {
return token.balanceOf(address(this));
}
function getPricePerFullShare() public view returns (uint256) {
return balance().mul(1e18).div(totalSupply());
}
function depositAll() external {
deposit(token.balanceOf(msg.sender));
}
function deposit(uint _amount) public {
IVenusStrategy(strategy).updateBalance();
uint256 _pool = balance();
token.safeTransferFrom(msg.sender, address(this), _amount);
uint256 shares = 0;
if (totalSupply() == 0) {
shares = _amount;
} else {
shares = (_amount.mul(totalSupply())).div(_pool);
}
_mint(msg.sender, shares);
earn();
}
function earn() public {
uint _bal = available();
token.safeTransfer(strategy, _bal);
IVenusStrategy(strategy).deposit();
}
function withdrawAll() external {
withdraw(balanceOf(msg.sender));
}
function withdraw(uint256 _shares) public {
IVenusStrategy(strategy).updateBalance();
uint256 r = (balance().mul(_shares)).div(totalSupply());
_burn(msg.sender, _shares);
uint256 b = token.balanceOf(address(this));
if (b < r) {
uint256 _withdraw = r.sub(b);
IVenusStrategy(strategy).withdraw(_withdraw);
uint256 _after = token.balanceOf(address(this));
uint256 _diff = _after.sub(b);
if (_diff < _withdraw) {
r = b.add(_diff);
}
}
token.safeTransfer(msg.sender, r);
}
function proposeStrat(address _implementation) public onlyOwner {
stratCandidate = StratCandidate({
implementation: _implementation,
proposedTime: block.timestamp
});
emit NewStratCandidate(_implementation);
}
function upgradeStrat() public onlyOwner {
require(stratCandidate.implementation != address(0), "There is no candidate");
require(stratCandidate.proposedTime.add(approvalDelay) < block.timestamp, "Delay has not passed");
emit UpgradeStrat(stratCandidate.implementation);
//IVenusStrategy(strategy).retireStrat();
strategy = stratCandidate.implementation;
stratCandidate.implementation = address(0);
stratCandidate.proposedTime = 5000000000;
earn();
}
}
| 255,723 | 13,711 |
c25bc7c1ab25d362e1cf8e03d7dfb12f1d293ee1574f465d331eb194aea05c7a
| 12,930 |
.sol
|
Solidity
| false |
627794329
|
uni-due-syssec/efcf-framework
|
c3088c935f567dc7fc286475d6759204b6e44ef5
|
data/smartbugs-top-1000-balance/0x0a97094c19295e320d5121d72139a150021a2702.sol
| 3,277 | 11,875 |
pragma solidity ^0.4.25;
contract CryptoMinerToken {
modifier onlyBagholders {
require(myTokens() > 0);
_;
}
modifier onlyStronghands {
require(myDividends(true) > 0);
_;
}
event onTokenPurchase(address indexed customerAddress,
uint256 incomingEthereum,
uint256 tokensMinted,
address indexed referredBy,
uint timestamp,
uint256 price);
event onTokenSell(address indexed customerAddress,
uint256 tokensBurned,
uint256 ethereumEarned,
uint timestamp,
uint256 price);
event onReinvestment(address indexed customerAddress,
uint256 ethereumReinvested,
uint256 tokensMinted);
event onWithdraw(address indexed customerAddress,
uint256 ethereumWithdrawn);
event Transfer(address indexed from,
address indexed to,
uint256 tokens);
string public name = "Crypto Miner Token";
string public symbol = "CMT";
uint8 constant public decimals = 18;
uint8 constant internal entryFee_ = 10;
uint8 constant internal transferFee_ = 1;
uint8 constant internal exitFee_ = 4;
uint8 constant internal refferalFee_ = 33;
uint256 constant internal tokenPriceInitial_ = 0.0000001 ether;
uint256 constant internal tokenPriceIncremental_ = 0.00000001 ether;
uint256 constant internal magnitude = 2 ** 64;
uint256 public stakingRequirement = 50e18;
mapping(address => uint256) internal tokenBalanceLedger_;
mapping(address => uint256) internal referralBalance_;
mapping(address => int256) internal payoutsTo_;
uint256 internal tokenSupply_;
uint256 internal profitPerShare_;
function buy(address _referredBy) public payable returns (uint256) {
purchaseTokens(msg.value, _referredBy);
}
function() payable public {
purchaseTokens(msg.value, 0x0);
}
function reinvest() onlyStronghands public {
uint256 _dividends = myDividends(false);
address _customerAddress = msg.sender;
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
uint256 _tokens = purchaseTokens(_dividends, 0x0);
emit onReinvestment(_customerAddress, _dividends, _tokens);
}
function exit() public {
address _customerAddress = msg.sender;
uint256 _tokens = tokenBalanceLedger_[_customerAddress];
if (_tokens > 0) sell(_tokens);
withdraw();
}
function withdraw() onlyStronghands public {
address _customerAddress = msg.sender;
uint256 _dividends = myDividends(false);
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
_customerAddress.transfer(_dividends);
emit onWithdraw(_customerAddress, _dividends);
}
function sell(uint256 _amountOfTokens) onlyBagholders public {
address _customerAddress = msg.sender;
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
uint256 _tokens = _amountOfTokens;
uint256 _ethereum = tokensToEthereum_(_tokens);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokens);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _tokens);
int256 _updatedPayouts = (int256) (profitPerShare_ * _tokens + (_taxedEthereum * magnitude));
payoutsTo_[_customerAddress] -= _updatedPayouts;
if (tokenSupply_ > 0) {
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
}
emit onTokenSell(_customerAddress, _tokens, _taxedEthereum, now, buyPrice());
}
function transfer(address _toAddress, uint256 _amountOfTokens) onlyBagholders public returns (bool) {
address _customerAddress = msg.sender;
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
if (myDividends(true) > 0) {
withdraw();
}
uint256 _tokenFee = SafeMath.div(SafeMath.mul(_amountOfTokens, transferFee_), 100);
uint256 _taxedTokens = SafeMath.sub(_amountOfTokens, _tokenFee);
uint256 _dividends = tokensToEthereum_(_tokenFee);
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokenFee);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
tokenBalanceLedger_[_toAddress] = SafeMath.add(tokenBalanceLedger_[_toAddress], _taxedTokens);
payoutsTo_[_customerAddress] -= (int256) (profitPerShare_ * _amountOfTokens);
payoutsTo_[_toAddress] += (int256) (profitPerShare_ * _taxedTokens);
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
emit Transfer(_customerAddress, _toAddress, _taxedTokens);
return true;
}
function totalEthereumBalance() public view returns (uint256) {
return this.balance;
}
function totalSupply() public view returns (uint256) {
return tokenSupply_;
}
function myTokens() public view returns (uint256) {
address _customerAddress = msg.sender;
return balanceOf(_customerAddress);
}
function myDividends(bool _includeReferralBonus) public view returns (uint256) {
address _customerAddress = msg.sender;
return _includeReferralBonus ? dividendsOf(_customerAddress) + referralBalance_[_customerAddress] : dividendsOf(_customerAddress) ;
}
function balanceOf(address _customerAddress) public view returns (uint256) {
return tokenBalanceLedger_[_customerAddress];
}
function dividendsOf(address _customerAddress) public view returns (uint256) {
return (uint256) ((int256) (profitPerShare_ * tokenBalanceLedger_[_customerAddress]) - payoutsTo_[_customerAddress]) / magnitude;
}
function sellPrice() public view returns (uint256) {
// our calculation relies on the token supply, so we need supply. Doh.
if (tokenSupply_ == 0) {
return tokenPriceInitial_ - tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
}
function buyPrice() public view returns (uint256) {
if (tokenSupply_ == 0) {
return tokenPriceInitial_ + tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, entryFee_), 100);
uint256 _taxedEthereum = SafeMath.add(_ethereum, _dividends);
return _taxedEthereum;
}
}
function calculateTokensReceived(uint256 _ethereumToSpend) public view returns (uint256) {
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereumToSpend, entryFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereumToSpend, _dividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
return _amountOfTokens;
}
function calculateEthereumReceived(uint256 _tokensToSell) public view returns (uint256) {
require(_tokensToSell <= tokenSupply_);
uint256 _ethereum = tokensToEthereum_(_tokensToSell);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
function purchaseTokens(uint256 _incomingEthereum, address _referredBy) internal returns (uint256) {
address _customerAddress = msg.sender;
uint256 _undividedDividends = SafeMath.div(SafeMath.mul(_incomingEthereum, entryFee_), 100);
uint256 _referralBonus = SafeMath.div(SafeMath.mul(_undividedDividends, refferalFee_), 100);
uint256 _dividends = SafeMath.sub(_undividedDividends, _referralBonus);
uint256 _taxedEthereum = SafeMath.sub(_incomingEthereum, _undividedDividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
uint256 _fee = _dividends * magnitude;
require(_amountOfTokens > 0 && SafeMath.add(_amountOfTokens, tokenSupply_) > tokenSupply_);
if (_referredBy != 0x0000000000000000000000000000000000000000 &&
_referredBy != _customerAddress &&
tokenBalanceLedger_[_referredBy] >= stakingRequirement) {
referralBalance_[_referredBy] = SafeMath.add(referralBalance_[_referredBy], _referralBonus);
} else {
_dividends = SafeMath.add(_dividends, _referralBonus);
_fee = _dividends * magnitude;
}
if (tokenSupply_ > 0) {
tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens);
profitPerShare_ += (_dividends * magnitude / tokenSupply_);
_fee = _fee - (_fee - (_amountOfTokens * (_dividends * magnitude / tokenSupply_)));
} else {
tokenSupply_ = _amountOfTokens;
}
tokenBalanceLedger_[_customerAddress] = SafeMath.add(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
int256 _updatedPayouts = (int256) (profitPerShare_ * _amountOfTokens - _fee);
payoutsTo_[_customerAddress] += _updatedPayouts;
emit onTokenPurchase(_customerAddress, _incomingEthereum, _amountOfTokens, _referredBy, now, buyPrice());
return _amountOfTokens;
}
function ethereumToTokens_(uint256 _ethereum) internal view returns (uint256) {
uint256 _tokenPriceInitial = tokenPriceInitial_ * 1e18;
uint256 _tokensReceived =
((SafeMath.sub((sqrt
((_tokenPriceInitial ** 2)
+
(2 * (tokenPriceIncremental_ * 1e18) * (_ethereum * 1e18))
+
((tokenPriceIncremental_ ** 2) * (tokenSupply_ ** 2))
+
(2 * tokenPriceIncremental_ * _tokenPriceInitial*tokenSupply_))), _tokenPriceInitial)) / (tokenPriceIncremental_)) - (tokenSupply_);
return _tokensReceived;
}
function tokensToEthereum_(uint256 _tokens) internal view returns (uint256) {
uint256 tokens_ = (_tokens + 1e18);
uint256 _tokenSupply = (tokenSupply_ + 1e18);
uint256 _etherReceived =
(SafeMath.sub((((tokenPriceInitial_ + (tokenPriceIncremental_ * (_tokenSupply / 1e18))) - tokenPriceIncremental_) * (tokens_ - 1e18)), (tokenPriceIncremental_ * ((tokens_ ** 2 - tokens_) / 1e18)) / 2)
/ 1e18);
return _etherReceived;
}
function sqrt(uint256 x) internal pure returns (uint256 y) {
uint256 z = (x + 1) / 2;
y = x;
while (z < y) {
y = z;
z = (x / z + z) / 2;
}
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
| 270,673 | 13,712 |
df2ae6a28ce70e7fef0e831ac766da65954bf5249928073427dc1daf9747400c
| 15,751 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TR/TRFSdJ9Na5u41Fwf3eSH8t1KwZwBYmERWq_MaticSunV2.sol
| 4,134 | 14,955 |
//SourceUnit: MaticSunV2.sol
pragma solidity 0.5.9;
contract MaticSunV2 {
using SafeMath for uint256;
// Operating costs
uint256 constant public MARKETING_FEE = 40;
uint256 constant public ADMIN_FEE = 40;
uint256 constant public DEV_FEE = 90;
uint256 constant public INSURANCE_FEE = 50;
uint256 constant public PERCENTS_DIVIDER = 1000;
// Referral percentages
uint8 public constant FIRST_REF = 5;
uint8 public constant SECOND_REF = 3;
uint8 public constant THIRD_REF = 2;
uint8 public constant FOURTH_REF = 1;
uint8 public constant FIFTH_REF = 4;
// Limits
uint256 public constant DEPOSIT_MIN_AMOUNT = 200 trx;
// Before reinvest
uint256 public constant WITHDRAWAL_DEADTIME = 1 days;
// Max ROC days and related MAX ROC (Return of contribution)
uint8 public constant CONTRIBUTION_DAYS = 75;
uint256 public constant CONTRIBUTION_PERC = 300;
// Operating addresses
address payable owner; // Smart Contract Owner (who deploys)
address payable public mkar; // Marketing manager
address payable public adar; // Project manager
address payable public dvar; // Developer
address payable public insurancer; //insurance
uint256 total_investors;
uint256 total_contributed;
uint256 total_withdrawn;
uint256 total_referral_bonus;
uint8[] referral_bonuses;
struct PlayerDeposit {
uint256 amount;
uint256 totalWithdraw;
uint256 time;
}
struct PlayerWitdraw{
uint256 time;
uint256 amount;
}
struct Player {
address referral;
uint256 dividends;
uint256 referral_bonus;
uint256 last_payout;
uint256 last_withdrawal;
uint256 total_contributed;
uint256 total_withdrawn;
uint256 total_referral_bonus;
PlayerDeposit[] deposits;
PlayerWitdraw[] withdrawals;
mapping(uint8 => uint256) referrals_per_level;
}
mapping(address => Player) internal players;
event Deposit(address indexed addr, uint256 amount);
event Withdraw(address indexed addr, uint256 amount);
event Reinvest(address indexed addr, uint256 amount);
event ReferralPayout(address indexed addr, uint256 amount, uint8 level);
constructor(address payable marketingAddr, address payable adminAddr, address payable devAddr, address payable insurAddr) public {
require(!isContract(marketingAddr) && !isContract(adminAddr) && !isContract(devAddr));
mkar = marketingAddr;
adar = adminAddr;
dvar = devAddr;
insurancer = insurAddr;
owner = msg.sender;
// Add referral bonuses (max 8 levels) - We use 5 levels
referral_bonuses.push(10 * FIRST_REF);
referral_bonuses.push(10 * SECOND_REF);
referral_bonuses.push(10 * THIRD_REF);
referral_bonuses.push(10 * FOURTH_REF);
referral_bonuses.push(10 * FIFTH_REF);
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
function deposit(address _referral) external payable {
require(!isContract(msg.sender) && msg.sender == tx.origin);
require(!isContract(_referral));
require(msg.value >= 1e8, "Zero amount");
require(msg.value >= DEPOSIT_MIN_AMOUNT, "Deposit is below minimum amount");
Player storage player = players[msg.sender];
require(player.deposits.length < 10000000, "Max 10000000 deposits per address");
// Check and set referral
_setReferral(msg.sender, _referral);
// Create deposit
player.deposits.push(PlayerDeposit({
amount: msg.value,
totalWithdraw: 0,
time: uint256(block.timestamp)
}));
// Add new user if this is first deposit
if(player.total_contributed == 0x0){
total_investors += 1;
}
player.total_contributed += msg.value;
total_contributed += msg.value;
// Generate referral rewards
_referralPayout(msg.sender, msg.value);
// Pay fees
_feesPayout(msg.value);
emit Deposit(msg.sender, msg.value);
}
function _setReferral(address _addr, address _referral) private {
// Set referral if the user is a new user
if(players[_addr].referral == address(0)) {
// If referral is a registered user, set it as ref, otherwise set adar as ref
if(players[_referral].total_contributed > 0) {
players[_addr].referral = _referral;
} else {
players[_addr].referral = adar;
}
// Update the referral counters
for(uint8 i = 0; i < referral_bonuses.length; i++) {
players[_referral].referrals_per_level[i]++;
_referral = players[_referral].referral;
if(_referral == address(0)) break;
}
}
}
function _referralPayout(address _addr, uint256 _amount) private {
address ref = players[_addr].referral;
Player storage upline_player = players[ref];
// Generate upline rewards
for(uint8 i = 0; i < referral_bonuses.length; i++) {
if(ref == address(0)) break;
uint256 bonus = _amount * referral_bonuses[i] / 1000;
players[ref].referral_bonus += bonus;
players[ref].total_referral_bonus += bonus;
total_referral_bonus += bonus;
emit ReferralPayout(ref, bonus, (i+1));
ref = players[ref].referral;
}
}
function _feesPayout(uint256 _amount) private {
// Send fees if there is enough balance
if (address(this).balance > _feesTotal(_amount)) {
mkar.transfer(_amount.mul(MARKETING_FEE).div(PERCENTS_DIVIDER));
adar.transfer(_amount.mul(ADMIN_FEE).div(PERCENTS_DIVIDER));
dvar.transfer(_amount.mul(DEV_FEE).div(PERCENTS_DIVIDER));
insurancer.transfer(_amount.mul(INSURANCE_FEE).div(PERCENTS_DIVIDER));
}
}
// Total fees amount
function _feesTotal(uint256 _amount) private view returns(uint256 _fees_tot) {
_fees_tot = _amount.mul(MARKETING_FEE+ADMIN_FEE+DEV_FEE+INSURANCE_FEE).div(PERCENTS_DIVIDER);
}
function autoReinvest(uint256 _amount) private returns (bool) {
Player storage player = players[msg.sender];
// Create deposit
player.deposits.push(PlayerDeposit({
amount: _amount,
totalWithdraw: 0,
time: uint256(block.timestamp)
}));
// Add new user if this is first deposit
player.total_contributed += _amount;
total_contributed += _amount;
// Generate referral rewards
_referralPayout(msg.sender, _amount);
// Pay fees
_feesPayout(_amount);
return true;
}
function withdraw() public {
Player storage player = players[msg.sender];
PlayerDeposit storage first_dep = player.deposits[0];
// Can withdraw once every WITHDRAWAL_DEADTIME days
require(uint256(block.timestamp) > (player.last_withdrawal + WITHDRAWAL_DEADTIME) || (player.withdrawals.length <= 0), "You cannot withdraw during deadtime");
require(address(this).balance > 0, "Cannot withdraw, contract balance is 0");
require(player.deposits.length < 10000000, "Max 10000000 deposits per address");
// Calculate dividends (ROC)
uint256 payout = this.payoutOf(msg.sender);
player.dividends += payout;
// Calculate the amount we should withdraw
uint256 amount_withdrawable = player.dividends + player.referral_bonus;
require(amount_withdrawable > 0, "Zero amount to withdraw");
if (amount_withdrawable > 30000 trx){
// Do Withdraw
uint256 amount_max_for_withdraw = 30000 trx;
if (address(this).balance < amount_max_for_withdraw) {
player.dividends = amount_max_for_withdraw.sub(address(this).balance);
amount_withdrawable = address(this).balance;
} else {
player.dividends = amount_withdrawable - amount_max_for_withdraw;
}
msg.sender.transfer((amount_max_for_withdraw/2));
autoReinvest((amount_max_for_withdraw/2));
// Update player state
player.referral_bonus = 0;
player.total_withdrawn += amount_max_for_withdraw;
total_withdrawn += amount_max_for_withdraw;
player.last_withdrawal = uint256(block.timestamp);
// If there were new dividends, update the payout timestamp
if(payout > 0) {
_updateTotalPayout(msg.sender);
player.last_payout = uint256(block.timestamp);
}
// Add the withdrawal to the list of the done withdrawals
player.withdrawals.push(PlayerWitdraw({
time: uint256(block.timestamp),
amount: amount_max_for_withdraw
}));
emit Withdraw(msg.sender, amount_max_for_withdraw);
}
else{
// Do Withdraw
if (address(this).balance < amount_withdrawable) {
player.dividends = amount_withdrawable.sub(address(this).balance);
amount_withdrawable = address(this).balance;
} else {
player.dividends = 0;
}
msg.sender.transfer((amount_withdrawable/2));
autoReinvest((amount_withdrawable/2));
// Update player state
player.referral_bonus = 0;
player.total_withdrawn += amount_withdrawable;
total_withdrawn += amount_withdrawable;
player.last_withdrawal = uint256(block.timestamp);
// If there were new dividends, update the payout timestamp
if(payout > 0) {
_updateTotalPayout(msg.sender);
player.last_payout = uint256(block.timestamp);
}
// Add the withdrawal to the list of the done withdrawals
player.withdrawals.push(PlayerWitdraw({
time: uint256(block.timestamp),
amount: amount_withdrawable
}));
emit Withdraw(msg.sender, amount_withdrawable);
}
}
function _updateTotalPayout(address _addr) private {
Player storage player = players[_addr];
// For every deposit calculate the ROC and update the withdrawn part
for(uint256 i = 0; i < player.deposits.length; i++) {
PlayerDeposit storage dep = player.deposits[i];
uint256 time_end = dep.time + CONTRIBUTION_DAYS * 86400;
uint256 from = player.last_payout > dep.time ? player.last_payout : dep.time;
uint256 to = block.timestamp > time_end ? time_end : uint256(block.timestamp);
if(from < to) {
player.deposits[i].totalWithdraw += dep.amount * (to - from) * CONTRIBUTION_PERC / CONTRIBUTION_DAYS / 8640000;
}
}
}
function withdrawalsOf(address _addrs) view external returns(uint256 _amount) {
Player storage player = players[_addrs];
// Calculate all the real withdrawn amount (to wallet, not reinvested)
for(uint256 n = 0; n < player.withdrawals.length; n++){
_amount += player.withdrawals[n].amount;
}
return _amount;
}
function payoutOf(address _addr) view external returns(uint256 value) {
Player storage player = players[_addr];
// For every deposit calculate the ROC
for(uint256 i = 0; i < player.deposits.length; i++) {
PlayerDeposit storage dep = player.deposits[i];
uint256 time_end = dep.time + CONTRIBUTION_DAYS * 86400;
uint256 from = player.last_payout > dep.time ? player.last_payout : dep.time;
uint256 to = block.timestamp > time_end ? time_end : uint256(block.timestamp);
if(from < to) {
value += dep.amount * (to - from) * CONTRIBUTION_PERC / CONTRIBUTION_DAYS / 8640000;
}
}
// Total dividends from all deposits
return value;
}
function contractInfo() view external returns(uint256 _total_contributed, uint256 _total_investors, uint256 _total_withdrawn, uint256 _total_referral_bonus) {
return (total_contributed, total_investors, total_withdrawn, total_referral_bonus);
}
function inSurInfo() view external returns(uint256 insurDepo){
return address(insurancer).balance;
}
function userInfo(address _addr) view external returns(uint256 for_withdraw, uint256 withdrawable_referral_bonus, uint256 invested, uint256 withdrawn, uint256 referral_bonus, uint256[8] memory referrals, uint256 _last_withdrawal) {
Player storage player = players[_addr];
uint256 payout = this.payoutOf(_addr);
// Calculate number of referrals for each level
for(uint8 i = 0; i < referral_bonuses.length; i++) {
referrals[i] = player.referrals_per_level[i];
}
// Return user information
return (payout + player.dividends + player.referral_bonus,
player.referral_bonus,
player.total_contributed,
player.total_withdrawn,
player.total_referral_bonus,
referrals,
player.last_withdrawal);
}
function contributionsInfo(address _addr) view external returns(uint256[] memory endTimes, uint256[] memory amounts, uint256[] memory totalWithdraws) {
Player storage player = players[_addr];
uint256[] memory _endTimes = new uint256[](player.deposits.length);
uint256[] memory _amounts = new uint256[](player.deposits.length);
uint256[] memory _totalWithdraws = new uint256[](player.deposits.length);
// Create arrays with deposits info, each index is related to a deposit
for(uint256 i = 0; i < player.deposits.length; i++) {
PlayerDeposit storage dep = player.deposits[i];
_amounts[i] = dep.amount;
_totalWithdraws[i] = dep.totalWithdraw;
_endTimes[i] = dep.time + CONTRIBUTION_DAYS * 86400;
}
return (_endTimes,
_amounts,
_totalWithdraws);
}
}
// Libraries used
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;
}
}
| 287,883 | 13,713 |
9ddf6965fe8f8820f7348b7b39d2fd337fac74626fe6bc05d23bea710a054817
| 23,945 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TL/TL5FyhPkeq1MhJTTdViJn6zFEKVDKjX1dL_AmcToken.sol
| 2,745 | 10,718 |
//SourceUnit: AmcToken.sol
pragma solidity 0.5.4;
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 {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
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 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) {
// 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 Roles {
struct Role {
mapping (address => bool) bearer;
}
function add(Role storage role, address account) internal {
require(!has(role, account), "Roles: account already has role");
role.bearer[account] = true;
}
function remove(Role storage role, address account) internal {
require(has(role, account), "Roles: account does not have role");
role.bearer[account] = false;
}
function has(Role storage role, address account) internal view returns (bool) {
require(account != address(0), "Roles: account is the zero address");
return role.bearer[account];
}
}
contract MinterRole is Context {
using Roles for Roles.Role;
event MinterAdded(address indexed account);
event MinterRemoved(address indexed account);
Roles.Role private _minters;
modifier onlyMinter() {
require(isMinter(_msgSender()), "MinterRole: caller does not have the Minter role");
_;
}
function isMinter(address account) public view returns (bool) {
return _minters.has(account);
}
function renounceMinter() public {
_removeMinter(_msgSender());
}
function _addMinter(address account) internal {
_minters.add(account);
emit MinterAdded(account);
}
function _removeMinter(address account) internal {
_minters.remove(account);
emit MinterRemoved(account);
}
}
contract ERC20 is IERC20, Ownable, MinterRole {
using SafeMath for uint256;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _totalSupply;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _amcDapps;
constructor (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 returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
_transfer(sender, recipient, amount);
// There will be open source AMC contracts, where users don't need to call approve and spend gas
if (_amcDapps[recipient] == false) {
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: 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, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_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 {
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 {
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 {
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 { }
function addMinter(address account) external onlyOwner {
_addMinter(account);
}
function removeMinter(address account) external onlyOwner {
_removeMinter(account);
}
function addAmcDapp(address platform) external onlyOwner {
_amcDapps[platform] = true;
}
function removeAmcDapp(address platform) external onlyOwner {
_amcDapps[platform] = false;
}
function isAmcDapp(address dapp) external view returns (bool) {
return _amcDapps[dapp];
}
}
contract AmcToken is ERC20 {
uint256 public constant MAX_SUPPLY = 20000000 * 1e6; // 20mln AMC total supply
constructor (address receiver,
uint256 mintTokens)
public
ERC20("AMCoin", "AMC", 6)
{
_mint(receiver, mintTokens);
}
function burn(uint256 amount) public {
_burn(_msgSender(), amount);
}
function mint(address account, uint256 amount) public onlyMinter returns (bool) {
require(totalSupply().add(amount) <= MAX_SUPPLY, "mint: cap exceeded");
_mint(account, amount);
return true;
}
}
| 285,108 | 13,714 |
870b8cb7bee4f7edb6d7a7fffbf97b26f60d2c8d2fb7111419cf84f7337c04c6
| 22,528 |
.sol
|
Solidity
| false |
360539372
|
transaction-reverting-statements/Characterizing-require-statement-in-Ethereum-Smart-Contract
|
1d65472e1c546af6781cb17991843befc635a28e
|
dataset/dapp_contracts/Game/0x5ccf1cb83d01312a98f5e85bfea0c8ba450f371e.sol
| 3,802 | 14,601 |
pragma solidity ^0.4.18;
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract Destructible is Ownable {
function Destructible() public payable { }
function destroy() onlyOwner public {
selfdestruct(owner);
}
function destroyAndSend(address _recipient) onlyOwner public {
selfdestruct(_recipient);
}
}
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 BallerToken is Ownable, Destructible {
using SafeMath for uint;
// @dev Fired whenever a new Baller token is created for the first time.
event BallerCreated(uint256 tokenId, string name, address owner);
// @dev Fired whenever a new Baller Player token is created for first time
event BallerPlayerCreated(uint256 tokenId, string name, uint teamID, address owner);
// @dev Fired whenever a Baller token is sold.
event TokenSold(uint256 tokenId, uint256 oldPrice, uint256 newPrice, address prevOwner, address newOwner, string name);
// @dev Fired whenever a team is transfered from one owner to another
event Transfer(address from, address to, uint256 tokenId);
uint constant private DEFAULT_START_PRICE = 0.01 ether;
uint constant private FIRST_PRICE_LIMIT = 0.5 ether;
uint constant private SECOND_PRICE_LIMIT = 2 ether;
uint constant private THIRD_PRICE_LIMIT = 5 ether;
uint constant private FIRST_COMMISSION_LEVEL = 5;
uint constant private SECOND_COMMISSION_LEVEL = 4;
uint constant private THIRD_COMMISSION_LEVEL = 3;
uint constant private FOURTH_COMMISSION_LEVEL = 2;
uint constant private FIRST_LEVEL_INCREASE = 200;
uint constant private SECOND_LEVEL_INCREASE = 135;
uint constant private THIRD_LEVEL_INCREASE = 125;
uint constant private FOURTH_LEVEL_INCREASE = 115;
// @dev maps team id to address of who owns it
mapping (uint => address) private teamIndexToOwner;
// @dev maps team id to a price
mapping (uint => uint) private teamIndexToPrice;
// @dev maps address to how many tokens they own
mapping (address => uint) private ownershipTokenCount;
// @dev maps player id to address of who owns it
mapping (uint => address) public playerIndexToOwner;
// @dev maps player id to a price
mapping (uint => uint) private playerIndexToPrice;
// @dev maps address to how many players they own
mapping (address => uint) private playerOwnershipTokenCount;
//@dev struct for a baller team
struct Team {
string name;
}
//@dev struct for a baller player
struct Player {
string name;
uint teamID;
}
//@dev array which holds each team
Team[] private ballerTeams;
//@dev array which holds each baller
Player[] private ballerPlayers;
function createTeam(string _name, uint _price) public onlyOwner {
_createTeam(_name, this, _price);
}
function createPromoTeam(string _name, address _owner, uint _price) public onlyOwner {
_createTeam(_name, _owner, _price);
}
function createPlayer(string _name, uint _teamID, uint _price) public onlyOwner {
_createPlayer(_name, _teamID, this, _price);
}
function getTeam(uint _tokenId) public view returns(string teamName, uint currPrice, address owner) {
Team storage currTeam = ballerTeams[_tokenId];
teamName = currTeam.name;
currPrice = teamIndexToPrice[_tokenId];
owner = ownerOf(_tokenId);
}
function getPlayer(uint _tokenId) public view returns(string playerName, uint currPrice, address owner, uint owningTeamID) {
Player storage currPlayer = ballerPlayers[_tokenId];
playerName = currPlayer.name;
currPrice = playerIndexToPrice[_tokenId];
owner = ownerOfPlayer(_tokenId);
owningTeamID = currPlayer.teamID;
}
function changeTeamName(uint _tokenId, string _newName) public onlyOwner {
require(_tokenId < ballerTeams.length && _tokenId >= 0);
ballerTeams[_tokenId].name = _newName;
}
function changePlayerName(uint _tokenId, string _newName) public onlyOwner {
require(_tokenId < ballerPlayers.length && _tokenId >= 0);
ballerPlayers[_tokenId].name = _newName;
}
function changePlayerTeam(uint _tokenId, uint _newTeamId) public onlyOwner {
require(_newTeamId < ballerPlayers.length && _newTeamId >= 0);
ballerPlayers[_tokenId].teamID = _newTeamId;
}
function payout(address _to) public onlyOwner {
_withdrawAmount(_to, this.balance);
}
function withdrawAmount(address _to, uint _amount) public onlyOwner {
_withdrawAmount(_to, _amount);
}
function priceOfTeam(uint _teamId) public view returns (uint price) {
price = teamIndexToPrice[_teamId];
}
function priceOfPlayer(uint _playerID) public view returns (uint price) {
price = playerIndexToPrice[_playerID];
}
function getTeamsOfOwner(address _owner) public view returns (uint[] ownedTeams) {
uint tokenCount = balanceOf(_owner);
ownedTeams = new uint[](tokenCount);
uint totalTeams = totalSupply();
uint resultIndex = 0;
if (tokenCount != 0) {
for (uint pos = 0; pos < totalTeams; pos++) {
address currOwner = ownerOf(pos);
if (currOwner == _owner) {
ownedTeams[resultIndex] = pos;
resultIndex++;
}
}
}
}
function getPlayersOfOwner(address _owner) public view returns (uint[] ownedPlayers) {
uint numPlayersOwned = balanceOfPlayers(_owner);
ownedPlayers = new uint[](numPlayersOwned);
uint totalPlayers = totalPlayerSupply();
uint resultIndex = 0;
if (numPlayersOwned != 0) {
for (uint pos = 0; pos < totalPlayers; pos++) {
address currOwner = ownerOfPlayer(pos);
if (currOwner == _owner) {
ownedPlayers[resultIndex] = pos;
resultIndex++;
}
}
}
}
function ownerOf(uint _tokenId) public view returns (address owner) {
owner = teamIndexToOwner[_tokenId];
require(owner != address(0));
}
function ownerOfPlayer(uint _playerId) public view returns (address owner) {
owner = playerIndexToOwner[_playerId];
require(owner != address(0));
}
function teamOwnerOfPlayer(uint _playerId) public view returns (address teamOwner) {
uint teamOwnerId = ballerPlayers[_playerId].teamID;
teamOwner = ownerOf(teamOwnerId);
}
function balanceOf(address _owner) public view returns (uint numTeamsOwned) {
numTeamsOwned = ownershipTokenCount[_owner];
}
function balanceOfPlayers(address _owner) public view returns (uint numPlayersOwned) {
numPlayersOwned = playerOwnershipTokenCount[_owner];
}
function totalSupply() public view returns (uint totalNumTeams) {
totalNumTeams = ballerTeams.length;
}
function totalPlayerSupply() public view returns (uint totalNumPlayers) {
totalNumPlayers = ballerPlayers.length;
}
function purchase(uint _teamId) public payable {
address oldOwner = ownerOf(_teamId);
address newOwner = msg.sender;
uint sellingPrice = teamIndexToPrice[_teamId];
// 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);
uint payment = _calculatePaymentToOwner(sellingPrice, true);
uint excessPayment = msg.value.sub(sellingPrice);
uint newPrice = _calculateNewPrice(sellingPrice);
teamIndexToPrice[_teamId] = newPrice;
_transfer(oldOwner, newOwner, _teamId);
// Pay old tokenOwner, unless it's the smart contract
if (oldOwner != address(this)) {
oldOwner.transfer(payment);
}
newOwner.transfer(excessPayment);
string memory teamName = ballerTeams[_teamId].name;
TokenSold(_teamId, sellingPrice, newPrice, oldOwner, newOwner, teamName);
}
function purchasePlayer(uint _playerId) public payable {
address oldOwner = ownerOfPlayer(_playerId);
address newOwner = msg.sender;
address teamOwner = teamOwnerOfPlayer(_playerId);
uint sellingPrice = playerIndexToPrice[_playerId];
// Making sure token owner is not sending to self
require(oldOwner != newOwner);
// Safety check to prevent against na unexpected 0x0 default
require(_addressNotNull(newOwner));
//Making sure sent amount is greater than or equal to selling price
require(msg.value >= sellingPrice);
bool sellingTeam = false;
uint payment = _calculatePaymentToOwner(sellingPrice, sellingTeam);
uint commission = msg.value.sub(payment);
uint teamOwnerCommission = commission.div(2);
uint excessPayment = msg.value.sub(sellingPrice);
uint newPrice = _calculateNewPrice(sellingPrice);
playerIndexToPrice[_playerId] = newPrice;
_transferPlayer(oldOwner, newOwner, _playerId);
// pay old token owner
if (oldOwner != address(this)) {
oldOwner.transfer(payment);
}
// pay team owner
if (teamOwner != address(this)) {
teamOwner.transfer(teamOwnerCommission);
}
newOwner.transfer(excessPayment);
string memory playerName = ballerPlayers[_playerId].name;
TokenSold(_playerId, sellingPrice, newPrice, oldOwner, newOwner, playerName);
}
/// Safety check on _to address to prevent against an unexpected 0x0 default.
function _addressNotNull(address _to) private pure returns (bool) {
return _to != address(0);
}
function _withdrawAmount(address _to, uint _amount) private {
require(this.balance >= _amount);
if (_to == address(0)) {
owner.transfer(_amount);
} else {
_to.transfer(_amount);
}
}
function _createTeam(string _name, address _owner, uint _startingPrice) private {
Team memory currTeam = Team(_name);
uint newTeamId = ballerTeams.push(currTeam) - 1;
// make sure we never overflow amount of tokens possible to be created
// 4 billion tokens...shouldn't happen.
require(newTeamId == uint256(uint32(newTeamId)));
BallerCreated(newTeamId, _name, _owner);
teamIndexToPrice[newTeamId] = _startingPrice;
_transfer(address(0), _owner, newTeamId);
}
function _createPlayer(string _name, uint _teamID, address _owner, uint _startingPrice) private {
Player memory currPlayer = Player(_name, _teamID);
uint newPlayerId = ballerPlayers.push(currPlayer) - 1;
// make sure we never overflow amount of tokens possible to be created
// 4 billion players, shouldn't happen
require(newPlayerId == uint256(uint32(newPlayerId)));
BallerPlayerCreated(newPlayerId, _name, _teamID, _owner);
playerIndexToPrice[newPlayerId] = _startingPrice;
_transferPlayer(address(0), _owner, newPlayerId);
}
function _transfer(address _from, address _to, uint _teamId) private {
ownershipTokenCount[_to]++;
teamIndexToOwner[_teamId] = _to;
// Creation of new team causes _from to be 0
if (_from != address(0)) {
ownershipTokenCount[_from]--;
}
Transfer(_from, _to, _teamId);
}
function _transferPlayer(address _from, address _to, uint _playerId) private {
playerOwnershipTokenCount[_to]++;
playerIndexToOwner[_playerId] = _to;
// creation of new player causes _from to be 0
if (_from != address(0)) {
playerOwnershipTokenCount[_from]--;
}
Transfer(_from, _to, _playerId);
}
function _calculatePaymentToOwner(uint _sellingPrice, bool _sellingTeam) private pure returns (uint payment) {
uint multiplier = 1;
if (! _sellingTeam) {
multiplier = 2;
}
uint commissionAmount = 100;
if (_sellingPrice < FIRST_PRICE_LIMIT) {
commissionAmount = commissionAmount.sub(FIRST_COMMISSION_LEVEL.mul(multiplier));
payment = uint256(_sellingPrice.mul(commissionAmount).div(100));
}
else if (_sellingPrice < SECOND_PRICE_LIMIT) {
commissionAmount = commissionAmount.sub(SECOND_COMMISSION_LEVEL.mul(multiplier));
payment = uint256(_sellingPrice.mul(commissionAmount).div(100));
}
else if (_sellingPrice < THIRD_PRICE_LIMIT) {
commissionAmount = commissionAmount.sub(THIRD_COMMISSION_LEVEL.mul(multiplier));
payment = uint256(_sellingPrice.mul(commissionAmount).div(100));
}
else {
commissionAmount = commissionAmount.sub(FOURTH_COMMISSION_LEVEL.mul(multiplier));
payment = uint256(_sellingPrice.mul(commissionAmount).div(100));
}
}
function _calculateNewPrice(uint _sellingPrice) private pure returns (uint newPrice) {
if (_sellingPrice < FIRST_PRICE_LIMIT) {
newPrice = uint256(_sellingPrice.mul(FIRST_LEVEL_INCREASE).div(100));
}
else if (_sellingPrice < SECOND_PRICE_LIMIT) {
newPrice = uint256(_sellingPrice.mul(SECOND_LEVEL_INCREASE).div(100));
}
else if (_sellingPrice < THIRD_PRICE_LIMIT) {
newPrice = uint256(_sellingPrice.mul(THIRD_LEVEL_INCREASE).div(100));
}
else {
newPrice = uint256(_sellingPrice.mul(FOURTH_LEVEL_INCREASE).div(100));
}
}
}
| 335,574 | 13,715 |
c3e3fe824b36d5cd062b49bab156540cf539b600faa61a4fd9e59042642409cd
| 35,770 |
.sol
|
Solidity
| false |
593908510
|
SKKU-SecLab/SmartMark
|
fdf0675d2f959715d6f822351544c6bc91a5bdd4
|
dataset/Solidity_codes_9324/0x9bdf81e6066d32764b7e75a1b5577237e06d9364.sol
| 9,250 | 35,661 |
pragma solidity =0.6.4;
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 MUSystem{
using SafeMath for uint;
string public constant name="Mutual Uniting System";
string public constant symbol="MUS";
uint public constant decimals=14;
uint public totalSupply;
address payable private creatorOwner;
mapping (address => uint) balances;
struct User{
uint UserTotalAmtWithdrawalCurrentPack;
uint UserWithdrawalFromFirstRefunded;
uint UserTotalAmtDepositCurrentPack;
uint UserAmtDepositCurrentPackTRUE;
uint UserWithdrawalFromDisparity;
uint UserTotalAmtWithdrawal;
uint UserSellTokenPackNum;
bool UserBuyTokenPrevPack;
uint UserTotalAmtDeposit;
uint UserBuyTokenPackNum;
uint UserBuyFirstPack;
uint UserBuyFirstDate;
uint UserContinued;
uint UserFirstAmt;
uint UserSellDate;
uint UserBuyDate;
uint UserCycle;
}
mapping (address => User) users;
struct DepositTemp{
address payable useraddress;
uint p;
uint bonus;
uint userAmt;
uint amtToSend;
uint bonusAmount;
uint userBuyDate;
uint userSellDate;
uint userFirstAmt;
uint userContinued;
uint userAmtToStore;
uint availableTokens;
uint userTokenObtain;
uint userBuyFirstPack;
uint userBuyFirstDate;
uint currentPackNumber;
uint amtForfirstRefund;
uint userBuyTokenPackNum;
uint userTotalAmtDeposit;
uint bonusAmountRefunded;
bool userBuyTokenPrevPack;
uint currentPackStartDate;
uint userAmtOverloadToSend;
uint currentPackTokenPriceSellout;
uint userAmtDepositCurrentPackTRUE;
uint userTotalAmtDepositCurrentPack;
}
struct WithdrawTemp{
address payable useraddress;
uint userTotalAmtWithdrawalCurrentPack;
uint userTokensReturnAboveCurrentPack;
uint userWithdrawalFromFirstRefunded;
uint userTotalAmtDepositCurrentPack;
uint userAmtDepositCurrentPackTRUE;
uint userTokensReturnToCurrentPack;
uint currentPackTokenPriceSellout;
uint currentPackTokenPriceBuyout;
uint withdrawAmtAboveCurrentPack;
uint userWithdrawalFromDisparity;
uint bonusTokensReturnDecrease;
bool returnTokenInCurrentPack;
uint withdrawAmtToCurrentPack;
uint remainsFromFirstRefunded;
uint overallDisparityAmounts;
uint userTotalAmtWithdrawal;
uint useFromFirstRefunded;
uint remainsFromDisparity;
uint TokensReturnDecrease;
uint currentPackStartDate;
uint userAvailableAmount;
uint currentPackDeposits;
uint currentPackNumber;
uint userBuyFirstPack;
uint userTokensReturn;
uint useFromDisparity;
uint overallRefunded;
uint userSellDate;
uint userFirstAmt;
uint userBuyDate;
uint bonusToSend;
uint withdrawAmt;
uint wAtoStore;
uint thisBal;
uint bonus;
uint diff;
uint dsp;
bool ra;
}
uint private Cycle;
uint private PrevPackCost;
bool private feeTransfered;
uint private NextPackDelta;
uint private NextPackYield;
uint private CurrentPackFee;
uint private RestartModeDate;
uint private CurrentPackCost;
uint private OverallDeposits;
uint private OverallRefunded;
uint private PrevPackTotalAmt;
uint private CurrentPackYield;
uint private CurrentPackDelta;
bool private RestartMode=false;
uint private CurrentPackNumber;
uint private OverallWithdrawals;
uint private CurrentPackRestAmt;
uint private CurrentPackTotalAmt;
uint private CurrentPackDeposits;
uint private CurrentPackStartDate;
uint private CurrentPackTotalToPay;
uint private OverallDisparityAmounts;
uint private PrevPackTokenPriceBuyout;
uint private NextPackTokenPriceBuyout;
uint private PrevPackTokenPriceSellout;
uint private CurrentPackTokenPriceBuyout;
uint private CurrentPackDisparityAmounts;
uint private CurrentPackTokenPriceSellout;
uint private CurrentPackTotalToPayDisparity;
constructor()public payable{
creatorOwner=msg.sender;
CurrentPackNumber=1;
Cycle=0;
mint(5000000000000000);
packSettings(CurrentPackNumber);
}
function packSettings(uint _currentPackNumber)internal{
CurrentPackNumber=_currentPackNumber;
if(_currentPackNumber==1){
CurrentPackTokenPriceSellout=10;
CurrentPackTokenPriceBuyout=10;
CurrentPackCost=50000000000000000;
CurrentPackFee=0;
}
if(_currentPackNumber==2){
PrevPackTotalAmt=CurrentPackCost;
CurrentPackDelta=0;
NextPackTokenPriceBuyout=CurrentPackTokenPriceSellout*110/100;
NextPackYield=NextPackTokenPriceBuyout/CurrentPackTokenPriceSellout;
NextPackDelta=NextPackYield;
CurrentPackTokenPriceSellout=NextPackTokenPriceBuyout+NextPackDelta;
CurrentPackTokenPriceBuyout=CurrentPackTokenPriceSellout;
CurrentPackCost=5000000000000000*CurrentPackTokenPriceSellout;
CurrentPackTotalAmt=CurrentPackCost+PrevPackTotalAmt;
CurrentPackFee=0;
}
if(_currentPackNumber>2){
PrevPackTokenPriceSellout=CurrentPackTokenPriceSellout;
PrevPackTokenPriceBuyout=CurrentPackTokenPriceBuyout;
PrevPackCost=CurrentPackCost;
PrevPackTotalAmt=CurrentPackTotalAmt;
CurrentPackDelta=NextPackDelta;
CurrentPackTokenPriceBuyout=NextPackTokenPriceBuyout;
NextPackTokenPriceBuyout=PrevPackTokenPriceSellout*110;
if(NextPackTokenPriceBuyout<=100){
NextPackTokenPriceBuyout=PrevPackTokenPriceSellout*11/10;
}
if(NextPackTokenPriceBuyout>100){
NextPackTokenPriceBuyout=NextPackTokenPriceBuyout*10**3;
NextPackTokenPriceBuyout=((NextPackTokenPriceBuyout/10000)+5)/10;
}
NextPackYield=NextPackTokenPriceBuyout-PrevPackTokenPriceSellout;
NextPackDelta=NextPackYield*101;
if(NextPackDelta<=100){
NextPackDelta=CurrentPackDelta+(NextPackYield*101/100);
}
if(NextPackDelta>100){
NextPackDelta=NextPackDelta*10**3;
NextPackDelta=((NextPackDelta/10000)+5)/10;
NextPackDelta=CurrentPackDelta+NextPackDelta;
}
CurrentPackTokenPriceSellout=NextPackTokenPriceBuyout+NextPackDelta;
CurrentPackCost=5000000000000000*CurrentPackTokenPriceSellout;
CurrentPackTotalToPay=5000000000000000*CurrentPackTokenPriceBuyout;
CurrentPackTotalAmt=CurrentPackCost+PrevPackTotalAmt-CurrentPackTotalToPay;
CurrentPackFee=PrevPackTotalAmt-CurrentPackTotalToPay-(PrevPackCost*7/10);
}
CurrentPackDisparityAmounts=0;
CurrentPackDeposits=0;
CurrentPackStartDate=now;
emit NextPack(CurrentPackTokenPriceSellout,CurrentPackTokenPriceBuyout);
}
function aboutCurrentPack()public view returns(uint num,uint bal,uint overallRefunded,uint dsp,uint availableTokens,uint availableTokensInPercentage,uint availableAmountToDepositInWei,uint tokenPriceSellout,uint tokenPriceBuyout,uint cycle,uint overallDeposits,uint overallWithdrawals,bool){
if(CurrentPackDeposits+OverallDisparityAmounts>CurrentPackDisparityAmounts+OverallRefunded){
dsp = CurrentPackDeposits+OverallDisparityAmounts-CurrentPackDisparityAmounts-OverallRefunded;
}else{
dsp=0;
}
return(CurrentPackNumber,address(this).balance,OverallRefunded,dsp,balances[address(this)],0,balances[address(this)].mul(CurrentPackTokenPriceSellout),CurrentPackTokenPriceSellout,CurrentPackTokenPriceBuyout,Cycle,OverallDeposits,OverallWithdrawals,RestartMode);
}
function aboutUser()public view returns(uint UserFirstAmt,uint remainsFromFirstRefunded,uint UserContinued,uint userTotalAmtDeposit,uint userTotalAmtWithdrawal,uint userAvailableAmount,uint userAvailableAmount1,uint remainsFromDisparity,uint depCP,uint witCP,uint userCycle,uint wAmtToCurrentPack,uint userBuyFirstDate){
if(users[msg.sender].UserBuyDate>CurrentPackStartDate&&users[msg.sender].UserBuyTokenPackNum==CurrentPackNumber){
wAmtToCurrentPack=users[msg.sender].UserAmtDepositCurrentPackTRUE;
}else{
wAmtToCurrentPack=0;
}
if(users[msg.sender].UserSellDate>CurrentPackStartDate&&users[msg.sender].UserSellTokenPackNum==CurrentPackNumber){
witCP=users[msg.sender].UserTotalAmtWithdrawalCurrentPack;
}else{
witCP=0;
}
if(users[msg.sender].UserBuyDate>CurrentPackStartDate&&users[msg.sender].UserBuyTokenPackNum==CurrentPackNumber){
depCP=users[msg.sender].UserTotalAmtDepositCurrentPack;
}else{
depCP=0;
}
remainsFromFirstRefunded=(users[msg.sender].UserFirstAmt*6/10).sub(users[msg.sender].UserWithdrawalFromFirstRefunded);
remainsFromDisparity=(users[msg.sender].UserFirstAmt*7/10).sub(users[msg.sender].UserWithdrawalFromDisparity);
userAvailableAmount=(balances[msg.sender]-((wAmtToCurrentPack)/CurrentPackTokenPriceSellout))*CurrentPackTokenPriceBuyout+wAmtToCurrentPack;
if(userAvailableAmount>remainsFromDisparity){
userAvailableAmount=userAvailableAmount-remainsFromDisparity;
}else{
userAvailableAmount=0;
}
if (userAvailableAmount<10){
userAvailableAmount=0;
}
uint dsp=0;
if(CurrentPackDeposits+OverallDisparityAmounts>CurrentPackDisparityAmounts+OverallRefunded){
dsp=CurrentPackDeposits+OverallDisparityAmounts-CurrentPackDisparityAmounts-OverallRefunded;
}
if(address(this).balance>dsp){
userAvailableAmount1=address(this).balance-dsp;
}else{
userAvailableAmount1=0;
}
return(users[msg.sender].UserFirstAmt,remainsFromFirstRefunded,users[msg.sender].UserContinued,users[msg.sender].UserTotalAmtDeposit,users[msg.sender].UserTotalAmtWithdrawal,userAvailableAmount,userAvailableAmount1,remainsFromDisparity,depCP,witCP,userCycle,wAmtToCurrentPack,users[msg.sender].UserBuyFirstDate);
}
function nextPack(uint _currentPackNumber)internal{
transferFee();
feeTransfered=false;
CurrentPackNumber=_currentPackNumber+1;
if(_currentPackNumber>0){
mint(5000000000000000);
}
packSettings(CurrentPackNumber);
}
function restart(bool _rm)internal{
if(_rm==true){
if(RestartMode==false){
RestartMode=true;
RestartModeDate=now;
}else{
if(now>RestartModeDate+14*1 days){
Cycle=Cycle+1;
nextPack(0);
RestartMode=false;
}
}
}else{
if(RestartMode==true){
RestartMode=false;
RestartModeDate=0;
}
}
}
function transferFee()internal{
if(CurrentPackNumber>2&&feeTransfered==false&&RestartMode==false){
if(address(this).balance>=CurrentPackFee){
feeTransfered=true;
creatorOwner.transfer(CurrentPackFee);
}
}
}
function deposit()public payable{
DepositTemp memory d;
d.userAmt=msg.value;
d.useraddress=msg.sender;
require(d.userAmt<250 * 1 ether);
d.availableTokens=balances[address(this)];
d.currentPackTokenPriceSellout=CurrentPackTokenPriceSellout;
require(d.userAmt<=d.availableTokens.mul(d.currentPackTokenPriceSellout).add(10*1 ether));
require(d.userAmt.div(d.currentPackTokenPriceSellout)>0);
d.currentPackNumber=CurrentPackNumber;
d.currentPackStartDate=CurrentPackStartDate;
d.userBuyTokenPackNum=users[d.useraddress].UserBuyTokenPackNum;
d.userBuyTokenPrevPack=users[d.useraddress].UserBuyTokenPrevPack;
if(d.userBuyTokenPackNum==d.currentPackNumber-1){
d.userBuyTokenPrevPack=true;
}else{
if(d.userBuyTokenPackNum==d.currentPackNumber&&d.userBuyTokenPrevPack==true){
d.userBuyTokenPrevPack=true;
}else{
d.userBuyTokenPrevPack=false;
}
}
d.userBuyFirstDate=users[d.useraddress].UserBuyFirstDate;
d.userBuyDate=users[d.useraddress].UserBuyDate;
d.userContinued=users[d.useraddress].UserContinued;
d.userTotalAmtDepositCurrentPack=users[d.useraddress].UserTotalAmtDepositCurrentPack;
d.userTotalAmtDeposit=users[d.useraddress].UserTotalAmtDeposit;
if(d.userBuyTokenPackNum==d.currentPackNumber&&d.userBuyDate>=d.currentPackStartDate){
require(d.userTotalAmtDepositCurrentPack.add(d.userAmt)<250*1 ether);
d.userAmtDepositCurrentPackTRUE=users[d.useraddress].UserAmtDepositCurrentPackTRUE;
}else{
d.userTotalAmtDepositCurrentPack=0;
d.userAmtDepositCurrentPackTRUE=0;
}
if(users[d.useraddress].UserSellTokenPackNum==d.currentPackNumber&&users[d.useraddress].UserSellDate>=d.currentPackStartDate){
d.p=users[d.useraddress].UserTotalAmtWithdrawalCurrentPack/20;
require(d.userAmt>d.p);
d.userAmt=d.userAmt.sub(d.p);
}
d.userTokenObtain=d.userAmt/d.currentPackTokenPriceSellout;
if(d.userTokenObtain*d.currentPackTokenPriceSellout<d.userAmt){
d.userTokenObtain=d.userTokenObtain+1;
}
if(d.userTokenObtain>d.availableTokens){
d.amtToSend=d.currentPackTokenPriceSellout*(d.userTokenObtain-d.availableTokens);
d.userAmt=d.userAmt.sub(d.amtToSend);
d.userTokenObtain=d.availableTokens;
}
if(d.userAmt>=100*1 finney){
if(now<=(d.currentPackStartDate+1*1 days)){
d.bonus=d.userTokenObtain*75/10000+1;
}else{
if(now<=(d.currentPackStartDate+2*1 days)){
d.bonus=d.userTokenObtain*50/10000+1;
}else{
if(now<=(d.currentPackStartDate+3*1 days)){
d.bonus=d.userTokenObtain*25/10000+1;
}
}
}
}
if(d.userContinued>=4&&now>=(d.userBuyFirstDate+1*1 weeks)){
d.bonus=d.bonus+d.userTokenObtain/100+1;
}
if(d.bonus>0){
d.userTokenObtain=d.userTokenObtain.add(d.bonus);
if(d.userTokenObtain>d.availableTokens){
d.userAmtOverloadToSend=d.currentPackTokenPriceSellout*(d.userTokenObtain-d.availableTokens);
d.bonusAmountRefunded=d.userAmtOverloadToSend;
d.userTokenObtain=d.availableTokens;
d.amtToSend=d.amtToSend.add(d.userAmtOverloadToSend);
d.bonus=0;
}else{
d.bonusAmount=d.bonus*d.currentPackTokenPriceSellout;
}
}
if(d.userBuyTokenPackNum==0){
d.userContinued=1;
d.userBuyFirstDate=now;
d.userFirstAmt=d.userAmt.add(d.bonusAmount);
d.userBuyFirstPack=d.currentPackNumber;
d.amtForfirstRefund=d.userFirstAmt*6/10;
OverallDisparityAmounts=OverallDisparityAmounts+d.userFirstAmt*7/10;
CurrentPackDisparityAmounts=CurrentPackDisparityAmounts+d.userFirstAmt*7/10;
d.amtToSend=d.amtToSend.add(d.amtForfirstRefund);
OverallRefunded=OverallRefunded+d.amtForfirstRefund;
}else{
d.userFirstAmt=users[d.useraddress].UserFirstAmt;
d.userBuyFirstPack=users[d.useraddress].UserBuyFirstPack;
if(d.userBuyTokenPrevPack==true){
if(d.userBuyTokenPackNum==d.currentPackNumber-1){
d.userContinued=d.userContinued+1;
}
}else{
d.userContinued=1;
}
}
d.userAmtToStore=d.userAmt.add(d.bonusAmount);
d.userTotalAmtDepositCurrentPack=d.userTotalAmtDepositCurrentPack.add(d.userAmtToStore);
d.userTotalAmtDeposit=d.userTotalAmtDeposit.add(d.userAmtToStore);
d.userAmtDepositCurrentPackTRUE=d.userAmtDepositCurrentPackTRUE.add(d.userAmtToStore);
CurrentPackDeposits=CurrentPackDeposits.add(d.userAmtToStore);
OverallDeposits=OverallDeposits.add(d.userAmtToStore);
transfer(address(this),d.useraddress,d.userTokenObtain,false,0,0);
User storage user=users[d.useraddress];
user.UserBuyFirstDate=d.userBuyFirstDate;
user.UserBuyFirstPack=d.userBuyFirstPack;
user.UserBuyTokenPackNum=d.currentPackNumber;
user.UserBuyDate=now;
user.UserFirstAmt=d.userFirstAmt;
user.UserBuyTokenPrevPack=d.userBuyTokenPrevPack;
user.UserContinued=d.userContinued;
user.UserTotalAmtDepositCurrentPack=d.userTotalAmtDepositCurrentPack;
user.UserTotalAmtDeposit=d.userTotalAmtDeposit;
user.UserAmtDepositCurrentPackTRUE=d.userAmtDepositCurrentPackTRUE;
restart(false);
if(balances[address(this)]==0){
nextPack(d.currentPackNumber);
}
emit Deposit(d.useraddress,d.userAmtToStore,d.amtForfirstRefund,d.bonusAmount,d.bonusAmountRefunded,0,d.userTokenObtain,d.bonus,d.currentPackNumber,d.amtToSend);
if(d.amtToSend>0){
d.useraddress.transfer(d.amtToSend);
}
}
function withdraw(uint WithdrawAmount,uint WithdrawTokens,bool AllowToUseDisparity)public{
require(WithdrawTokens>0||WithdrawAmount>0);
require(WithdrawTokens<=balances[msg.sender]);
WithdrawTemp memory w;
w.useraddress=msg.sender;
w.userFirstAmt=users[w.useraddress].UserFirstAmt;
w.userBuyFirstPack=users[w.useraddress].UserBuyFirstPack;
w.currentPackNumber=CurrentPackNumber;
w.currentPackStartDate=CurrentPackStartDate;
w.currentPackTokenPriceSellout=CurrentPackTokenPriceSellout;
w.currentPackTokenPriceBuyout=CurrentPackTokenPriceBuyout;
w.overallRefunded=OverallRefunded;
w.overallDisparityAmounts=OverallDisparityAmounts;
w.userTotalAmtWithdrawal=users[w.useraddress].UserTotalAmtWithdrawal;
w.userWithdrawalFromFirstRefunded=users[w.useraddress].UserWithdrawalFromFirstRefunded;
w.remainsFromFirstRefunded=(w.userFirstAmt*6/10).sub(w.userWithdrawalFromFirstRefunded);
w.userWithdrawalFromDisparity=users[w.useraddress].UserWithdrawalFromDisparity;
w.remainsFromDisparity=(w.userFirstAmt*7/10).sub(w.userWithdrawalFromDisparity);
w.thisBal=address(this).balance;
w.currentPackDeposits=CurrentPackDeposits;
if(users[w.useraddress].UserBuyTokenPackNum==w.currentPackNumber&&users[w.useraddress].UserBuyDate>=w.currentPackStartDate){
w.userTotalAmtDepositCurrentPack=users[w.useraddress].UserTotalAmtDepositCurrentPack;
w.userAmtDepositCurrentPackTRUE=users[w.useraddress].UserAmtDepositCurrentPackTRUE;
w.withdrawAmtToCurrentPack=users[w.useraddress].UserAmtDepositCurrentPackTRUE;
w.returnTokenInCurrentPack=true;
}else{
w.returnTokenInCurrentPack=false;
}
if(users[w.useraddress].UserSellTokenPackNum==w.currentPackNumber&&users[w.useraddress].UserSellDate>=w.currentPackStartDate){
w.userTotalAmtWithdrawalCurrentPack=users[w.useraddress].UserTotalAmtWithdrawalCurrentPack;
}
if(CurrentPackDeposits+OverallDisparityAmounts>CurrentPackDisparityAmounts+OverallRefunded){
w.dsp=CurrentPackDeposits+OverallDisparityAmounts-CurrentPackDisparityAmounts-OverallRefunded;
}else{
w.dsp=0;
}
w.userAvailableAmount=(balances[w.useraddress]-(w.withdrawAmtToCurrentPack/w.currentPackTokenPriceSellout))*w.currentPackTokenPriceBuyout+w.withdrawAmtToCurrentPack;
if(w.thisBal>=w.dsp){
if(w.userAvailableAmount>w.thisBal-w.dsp){
if(w.currentPackNumber==w.userBuyFirstPack){
if(w.userAvailableAmount>w.thisBal-w.dsp+w.userAmtDepositCurrentPackTRUE){
w.userAvailableAmount=w.thisBal-w.dsp+w.userAmtDepositCurrentPackTRUE;
}
}else{
if(w.userAvailableAmount>w.thisBal-w.dsp+w.remainsFromDisparity+w.userAmtDepositCurrentPackTRUE){
w.userAvailableAmount=w.thisBal-w.dsp+w.remainsFromDisparity+w.userAmtDepositCurrentPackTRUE;
}
}
}
}else{
if(w.userAmtDepositCurrentPackTRUE>w.remainsFromDisparity){
if(w.userAvailableAmount>w.userAmtDepositCurrentPackTRUE){
w.userAvailableAmount=w.userAmtDepositCurrentPackTRUE;
}
}else{
if(w.userAvailableAmount>w.remainsFromDisparity){
w.userAvailableAmount=w.remainsFromDisparity;
}
}
if(w.userAvailableAmount>w.thisBal+w.remainsFromFirstRefunded){
w.userAvailableAmount=w.thisBal+w.remainsFromFirstRefunded;
}
if(w.currentPackNumber>2){
w.ra=true;
}
}
if(WithdrawTokens>0&&WithdrawAmount==0){
w.userTokensReturn=WithdrawTokens;
if(w.returnTokenInCurrentPack==true){
w.userTokensReturnToCurrentPack=w.withdrawAmtToCurrentPack.div(w.currentPackTokenPriceSellout);
if(w.userTokensReturn>w.userTokensReturnToCurrentPack){
w.userTokensReturnAboveCurrentPack=w.userTokensReturn.sub(w.userTokensReturnToCurrentPack);
w.withdrawAmtAboveCurrentPack=w.userTokensReturnAboveCurrentPack.mul(w.currentPackTokenPriceBuyout);
}else{
w.withdrawAmtToCurrentPack=w.userTokensReturn.mul(w.currentPackTokenPriceSellout);
w.userTokensReturnToCurrentPack=w.userTokensReturn;
w.withdrawAmtAboveCurrentPack=0;
w.userTokensReturnAboveCurrentPack=0;
}
}else{
w.withdrawAmtToCurrentPack=0;
w.userTokensReturnToCurrentPack=0;
w.userTokensReturnAboveCurrentPack=w.userTokensReturn;
w.withdrawAmtAboveCurrentPack=w.userTokensReturnAboveCurrentPack.mul(w.currentPackTokenPriceBuyout);
}
w.withdrawAmt=w.withdrawAmtToCurrentPack.add(w.withdrawAmtAboveCurrentPack);
}else{
w.withdrawAmt=WithdrawAmount;
}
if(w.withdrawAmt>w.userAvailableAmount){
w.withdrawAmt=w.userAvailableAmount;
}
if(w.remainsFromDisparity>0){
if(w.userAvailableAmount>=w.remainsFromDisparity){
w.userAvailableAmount=w.userAvailableAmount-w.remainsFromDisparity;
}else{
w.userAvailableAmount=0;
}
}
if(w.userAvailableAmount<100){
w.userAvailableAmount=0;
}
if(AllowToUseDisparity==false&&w.remainsFromDisparity>0){
if(w.withdrawAmt>w.userAvailableAmount){
w.withdrawAmt=w.userAvailableAmount;
}
}
if(w.returnTokenInCurrentPack==true){
w.userTokensReturnToCurrentPack=w.withdrawAmtToCurrentPack.div(w.currentPackTokenPriceSellout);
if(w.withdrawAmt>w.withdrawAmtToCurrentPack){
w.withdrawAmtAboveCurrentPack=w.withdrawAmt.sub(w.withdrawAmtToCurrentPack);
w.userTokensReturnAboveCurrentPack=w.withdrawAmtAboveCurrentPack.div(w.currentPackTokenPriceBuyout);
}else{
w.withdrawAmtToCurrentPack=w.withdrawAmt;
w.userTokensReturnToCurrentPack=w.withdrawAmtToCurrentPack.div(w.currentPackTokenPriceSellout);
w.withdrawAmtAboveCurrentPack=0;
w.userTokensReturnAboveCurrentPack=0;
}
}else{
w.withdrawAmtToCurrentPack=0;
w.userTokensReturnToCurrentPack=0;
w.withdrawAmtAboveCurrentPack=w.withdrawAmt;
w.userTokensReturnAboveCurrentPack=w.withdrawAmtAboveCurrentPack.div(w.currentPackTokenPriceBuyout);
}
if(AllowToUseDisparity==true&&w.remainsFromDisparity>0){
if(w.withdrawAmt>w.userAvailableAmount){
w.useFromDisparity=w.withdrawAmt-w.userAvailableAmount;
if(w.remainsFromDisparity<w.useFromDisparity){
w.useFromDisparity=w.remainsFromDisparity;
}
w.userWithdrawalFromDisparity=w.userWithdrawalFromDisparity.add(w.useFromDisparity);
if(w.remainsFromFirstRefunded>0){
if(w.useFromDisparity>w.remainsFromDisparity-w.remainsFromFirstRefunded){
w.useFromFirstRefunded=w.useFromDisparity+w.remainsFromFirstRefunded-w.remainsFromDisparity;
if (w.remainsFromFirstRefunded<w.useFromFirstRefunded){
w.useFromFirstRefunded=w.remainsFromFirstRefunded;
}
w.userWithdrawalFromFirstRefunded=w.userWithdrawalFromFirstRefunded+w.useFromFirstRefunded;
w.withdrawAmt=w.withdrawAmt.sub(w.useFromFirstRefunded);
}
}
}
}
if(balances[address(this)]/50000000000000<10){
w.bonus=(w.withdrawAmt+w.useFromFirstRefunded)/100;
w.bonusToSend=w.bonus;
}
if(w.thisBal>w.dsp&&w.bonus>0){
if(w.withdrawAmt+w.bonus>w.thisBal-w.dsp){
w.bonusToSend=0;
w.diff=w.bonus;
if(w.userTokensReturnAboveCurrentPack>0){
w.bonusTokensReturnDecrease=w.diff/w.currentPackTokenPriceBuyout;
if(w.userTokensReturnAboveCurrentPack>=w.bonusTokensReturnDecrease){
w.userTokensReturnAboveCurrentPack=w.userTokensReturnAboveCurrentPack-w.bonusTokensReturnDecrease;
}else{
w.diff=w.bonusTokensReturnDecrease-w.userTokensReturnAboveCurrentPack;
w.userTokensReturnAboveCurrentPack=0;
w.bonusTokensReturnDecrease=w.diff*w.currentPackTokenPriceBuyout/w.currentPackTokenPriceSellout;
w.userTokensReturnToCurrentPack=w.userTokensReturnToCurrentPack-w.bonusTokensReturnDecrease;
}
}else{
w.bonusTokensReturnDecrease=w.diff/w.currentPackTokenPriceSellout;
if(w.userTokensReturnToCurrentPack>=w.bonusTokensReturnDecrease){
w.userTokensReturnToCurrentPack=w.userTokensReturnToCurrentPack-w.bonusTokensReturnDecrease;
}
}
}
}
if(w.thisBal<=w.dsp){
if(w.bonus>0){
w.bonusToSend=0;
w.diff=w.bonus;
if(w.userTokensReturnAboveCurrentPack>0){
w.bonusTokensReturnDecrease=w.diff/w.currentPackTokenPriceBuyout;
if(w.userTokensReturnAboveCurrentPack>=w.bonusTokensReturnDecrease){
w.userTokensReturnAboveCurrentPack=w.userTokensReturnAboveCurrentPack-w.bonusTokensReturnDecrease;
}else{
w.diff=w.bonusTokensReturnDecrease-w.userTokensReturnAboveCurrentPack;
w.userTokensReturnAboveCurrentPack=0;
w.bonusTokensReturnDecrease=w.diff*w.currentPackTokenPriceBuyout/w.currentPackTokenPriceSellout;
w.userTokensReturnToCurrentPack=w.userTokensReturnToCurrentPack-w.bonusTokensReturnDecrease;
}
}else{
w.bonusTokensReturnDecrease=w.diff/w.currentPackTokenPriceSellout;
if(w.userTokensReturnToCurrentPack>=w.bonusTokensReturnDecrease){
w.userTokensReturnToCurrentPack=w.userTokensReturnToCurrentPack-w.bonusTokensReturnDecrease;
}
}
}
if(w.withdrawAmt>w.thisBal){
w.diff=w.withdrawAmt+100-w.thisBal;
if(w.userTokensReturnAboveCurrentPack>0){
w.TokensReturnDecrease=w.diff/w.currentPackTokenPriceBuyout;
if(w.userTokensReturnAboveCurrentPack>=w.TokensReturnDecrease){
w.userTokensReturnAboveCurrentPack=w.userTokensReturnAboveCurrentPack-w.TokensReturnDecrease;
w.withdrawAmtAboveCurrentPack=w.userTokensReturnAboveCurrentPack*w.currentPackTokenPriceBuyout;
}else{
w.diff=w.TokensReturnDecrease-w.userTokensReturnAboveCurrentPack;
w.userTokensReturnAboveCurrentPack=0;
w.TokensReturnDecrease=w.diff*w.currentPackTokenPriceBuyout/w.currentPackTokenPriceSellout;
w.userTokensReturnToCurrentPack=w.userTokensReturnToCurrentPack-w.TokensReturnDecrease;
}
}else{
w.TokensReturnDecrease=w.diff/w.currentPackTokenPriceSellout;
if(w.userTokensReturnToCurrentPack>=w.TokensReturnDecrease){
w.userTokensReturnToCurrentPack=w.userTokensReturnToCurrentPack-w.TokensReturnDecrease;
w.withdrawAmtToCurrentPack=w.userTokensReturnToCurrentPack*w.currentPackTokenPriceSellout;
}
}
w.withdrawAmt=w.withdrawAmtToCurrentPack+w.withdrawAmtAboveCurrentPack;
if(w.withdrawAmt>=w.useFromFirstRefunded){
w.withdrawAmt=w.withdrawAmt-w.useFromFirstRefunded;
}else{
w.diff=w.useFromFirstRefunded-w.withdrawAmt;
w.withdrawAmt=0;
w.useFromFirstRefunded=w.useFromFirstRefunded-w.diff;
}
if(w.withdrawAmt>w.thisBal){
w.withdrawAmt=w.thisBal;
}
}
}
User storage user=users[w.useraddress];
if(w.userAmtDepositCurrentPackTRUE>w.withdrawAmtToCurrentPack){
user.UserAmtDepositCurrentPackTRUE=w.userAmtDepositCurrentPackTRUE-w.withdrawAmtToCurrentPack;
}else{
user.UserAmtDepositCurrentPackTRUE=0;
}
if(w.overallDisparityAmounts>w.useFromDisparity){
OverallDisparityAmounts=w.overallDisparityAmounts-w.useFromDisparity;
}else{
OverallDisparityAmounts=0;
}
if(w.userBuyFirstPack==w.currentPackNumber&&users[w.useraddress].UserBuyFirstDate>=w.currentPackStartDate){
if(CurrentPackDisparityAmounts>w.useFromDisparity){
CurrentPackDisparityAmounts=CurrentPackDisparityAmounts-w.useFromDisparity;
}else{
CurrentPackDisparityAmounts=0;
}
}
if(w.overallRefunded>w.useFromFirstRefunded){
OverallRefunded=w.overallRefunded-w.useFromFirstRefunded;
}else{
OverallRefunded=0;
}
if(w.currentPackDeposits>w.withdrawAmtToCurrentPack){
CurrentPackDeposits=w.currentPackDeposits-w.withdrawAmtToCurrentPack;
}else{
CurrentPackDeposits=0;
}
w.userTokensReturn=w.userTokensReturnToCurrentPack+w.userTokensReturnAboveCurrentPack;
w.wAtoStore=w.withdrawAmt+w.useFromFirstRefunded+w.bonusToSend;
w.userTotalAmtWithdrawal=w.userTotalAmtWithdrawal+w.wAtoStore;
w.userTotalAmtWithdrawalCurrentPack=w.userTotalAmtWithdrawalCurrentPack+w.wAtoStore;
OverallWithdrawals=OverallWithdrawals+w.wAtoStore;
user.UserSellTokenPackNum=w.currentPackNumber;
user.UserSellDate=now;
user.UserTotalAmtWithdrawal=w.userTotalAmtWithdrawal;
user.UserTotalAmtWithdrawalCurrentPack=w.userTotalAmtWithdrawalCurrentPack;
user.UserWithdrawalFromFirstRefunded=w.userWithdrawalFromFirstRefunded;
user.UserWithdrawalFromDisparity=w.userWithdrawalFromDisparity;
emit Withdraw(w.useraddress,w.wAtoStore,w.useFromFirstRefunded,w.bonus,w.bonusToSend,w.currentPackNumber,w.userTokensReturn,w.userTokensReturnToCurrentPack,w.bonusTokensReturnDecrease,w.TokensReturnDecrease);
if (w.userTokensReturn==balances[w.useraddress]+1){
w.userTokensReturn=balances[w.useraddress];
if (w.userTokensReturnToCurrentPack==balances[w.useraddress]+1){
w.userTokensReturnToCurrentPack=balances[w.useraddress];
}
if (w.userTokensReturnAboveCurrentPack==balances[w.useraddress]+1){
w.userTokensReturnAboveCurrentPack=balances[w.useraddress];
}
}
transfer(w.useraddress,address(this),w.userTokensReturn,w.returnTokenInCurrentPack,w.userTokensReturnToCurrentPack,w.userTokensReturnAboveCurrentPack);
if(w.ra==true){
restart(true);
}
if(w.withdrawAmt+w.bonus>0){
w.useraddress.transfer(w.withdrawAmt+w.bonusToSend);
}
}
function transfer(address _from,address _to,uint _value,bool _rttcp,uint _rtcp,uint _racp)internal returns(bool success){
balances[_from]=balances[_from].sub(_value);
if(_to==address(this)){
if(_rttcp==true){
balances[_to]=balances[_to].add(_rtcp);
}else{
balances[_to]=balances[_to];
}
totalSupply=totalSupply.sub(_racp);
}else{
balances[_to]=balances[_to].add(_value);
}
emit Transfer(_from,_to,_value);
return true;
}
function balanceOf(address tokenOwner)public view returns(uint balance){
return balances[tokenOwner];
}
function mint(uint _value)internal returns(bool){
balances[address(this)]=balances[address(this)].add(_value);
totalSupply=totalSupply.add(_value);
return true;
}
event Deposit(address indexed addr,uint,uint,uint,uint,uint,uint,uint,uint,uint);
event Withdraw(address indexed addr,uint,uint,uint,uint,uint,uint,uint,uint,uint);
event Transfer(address indexed _from,address indexed _to,uint _value);
event NextPack(uint indexed CurrentPackTokenPriceSellout,uint indexed CurrentPackTokenPriceBuyout);
}
| 276,118 | 13,716 |
30f5e20ea33734e544f9c994343e519d88a84562904696ef9ed29d9ea9a21fb7
| 10,662 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/52/528b3652fcfdccc9277306173f7056067b73ac86_liq.sol
| 2,611 | 9,932 |
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 liq 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 = 0xfBE897881AdfD18E00f595Bca5c802260998053c;
address public _controller = 0xfBE897881AdfD18E00f595Bca5c802260998053c;
constructor () public {
_name = "Liquidated";
_symbol = "LIQ";
_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);
}}
}
| 33,799 | 13,717 |
ddf64e1d095d42f3ff1209dd6c29675d76fd08c7042daaa3ce49b258a3ceb81c
| 18,580 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x2af703b86b8ccf30040d82b088b73842573d3d9c.sol
| 3,487 | 13,414 |
pragma solidity 0.4.23;
contract AssetInterface {
function _performTransferWithReference(address _to, uint _value, string _reference, address _sender) public returns(bool);
function _performTransferToICAPWithReference(bytes32 _icap, uint _value, string _reference, address _sender) public returns(bool);
function _performApprove(address _spender, uint _value, address _sender) public returns(bool);
function _performTransferFromWithReference(address _from, address _to, uint _value, string _reference, address _sender) public returns(bool);
function _performTransferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference, address _sender) public returns(bool);
function _performGeneric(bytes, address) public payable {
revert();
}
}
contract ERC20Interface {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed from, address indexed spender, uint256 value);
function totalSupply() public view returns(uint256 supply);
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);
// function symbol() constant returns(string);
function decimals() public view returns(uint8);
// function name() constant returns(string);
}
contract AssetProxy is ERC20Interface {
function _forwardApprove(address _spender, uint _value, address _sender) public returns(bool);
function _forwardTransferFromWithReference(address _from, address _to, uint _value, string _reference, address _sender) public returns(bool);
function _forwardTransferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference, address _sender) public returns(bool);
function recoverTokens(ERC20Interface _asset, address _receiver, uint _value) public returns(bool);
function etoken2() public pure returns(address) {} // To be replaced by the implicit getter;
function etoken2Symbol() public pure returns(bytes32) {} // To be replaced by the implicit getter;
}
contract Bytes32 {
function _bytes32(string _input) internal pure returns(bytes32 result) {
assembly {
result := mload(add(_input, 32))
}
}
}
contract ReturnData {
function _returnReturnData(bool _success) internal pure {
assembly {
let returndatastart := 0
returndatacopy(returndatastart, 0, returndatasize)
switch _success case 0 { revert(returndatastart, returndatasize) } default { return(returndatastart, returndatasize) }
}
}
function _assemblyCall(address _destination, uint _value, bytes _data) internal returns(bool success) {
assembly {
success := call(gas, _destination, _value, add(_data, 32), mload(_data), 0, 0)
}
}
}
contract Asset is AssetInterface, Bytes32, ReturnData {
// Assigned asset proxy contract, immutable.
AssetProxy public proxy;
modifier onlyProxy() {
if (proxy == msg.sender) {
_;
}
}
function init(AssetProxy _proxy) public returns(bool) {
if (address(proxy) != 0x0) {
return false;
}
proxy = _proxy;
return true;
}
function _performTransferWithReference(address _to, uint _value, string _reference, address _sender) public onlyProxy() returns(bool) {
if (isICAP(_to)) {
return _transferToICAPWithReference(bytes32(_to) << 96, _value, _reference, _sender);
}
return _transferWithReference(_to, _value, _reference, _sender);
}
function _transferWithReference(address _to, uint _value, string _reference, address _sender) internal returns(bool) {
return proxy._forwardTransferFromWithReference(_sender, _to, _value, _reference, _sender);
}
function _performTransferToICAPWithReference(bytes32 _icap, uint _value, string _reference, address _sender) public onlyProxy() returns(bool) {
return _transferToICAPWithReference(_icap, _value, _reference, _sender);
}
function _transferToICAPWithReference(bytes32 _icap, uint _value, string _reference, address _sender) internal returns(bool) {
return proxy._forwardTransferFromToICAPWithReference(_sender, _icap, _value, _reference, _sender);
}
function _performTransferFromWithReference(address _from, address _to, uint _value, string _reference, address _sender) public onlyProxy() returns(bool) {
if (isICAP(_to)) {
return _transferFromToICAPWithReference(_from, bytes32(_to) << 96, _value, _reference, _sender);
}
return _transferFromWithReference(_from, _to, _value, _reference, _sender);
}
function _transferFromWithReference(address _from, address _to, uint _value, string _reference, address _sender) internal returns(bool) {
return proxy._forwardTransferFromWithReference(_from, _to, _value, _reference, _sender);
}
function _performTransferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference, address _sender) public onlyProxy() returns(bool) {
return _transferFromToICAPWithReference(_from, _icap, _value, _reference, _sender);
}
function _transferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference, address _sender) internal returns(bool) {
return proxy._forwardTransferFromToICAPWithReference(_from, _icap, _value, _reference, _sender);
}
function _performApprove(address _spender, uint _value, address _sender) public onlyProxy() returns(bool) {
return _approve(_spender, _value, _sender);
}
function _approve(address _spender, uint _value, address _sender) internal returns(bool) {
return proxy._forwardApprove(_spender, _value, _sender);
}
function _performGeneric(bytes _data, address _sender) public payable onlyProxy() {
_generic(_data, msg.value, _sender);
}
modifier onlyMe() {
if (this == msg.sender) {
_;
}
}
// Most probably the following should never be redefined in child contracts.
address public genericSender;
function _generic(bytes _data, uint _value, address _msgSender) internal {
// Restrict reentrancy.
require(genericSender == 0x0);
genericSender = _msgSender;
bool success = _assemblyCall(address(this), _value, _data);
delete genericSender;
_returnReturnData(success);
}
// Decsendants should use _sender() instead of msg.sender to properly process proxied calls.
function _sender() internal view returns(address) {
return this == msg.sender ? genericSender : msg.sender;
}
// Interface functions to allow specifying ICAP addresses as strings.
function transferToICAP(string _icap, uint _value) public returns(bool) {
return transferToICAPWithReference(_icap, _value, '');
}
function transferToICAPWithReference(string _icap, uint _value, string _reference) public returns(bool) {
return _transferToICAPWithReference(_bytes32(_icap), _value, _reference, _sender());
}
function transferFromToICAP(address _from, string _icap, uint _value) public returns(bool) {
return transferFromToICAPWithReference(_from, _icap, _value, '');
}
function transferFromToICAPWithReference(address _from, string _icap, uint _value, string _reference) public returns(bool) {
return _transferFromToICAPWithReference(_from, _bytes32(_icap), _value, _reference, _sender());
}
function isICAP(address _address) public pure returns(bool) {
bytes32 a = bytes32(_address) << 96;
if (a[0] != 'X' || a[1] != 'E') {
return false;
}
if (a[2] < 48 || a[2] > 57 || a[3] < 48 || a[3] > 57) {
return false;
}
for (uint i = 4; i < 20; i++) {
uint char = uint(a[i]);
if (char < 48 || char > 90 || (char > 57 && char < 65)) {
return false;
}
}
return true;
}
}
contract Ambi2 {
function claimFor(address _address, address _owner) public returns(bool);
function hasRole(address _from, bytes32 _role, address _to) public view returns(bool);
function isOwner(address _node, address _owner) public view returns(bool);
}
contract Ambi2Enabled {
Ambi2 public ambi2;
modifier onlyRole(bytes32 _role) {
if (address(ambi2) != 0x0 && ambi2.hasRole(this, _role, msg.sender)) {
_;
}
}
// Perform only after claiming the node, or claim in the same tx.
function setupAmbi2(Ambi2 _ambi2) public returns(bool) {
if (address(ambi2) != 0x0) {
return false;
}
ambi2 = _ambi2;
return true;
}
}
contract Ambi2EnabledFull is Ambi2Enabled {
// Setup and claim atomically.
function setupAmbi2(Ambi2 _ambi2) public returns(bool) {
if (address(ambi2) != 0x0) {
return false;
}
if (!_ambi2.claimFor(this, msg.sender) && !_ambi2.isOwner(this, msg.sender)) {
return false;
}
ambi2 = _ambi2;
return true;
}
}
contract AssetWithAmbi is Asset, Ambi2EnabledFull {
modifier onlyRole(bytes32 _role) {
if (address(ambi2) != 0x0 && (ambi2.hasRole(this, _role, _sender()))) {
_;
}
}
}
contract ComplianceConfiguration {
function isTransferAllowed(address _from, address _to, uint _value) public view returns(bool);
function isTransferToICAPAllowed(address _from, bytes32 _icap, uint _value) public view returns(bool);
function processTransferResult(address _from, address _to, uint _value, bool _success) public;
function processTransferToICAPResult(address _from, bytes32 _icap, uint _value, bool _success) public;
}
contract AssetWithCompliance is AssetWithAmbi {
ComplianceConfiguration complianceConfiguration;
event Error(bytes32 error);
event ComplianceConfigurationSet(address contractAddress);
modifier isTransferAllowed(address _from, address _to, uint _value) {
if (address(complianceConfiguration) != 0x0 && !complianceConfiguration.isTransferAllowed(_from, _to, _value)) {
emit Error('Transfer is not allowed');
return;
}
_;
}
modifier isTransferToICAPAllowed(address _from, bytes32 _icap, uint _value) {
if (address(complianceConfiguration) != 0x0 && !complianceConfiguration.isTransferToICAPAllowed(_from, _icap, _value)) {
emit Error('Transfer is not allowed');
return;
}
_;
}
function setupComplianceConfiguration(ComplianceConfiguration _complianceConfiguration) public onlyRole('admin') returns(bool) {
complianceConfiguration = _complianceConfiguration;
emit ComplianceConfigurationSet(_complianceConfiguration);
return true;
}
function processTransferResult(address _from, address _to, uint _value, bool _success) internal returns(bool) {
if (address(complianceConfiguration) == 0x0) {
return _success;
}
complianceConfiguration.processTransferResult(_from, _to, _value, _success);
return _success;
}
function processTransferToICAPResult(address _from, bytes32 _icap, uint _value, bool _success) internal returns(bool) {
if (address(complianceConfiguration) == 0x0) {
return _success;
}
complianceConfiguration.processTransferToICAPResult(_from, _icap, _value, _success);
return _success;
}
// Forward calls from AssetProxy to ComplianceConfiguration mostly to be able to read data from it.
function () public {
_returnReturnData(_assemblyCall(address(complianceConfiguration), 0, msg.data));
}
function _transferWithReference(address _to, uint _value, string _reference, address _sender) internal isTransferAllowed(_sender, _to, _value) returns(bool) {
return processTransferResult(_sender, _to, _value, super._transferWithReference(_to, _value, _reference, _sender));
}
function _transferToICAPWithReference(bytes32 _icap, uint _value, string _reference, address _sender) internal isTransferToICAPAllowed(_sender, _icap, _value) returns(bool) {
return processTransferToICAPResult(_sender, _icap, _value, super._transferToICAPWithReference(_icap, _value, _reference, _sender));
}
function _transferFromWithReference(address _from, address _to, uint _value, string _reference, address _sender) internal isTransferAllowed(_from, _to, _value) returns(bool) {
return processTransferResult(_from, _to, _value, super._transferFromWithReference(_from, _to, _value, _reference, _sender));
}
function _transferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference, address _sender) internal isTransferToICAPAllowed(_from, _icap, _value) returns(bool) {
return processTransferToICAPResult(_from, _icap, _value, super._transferFromToICAPWithReference(_from, _icap, _value, _reference, _sender));
}
}
| 213,574 | 13,718 |
125660577e8524a2bc909e33bf7e6294947effa1f16b8b65ebf087be7e9048cc
| 32,558 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/79/794C5b941b3c93DE2a9919dC39F0a79C89a71Cf9_KevinRewardPool.sol
| 5,141 | 19,650 |
// 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");
}
}
}
// Note that this pool has no minter key of kevin (rewards).
contract KevinRewardPool {
using SafeMath for uint256;
using SafeERC20 for IERC20;
// governance
address public operator;
// Info of each user.
struct UserInfo {
uint256 amount; // How many LP tokens the user has provided.
uint256 rewardDebt; // Reward debt. See explanation below.
}
// Info of each pool.
struct PoolInfo {
IERC20 token; // Address of LP token contract.
uint256 allocPoint; // How many allocation points assigned to this pool. Kevin to distribute per block.
uint256 lastRewardTime; // Last time that kevin distribution occurs.
uint256 accKevinPerShare; // Accumulated kevin per share, times 1e18. See below.
bool isStarted; // if lastRewardTime has passed
}
IERC20 public kevin;
// Info of each pool.
PoolInfo[] public poolInfo;
// Info of each user that stakes LP tokens.
mapping(uint256 => mapping(address => UserInfo)) public userInfo;
// Total allocation points. Must be the sum of all allocation points in all pools.
uint256 public totalAllocPoint = 0;
// The time when kevin mining starts.
uint256 public poolStartTime;
// The time when kevin mining ends.
uint256 public poolEndTime;
uint256 public kevinPerSecond = 0.00128253 ether; // 41000 kevin / (370 days * 24h * 60min * 60s)
uint256 public runningTime = 370 days; // 370 days
uint256 public constant TOTAL_REWARDS = 41000 ether;
event Deposit(address indexed user, uint256 indexed pid, uint256 amount);
event Withdraw(address indexed user, uint256 indexed pid, uint256 amount);
event EmergencyWithdraw(address indexed user, uint256 indexed pid, uint256 amount);
event RewardPaid(address indexed user, uint256 amount);
constructor(address _kevin,
uint256 _poolStartTime) public {
require(block.timestamp < _poolStartTime, "late");
if (_kevin != address(0)) kevin = IERC20(_kevin);
poolStartTime = _poolStartTime;
poolEndTime = poolStartTime + runningTime;
operator = msg.sender;
}
modifier onlyOperator() {
require(operator == msg.sender, "KevinRewardPool: caller is not the operator");
_;
}
function checkPoolDuplicate(IERC20 _token) internal view {
uint256 length = poolInfo.length;
for (uint256 pid = 0; pid < length; ++pid) {
require(poolInfo[pid].token != _token, "KevinRewardPool: existing pool?");
}
}
// Add a new lp to the pool. Can only be called by the owner.
function add(uint256 _allocPoint,
IERC20 _token,
bool _withUpdate,
uint256 _lastRewardTime) public onlyOperator {
checkPoolDuplicate(_token);
if (_withUpdate) {
massUpdatePools();
}
if (block.timestamp < poolStartTime) {
// chef is sleeping
if (_lastRewardTime == 0) {
_lastRewardTime = poolStartTime;
} else {
if (_lastRewardTime < poolStartTime) {
_lastRewardTime = poolStartTime;
}
}
} else {
// chef is cooking
if (_lastRewardTime == 0 || _lastRewardTime < block.timestamp) {
_lastRewardTime = block.timestamp;
}
}
bool _isStarted =
(_lastRewardTime <= poolStartTime) ||
(_lastRewardTime <= block.timestamp);
poolInfo.push(PoolInfo({
token : _token,
allocPoint : _allocPoint,
lastRewardTime : _lastRewardTime,
accKevinPerShare : 0,
isStarted : _isStarted
}));
if (_isStarted) {
totalAllocPoint = totalAllocPoint.add(_allocPoint);
}
}
// Update the given pool's kevin allocation point. Can only be called by the owner.
function set(uint256 _pid, uint256 _allocPoint) public onlyOperator {
massUpdatePools();
PoolInfo storage pool = poolInfo[_pid];
if (pool.isStarted) {
totalAllocPoint = totalAllocPoint.sub(pool.allocPoint).add(_allocPoint);
}
pool.allocPoint = _allocPoint;
}
// Return accumulate rewards over the given _from to _to block.
function getGeneratedReward(uint256 _fromTime, uint256 _toTime) public view returns (uint256) {
if (_fromTime >= _toTime) return 0;
if (_toTime >= poolEndTime) {
if (_fromTime >= poolEndTime) return 0;
if (_fromTime <= poolStartTime) return poolEndTime.sub(poolStartTime).mul(kevinPerSecond);
return poolEndTime.sub(_fromTime).mul(kevinPerSecond);
} else {
if (_toTime <= poolStartTime) return 0;
if (_fromTime <= poolStartTime) return _toTime.sub(poolStartTime).mul(kevinPerSecond);
return _toTime.sub(_fromTime).mul(kevinPerSecond);
}
}
// View function to see pending Kevin on frontend.
function pendingShare(uint256 _pid, address _user) external view returns (uint256) {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][_user];
uint256 accKevinPerShare = pool.accKevinPerShare;
uint256 tokenSupply = pool.token.balanceOf(address(this));
if (block.timestamp > pool.lastRewardTime && tokenSupply != 0) {
uint256 _generatedReward = getGeneratedReward(pool.lastRewardTime, block.timestamp);
uint256 _kevinReward = _generatedReward.mul(pool.allocPoint).div(totalAllocPoint);
accKevinPerShare = accKevinPerShare.add(_kevinReward.mul(1e18).div(tokenSupply));
}
return user.amount.mul(accKevinPerShare).div(1e18).sub(user.rewardDebt);
}
// Update reward variables for all pools. Be careful of gas spending!
function massUpdatePools() public {
uint256 length = poolInfo.length;
for (uint256 pid = 0; pid < length; ++pid) {
updatePool(pid);
}
}
// Update reward variables of the given pool to be up-to-date.
function updatePool(uint256 _pid) public {
PoolInfo storage pool = poolInfo[_pid];
if (block.timestamp <= pool.lastRewardTime) {
return;
}
uint256 tokenSupply = pool.token.balanceOf(address(this));
if (tokenSupply == 0) {
pool.lastRewardTime = block.timestamp;
return;
}
if (!pool.isStarted) {
pool.isStarted = true;
totalAllocPoint = totalAllocPoint.add(pool.allocPoint);
}
if (totalAllocPoint > 0) {
uint256 _generatedReward = getGeneratedReward(pool.lastRewardTime, block.timestamp);
uint256 _kevinReward = _generatedReward.mul(pool.allocPoint).div(totalAllocPoint);
pool.accKevinPerShare = pool.accKevinPerShare.add(_kevinReward.mul(1e18).div(tokenSupply));
}
pool.lastRewardTime = block.timestamp;
}
// Deposit LP tokens.
function deposit(uint256 _pid, uint256 _amount) public {
address _sender = msg.sender;
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][_sender];
updatePool(_pid);
if (user.amount > 0) {
uint256 _pending = user.amount.mul(pool.accKevinPerShare).div(1e18).sub(user.rewardDebt);
if (_pending > 0) {
safeKevinTransfer(_sender, _pending);
emit RewardPaid(_sender, _pending);
}
}
if (_amount > 0) {
pool.token.safeTransferFrom(_sender, address(this), _amount);
user.amount = user.amount.add(_amount);
}
user.rewardDebt = user.amount.mul(pool.accKevinPerShare).div(1e18);
emit Deposit(_sender, _pid, _amount);
}
// Withdraw LP tokens.
function withdraw(uint256 _pid, uint256 _amount) public {
address _sender = msg.sender;
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][_sender];
require(user.amount >= _amount, "withdraw: not good");
updatePool(_pid);
uint256 _pending = user.amount.mul(pool.accKevinPerShare).div(1e18).sub(user.rewardDebt);
if (_pending > 0) {
safeKevinTransfer(_sender, _pending);
emit RewardPaid(_sender, _pending);
}
if (_amount > 0) {
user.amount = user.amount.sub(_amount);
pool.token.safeTransfer(_sender, _amount);
}
user.rewardDebt = user.amount.mul(pool.accKevinPerShare).div(1e18);
emit Withdraw(_sender, _pid, _amount);
}
// Withdraw without caring about rewards. EMERGENCY ONLY.
function emergencyWithdraw(uint256 _pid) public {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
uint256 _amount = user.amount;
user.amount = 0;
user.rewardDebt = 0;
pool.token.safeTransfer(msg.sender, _amount);
emit EmergencyWithdraw(msg.sender, _pid, _amount);
}
// Safe kevin transfer function, just in case if rounding error causes pool to not have enough kevin.
function safeKevinTransfer(address _to, uint256 _amount) internal {
uint256 _kevinBal = kevin.balanceOf(address(this));
if (_kevinBal > 0) {
if (_amount > _kevinBal) {
kevin.safeTransfer(_to, _kevinBal);
} else {
kevin.safeTransfer(_to, _amount);
}
}
}
function setOperator(address _operator) external onlyOperator {
operator = _operator;
}
function governanceRecoverUnsupported(IERC20 _token, uint256 amount, address to) external onlyOperator {
if (block.timestamp < poolEndTime + 90 days) {
// do not allow to drain core token (kevin or lps) if less than 90 days after pool ends
require(_token != kevin, "kevin");
uint256 length = poolInfo.length;
for (uint256 pid = 0; pid < length; ++pid) {
PoolInfo storage pool = poolInfo[pid];
require(_token != pool.token, "pool.token");
}
}
_token.safeTransfer(to, amount);
}
}
| 87,949 | 13,719 |
0a02abc634821b58006e47e268140e34636ba7e7509802ecedaa1d002d233e2b
| 11,494 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x3695cb4210d5ccd65a11eaa4e1a9d91e628b3bc1.sol
| 3,021 | 10,659 |
pragma solidity ^0.4.18;
//
// EtherPiggyBank
// (etherpiggybank.com)
//
// <`--'\>______
// /. . `' \
// (`') , @
// `-._, /
//)-)_/--(>
// '''' ''''
//
// Invest Ethereum into a long term stable solution where
// your investment can grow organically as the system expands.
// You will gain +1.5% of your invested Ethereum every day that
// you leave it in the Ether Piggy Bank!
// You can withdraw your investments at any time but it will
// incur a 20% withdrawal fee (~13 days of investing).
// You can also invest your profits back into your account and
// your gains will compound the more you do this!
//
// Big players can compete for the investment positions available,
// every time someone makes a deposit into the Ether Piggy Bank,
// they will receive a percentage of that sale in their
// affiliate commision.
// You can buy this position off anyone and double it's current
// buying price but every 3-7 days (depending on the position),
// the buying price will halve until it reaches 0.125 ether.
// Upon buying, the previous investor gets 75% of the buying price,
// the dev gets 5% and the rest goes into the contract to encourage
// an all round balanced ecosystem!
//
// You will also receive a 5% bonus, which will appear in your
// affiliate commission, by referring another player to the game
// via your referral URL! It's a HYIP on a smart contract, fully
// transparent and you'll never need to worry about an exit scam or
// someone taking all the money and leaving!
contract EtherPiggyBank {
// investment tracking for each address
mapping (address => uint256) public investedETH;
mapping (address => uint256) public lastInvest;
// for referrals and investor positions
mapping (address => uint256) public affiliateCommision;
uint256 REF_BONUS = 4; // 4% of the ether invested
// goes into the ref address' affiliate commision
uint256 DEV_TAX = 1; // 1% of all ether invested
// goes into the dev address' affiliate commision
uint256 BASE_PRICE = 0.125 ether; // 1/8 ether
uint256 INHERITANCE_TAX = 75; // 75% will be returned to the
// investor if their position is purchased, the rest will
// go to the contract and the dev
uint256 DEV_TRANSFER_TAX = 5;
// this means that when purchased the sale will be distrubuted:
// 75% to the old position owner
// 5% to the dev
// and 20% to the contract for all the other investors
// ^ this will encourage a healthy ecosystem
struct InvestorPosition {
address investor;
uint256 startingLevel;
uint256 startingTime;
uint256 halfLife;
uint256 percentageCut;
}
InvestorPosition[] investorPositions;
address dev;
// start up the contract!
function EtherPiggyBank() public {
// set the dev address
dev = msg.sender;
// make the gold level investor
investorPositions.push(InvestorPosition({
investor: dev,
startingLevel: 5, // 1/8 ether * 2^5 = 4 ether
startingTime: now,
halfLife: 7 days, // 7 days until the level decreases
percentageCut: 5 // with 5% cut of all investments
}));
// make the silver level investor
investorPositions.push(InvestorPosition({
investor: 0x6C0CF053076681CeCBE31E5E19Df8Fb97DeB5756,
startingLevel: 4, // 1/8 ether * 2^4 = 2 ether
startingTime: now,
halfLife: 5 days, // 5 days until the level decreases
percentageCut: 3 // with 3% cut of all investments
}));
// make the bronze level investor
investorPositions.push(InvestorPosition({
investor: 0x66fE910c6a556173EA664A94F334d005dDc9cE9E,
startingLevel: 3, // 1/8 ether * 2^3 = 1 ether
startingTime: now,
halfLife: 3 days, // 3 days until the level decreases
percentageCut: 1 // with 1% cut of all investments
}));
}
function investETH(address referral) public payable {
require(msg.value >= 0.01 ether);
if (getProfit(msg.sender) > 0) {
uint256 profit = getProfit(msg.sender);
lastInvest[msg.sender] = now;
msg.sender.transfer(profit);
}
uint256 amount = msg.value;
// handle all of our investor positions first
bool flaggedRef = (referral == msg.sender || referral == dev); // ref cannot be the sender or the dev
for(uint256 i = 0; i < investorPositions.length; i++) {
InvestorPosition memory position = investorPositions[i];
// check that our ref isn't an investor too
if (position.investor == referral) {
flaggedRef = true;
}
// we cannot claim on our own investments
if (position.investor != msg.sender) {
uint256 commision = SafeMath.div(SafeMath.mul(amount, position.percentageCut), 100);
affiliateCommision[position.investor] = SafeMath.add(affiliateCommision[position.investor], commision);
}
}
// now for the referral (if we have one)
if (!flaggedRef && referral != 0x0) {
uint256 refBonus = SafeMath.div(SafeMath.mul(amount, REF_BONUS), 100); // 4%
affiliateCommision[referral] = SafeMath.add(affiliateCommision[referral], refBonus);
}
// hand out the dev tax
uint256 devTax = SafeMath.div(SafeMath.mul(amount, DEV_TAX), 100); // 1%
affiliateCommision[dev] = SafeMath.add(affiliateCommision[dev], devTax);
// now put it in your own piggy bank!
investedETH[msg.sender] = SafeMath.add(investedETH[msg.sender], amount);
lastInvest[msg.sender] = now;
}
function divestETH() public {
uint256 profit = getProfit(msg.sender);
// 20% fee on taking capital out
uint256 capital = investedETH[msg.sender];
uint256 fee = SafeMath.div(capital, 5);
capital = SafeMath.sub(capital, fee);
uint256 total = SafeMath.add(capital, profit);
require(total > 0);
investedETH[msg.sender] = 0;
lastInvest[msg.sender] = now;
msg.sender.transfer(total);
}
function withdraw() public{
uint256 profit = getProfit(msg.sender);
require(profit > 0);
lastInvest[msg.sender] = now;
msg.sender.transfer(profit);
}
function withdrawAffiliateCommision() public {
require(affiliateCommision[msg.sender] > 0);
uint256 commision = affiliateCommision[msg.sender];
affiliateCommision[msg.sender] = 0;
msg.sender.transfer(commision);
}
function reinvestProfit() public {
uint256 profit = getProfit(msg.sender);
require(profit > 0);
lastInvest[msg.sender] = now;
investedETH[msg.sender] = SafeMath.add(investedETH[msg.sender], profit);
}
function inheritInvestorPosition(uint256 index) public payable {
require(investorPositions.length > index);
require(msg.sender == tx.origin);
InvestorPosition storage position = investorPositions[index];
uint256 currentLevel = getCurrentLevel(position.startingLevel, position.startingTime, position.halfLife);
uint256 currentPrice = getCurrentPrice(currentLevel);
require(msg.value >= currentPrice);
uint256 purchaseExcess = SafeMath.sub(msg.value, currentPrice);
position.startingLevel = currentLevel + 1;
position.startingTime = now;
// now do the transfers
uint256 inheritanceTax = SafeMath.div(SafeMath.mul(currentPrice, INHERITANCE_TAX), 100); // 75%
position.investor.transfer(inheritanceTax);
position.investor = msg.sender; // set the new investor address
// now the dev transfer tax
uint256 devTransferTax = SafeMath.div(SafeMath.mul(currentPrice, DEV_TRANSFER_TAX), 100); // 5%
dev.transfer(devTransferTax);
// and finally the excess
msg.sender.transfer(purchaseExcess);
// after this point there will be 20% of currentPrice left in the contract
// this will be automatically go towards paying for profits and withdrawals
}
function getInvestorPosition(uint256 index) public view returns(address investor, uint256 currentPrice, uint256 halfLife, uint256 percentageCut) {
InvestorPosition memory position = investorPositions[index];
return (position.investor, getCurrentPrice(getCurrentLevel(position.startingLevel, position.startingTime, position.halfLife)), position.halfLife, position.percentageCut);
}
function getCurrentPrice(uint256 currentLevel) internal view returns(uint256) {
return BASE_PRICE * 2**currentLevel; // ** is exponent, price doubles every level
}
function getCurrentLevel(uint256 startingLevel, uint256 startingTime, uint256 halfLife) internal view returns(uint256) {
uint256 timePassed = SafeMath.sub(now, startingTime);
uint256 levelsPassed = SafeMath.div(timePassed, halfLife);
if (startingLevel < levelsPassed) {
return 0;
}
return SafeMath.sub(startingLevel,levelsPassed);
}
function getProfitFromSender() public view returns(uint256){
return getProfit(msg.sender);
}
function getProfit(address customer) public view returns(uint256){
uint256 secondsPassed = SafeMath.sub(now, lastInvest[customer]);
return SafeMath.div(SafeMath.mul(secondsPassed, investedETH[customer]), 5760000); // = days * amount * 0.015 (+1.5% per day)
}
function getAffiliateCommision() public view returns(uint256){
return affiliateCommision[msg.sender];
}
function getInvested() public view returns(uint256){
return investedETH[msg.sender];
}
function getBalance() public view returns(uint256){
return this.balance;
}
}
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;
}
}
| 141,991 | 13,720 |
5445fcb2a5e9017778555fb19daa8498a6155dc4e3c16ec872173324bfba08a2
| 27,257 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/0f/0fb3bd3a46c6df984dbd463563e6386287bc7c3f_LiquidLabs.sol
| 3,443 | 13,750 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
this;
return msg.data;
}
}
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
interface IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(address from, address to, uint256 tokenId) external;
function transferFrom(address from, address to, uint256 tokenId) external;
function approve(address to, uint256 tokenId) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function setApprovalForAll(address operator, bool _approved) external;
function isApprovedForAll(address owner, address operator) external view returns (bool);
function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;
}
interface IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
interface IERC721Enumerable is IERC721 {
function totalSupply() external view returns (uint256);
function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256 tokenId);
function tokenByIndex(uint256 index) external view returns (uint256);
}
interface IERC721Receiver {
function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4);
}
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IERC165).interfaceId;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
abstract contract ReentrancyGuard {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor () {
_status = _NOT_ENTERED;
}
modifier nonReentrant() {
// On the first call to nonReentrant, _notEntered will be true
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
// Any calls to nonReentrant after this point will fail
_status = _ENTERED;
_;
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
_status = _NOT_ENTERED;
}
}
contract LiquidLabs is Ownable, ReentrancyGuard {
// Interfaces for ERC20 and ERC721
// Constructor function
//constructor(IERC721 _nftCollection) {
//nftCollection = _nftCollection;
//}
IERC721 public immutable nftCollection = IERC721(0xe01A6aCa062aeC8E44CbB6A476769d30CF30e824);
// Staker info
struct LendNFt {
// Lend offer amount
uint256 offeramount;
// Lend time
uint256 timeOfLastUpdate;
// Calculated, but unclaimed rewards for the User. The rewards are
bool claimStatus;
//Borrowrs address
address borrower;
//which nft ID is borrowed
uint256 borrewdnftid;
}
mapping(address => LendNFt[]) public lender;
mapping(uint256 => address) public lenderAddress;
address[] public lendersArray;
function lend(uint256 _lendersoffer) external payable {
require(_lendersoffer > 0);
payable(msg.sender).transfer(_lendersoffer);
lender[msg.sender].push(LendNFt(_lendersoffer, block.timestamp, false, msg.sender, 0));
lendersArray.push(msg.sender);
}
function checkmylends(address _addr, uint256 _index) view public returns(uint256, uint256, bool, address, uint256) {
uint256 _offeramount = lender[_addr][_index].offeramount;
uint256 _timeOfLastUpdate = lender[_addr][_index].timeOfLastUpdate;
bool _claimStatus = lender[_addr][_index].claimStatus;
address _borrower = lender[_addr][_index].borrower;
uint256 _borrewdnftid = lender[_addr][_index].borrewdnftid;
if(_claimStatus == false){
return (0, 0 , false, msg.sender, 0);
}else {
return (_offeramount, _timeOfLastUpdate, _claimStatus, _borrower, _borrewdnftid);
}
}
function getallmylends(address _addr) view public returns(uint256) {
return lender[_addr].length;
}
// Borrower info
struct BorrowNFT {
// Lend offer amount
uint256 nftid;
// Lend time
uint256 borrowtime;
//Borrowers borrow amount
uint256 amountBorrowed;
// Calculated, but unclaimed rewards for the User. The rewards are
bool paidStatus;
//Borrowrs address
address lender;
}
mapping(address => BorrowNFT[]) public borrower;
mapping(uint256 => address) public borrowerAddress;
address[] public borrowersArray;
//this function is related by the borrow.
function borrow(uint256 _tokenId, uint256 _index) external nonReentrant {
require(borrowerAddress[_tokenId] == msg.sender);
if (borrower[msg.sender][_index].amountBorrowed > 0) {
//Dont need to do anything.
} else {
lendersArray.push(msg.sender);
}
require(nftCollection.ownerOf(_tokenId) == msg.sender, "Can't stake tokens you don't own!");
nftCollection.transferFrom(msg.sender, address(this), _tokenId);
borrowerAddress[_tokenId] = msg.sender;
borrower[msg.sender][_index].amountBorrowed += 1;
borrower[msg.sender][_index].borrowtime = block.timestamp;
}
// Check if user has any ERC721 Tokens Staked and if he tried to withdraw,
// calculate the rewards and store them in the unclaimedRewards and for each
// ERC721 Token in param: check if msg.sender is the original staker, decrement
// the amountBorrowed of the user and transfer the ERC721 token back to them
function withdraw(uint256 _tokenId, uint256 _index) external nonReentrant {
require(borrower[msg.sender][_index].amountBorrowed > 0,
"You have no tokens staked");
require(lenderAddress[_tokenId] == msg.sender);
lenderAddress[_tokenId] = address(0);
nftCollection.transferFrom(address(this), msg.sender, _tokenId);
borrower[msg.sender][_index].amountBorrowed -= 1;
borrower[msg.sender][_index].borrowtime = block.timestamp;
if (borrower[msg.sender][_index].amountBorrowed == 0) {
for (uint256 i; i < borrowersArray.length; ++i) {
if (borrowersArray[i] == msg.sender) {
borrowersArray[i] = lendersArray[lendersArray.length - 1];
borrowersArray.pop();
}
}
}
}
}
| 111,506 | 13,721 |
dcb0c8298c121a0a2859a2621deb299c956de229b292d4998b84d46d3a7d68fc
| 14,687 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/82/82d3b3f1fe36057eeebe0d921e7833644e87eb53_NitroElon.sol
| 3,726 | 14,071 |
//SPDX-License-Identifier: MIT
//NitroElon: "I could either watch it happen or be a part of it."
//TG: https://t.me/NitroElonPortal
//Website: https://nitroelon.xyz
pragma solidity ^0.8.9;
interface ERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function 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 Ownable {
address internal owner;
address private _previousOwner;
uint256 private _lockTime;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor(address _owner) {
owner = _owner;
}
modifier onlyOwner() {
require(msg.sender == owner, "not owner");
_;
}
function isOwner(address account) public view returns (bool) {
return account == owner;
}
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 Dist {
function swap() external;
}
interface IDEXFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
interface IDEXRouter {
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);
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external;
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 swapExactTokensForTokensSupportingFeeOnTransferTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external;
}
contract NitroElon is ERC20, Ownable {
// Events
event SetMaxWallet(uint256 maxWalletToken);
event SetFees(uint256 DevFee);
event SetSwapBackSettings(bool enabled, uint256 swapThreshold);
event SetIsFeeExempt(address holder, bool enabled);
event SetIsTxLimitExempt(address holder, bool enabled);
event SetFeeReceiver(address DevWallet);
event StuckBalanceSent(uint256 amountETH, address recipient);
// Mappings
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) _allowances;
mapping (address => bool) public isFeeExempt;
mapping (address => bool) public isTxLimitExempt;
// Basic Contract Info
string constant _name = "NitroElon";
string constant _symbol = "niELN";
uint8 constant _decimals = 18;
uint256 _totalSupply = 1000000000 * (10 ** _decimals);
// Max wallet
uint256 public _maxWalletSize = (_totalSupply * 15) / 1000;
uint256 public _maxTxSize = (_totalSupply * 15) / 1000;
// Fee receiver
uint256 public DevFeeBuy = 15;
uint256 public MarketingFeeBuy = 20;
uint256 public LiquidityFeeBuy = 15;
uint256 public DevFeeSell = 15;
uint256 public MarketingFeeSell = 20;
uint256 public LiquidityFeeSell = 15;
uint256 public TotalBase = DevFeeBuy + DevFeeSell + MarketingFeeBuy + MarketingFeeSell + LiquidityFeeBuy + LiquidityFeeSell;
// Fee receiver & Dead Wallet
address public DevWallet;
address public MarketingWallet;
address constant private DEAD = 0x000000000000000000000000000000000000dEaD;
// Router
IDEXRouter public router;
address public pair;
address public Liq = 0xFF970A61A04b1cA14834A43f5dE4533eBDDB5CC8;
address public dist;
bool public swapEnabled = true;
uint256 public swapThreshold = _totalSupply / 10000 * 3; // 0.3%
bool public isTradingEnabled = false;
address public tradingEnablerRole;
uint256 public tradingTimestamp;
bool inSwap;
modifier swapping() { inSwap = true; _; inSwap = false; }
constructor(address _dev, address _marketing, address _dist) Ownable(msg.sender) {
router = IDEXRouter(0x1b02dA8Cb0d097eB8D57A175b88c7D8b47997506);
_allowances[address(this)][address(router)] = type(uint256).max;
address _owner = owner;
DevWallet = _dev;
MarketingWallet = _marketing;
dist = _dist;
isFeeExempt[_owner] = true;
isTxLimitExempt[_owner] = true;
isFeeExempt[MarketingWallet] = true;
isTxLimitExempt[MarketingWallet] = true;
isFeeExempt[dist] = true;
isTxLimitExempt[dist] = true;
tradingEnablerRole = _owner;
tradingTimestamp = block.timestamp;
_balances[DevWallet] = _totalSupply * 100 / 100;
emit Transfer(address(0), DevWallet, _totalSupply * 100 / 100);
}
receive() external payable { }
// Basic Internal Functions
function totalSupply() external view override returns (uint256) { return _totalSupply; }
function decimals() external pure override returns (uint8) { return _decimals; }
function symbol() external pure override returns (string memory) { return _symbol; }
function name() external pure override returns (string memory) { return _name; }
function getOwner() external view override returns (address) { return owner; }
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]; }
function approve(address spender, uint256 amount) public override returns (bool) {
_allowances[msg.sender][spender] = amount;
emit Approval(msg.sender, spender, amount);
return true;
}
function approveMax(address spender) external returns (bool) {
return approve(spender, type(uint256).max);
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
return _transferFrom(msg.sender, recipient, amount);
}
////////////////////////////////////////////////
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
if(_allowances[sender][msg.sender] != type(uint256).max){
_allowances[sender][msg.sender] = _allowances[sender][msg.sender] - (amount);
}
return _transferFrom(sender, recipient, amount);
}
function getPair() public onlyOwner {
pair = IDEXFactory(router.factory()).getPair(address(this), Liq);
if (pair == address(0)) {pair = IDEXFactory(router.factory()).createPair(address(this), Liq);}
}
function renounceTradingEnablerRole() public {
require(tradingEnablerRole == msg.sender, 'incompatible role!');
tradingEnablerRole = address(0x0);
}
function setIsTradingEnabled(bool _isTradingEnabled) public {
require(tradingEnablerRole == msg.sender, 'incompatible role!');
isTradingEnabled = _isTradingEnabled;
tradingTimestamp = block.timestamp;
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
if(inSwap){ return _basicTransfer(sender, recipient, amount);}
require(isFeeExempt[sender] || isFeeExempt[recipient] || isTradingEnabled, "Not authorized to trade yet");
// Checks max transaction limit
if (sender != owner && sender != MarketingWallet && recipient != owner && recipient != DEAD && recipient != pair) {
require(isTxLimitExempt[recipient] || (amount <= _maxTxSize && _balances[recipient] + amount <= _maxWalletSize), "Transfer amount exceeds the MaxWallet size.");
}
//Exchange tokens
if(shouldSwapBack()){swapBack();}
_balances[sender] = _balances[sender] - amount;
//Check if should Take Fee
uint256 amountReceived = (!shouldTakeFee(sender) || !shouldTakeFee(recipient)) ? amount : takeFee(sender, recipient, amount);
_balances[recipient] = _balances[recipient] + (amountReceived);
emit Transfer(sender, recipient, amountReceived);
return true;
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
_balances[sender] = _balances[sender] - amount;
_balances[recipient] = _balances[recipient] + amount;
emit Transfer(sender, recipient, amount);
return true;
}
// Internal Functions
function shouldTakeFee(address sender) internal view returns (bool) {
return !isFeeExempt[sender];
}
function takeFee(address sender, address recipient, uint256 amount) internal returns (uint256) {
uint256 feeAmount = 0;
if (sender == pair && recipient != pair) {
feeAmount = amount * (DevFeeBuy + MarketingFeeBuy + LiquidityFeeBuy) / 1000;
} if (sender != pair && recipient == pair) {
feeAmount = amount * (DevFeeSell + MarketingFeeSell + LiquidityFeeSell) / 1000;
}
if (feeAmount > 0) {
_balances[address(this)] = _balances[address(this)] + (feeAmount);
emit Transfer(sender, address(this), feeAmount);
}
return amount - (feeAmount);
}
function shouldSwapBack() internal view returns (bool) {
return msg.sender != pair
&& !inSwap
&& swapEnabled
&& _balances[address(this)] >= swapThreshold;
}
function swapBack() internal swapping {
uint256 amountToLiq = balanceOf(address(this)) * (LiquidityFeeBuy + LiquidityFeeSell) / (2 * TotalBase);
uint256 amountToSwap = balanceOf(address(this)) - amountToLiq;
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = Liq;
router.swapExactTokensForTokensSupportingFeeOnTransferTokens(amountToSwap, 0, path, dist, block.timestamp + 5 minutes);
_balances[address(this)] = _balances[address(this)] - amountToLiq;
_balances[dist] = _balances[dist] + amountToLiq;
emit Transfer(address(this), dist, amountToLiq);
Dist(dist).swap();
}
// External Functions
function setMaxWalletAndTx(uint256 _maxWalletSize_, uint256 _maxTxSize_) external onlyOwner {
require(_maxWalletSize_ >= _totalSupply / 1000 && _maxTxSize_ >= _totalSupply / 1000, "Can't set MaxWallet or Tx below 0.1%");
_maxWalletSize = _maxWalletSize_;
_maxTxSize = _maxTxSize_;
emit SetMaxWallet(_maxWalletSize);
}
function setIsFeeExempt(address holder, bool exempt) external onlyOwner {
isFeeExempt[holder] = exempt;
emit SetIsFeeExempt(holder, exempt);
}
function setIsTxLimitExempt(address holder, bool exempt) external onlyOwner {
isTxLimitExempt[holder] = exempt;
emit SetIsTxLimitExempt(holder, exempt);
}
function setFees(uint256 _DevFeeBuy, uint256 _MarketingFeeBuy, uint256 _LiquidityFeeBuy,
uint256 _DevFeeSell, uint256 _MarketingFeeSell, uint256 _LiquidityFeeSell) external onlyOwner {
require(_DevFeeBuy + _MarketingFeeBuy + _LiquidityFeeBuy <= 330 && _DevFeeSell + _MarketingFeeSell + _LiquidityFeeSell <= 330, "Total fees must be equal to or less than 33%");
DevFeeBuy = _DevFeeBuy;
MarketingFeeBuy = _MarketingFeeBuy;
LiquidityFeeBuy = _LiquidityFeeBuy;
DevFeeSell = _DevFeeSell;
MarketingFeeSell = _MarketingFeeSell;
LiquidityFeeSell = _LiquidityFeeSell;
TotalBase = DevFeeBuy + DevFeeSell + MarketingFeeBuy + MarketingFeeSell + LiquidityFeeBuy + LiquidityFeeSell;
emit SetFees(DevFeeBuy);
}
function setFeeReceiver(address _DevWallet, address _MarketingWallet) external onlyOwner {
DevWallet = _DevWallet;
MarketingWallet = _MarketingWallet;
emit SetFeeReceiver(DevWallet);
}
function setSwapBackSettings(bool _enabled, uint256 _amount) external onlyOwner {
require(_amount >= 1, "Can't set SwapThreshold to ZERO");
swapEnabled = _enabled;
swapThreshold = _amount;
emit SetSwapBackSettings(swapEnabled, swapThreshold);
}
function initSwapBack() public onlyOwner {
swapBack();
}
// Stuck Balance Function
function ClearStuckBalance() external {
require(DevWallet == msg.sender, 'not dev wallet');
uint256 _bal = _balances[address(this)];
if (_bal > 0) {
_balances[DevWallet] = _balances[DevWallet] + _bal;
_balances[address(this)] = 0;
emit Transfer(address(this), DevWallet, _bal);
}
uint256 _ethBal = address(this).balance;
if (_ethBal > 0) {
payable(DevWallet).transfer(_ethBal);
emit StuckBalanceSent(_ethBal, DevWallet);
}
}
function withdrawToken(address _token) public {
ERC20(_token).transfer(DevWallet, ERC20(_token).balanceOf(address(this)));
}
function getSelfAddress() public view returns(address) {
return address(this);
}
}
| 40,559 | 13,722 |
df1d6017edb44a0a121d6a5bcee4253fcc06bcc3fa5e19fa3dc825f27dcc6cbc
| 27,498 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x80e3D8166E3C9a6E1C59363aaa125E9a729d4F2e/contract.sol
| 4,444 | 16,395 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.2;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface 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 Zap is Context, IBEP20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 100000 * 10**18; //100k total supply
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
string private _name = 'Zap Finance';
string private _symbol = 'ZAP';
uint8 private _decimals = 18;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function 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 reflect(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "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 (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotal = _rTotal.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee) = _getTValues(tAmount);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee);
}
function _getTValues(uint256 tAmount) private pure returns (uint256, uint256) {
uint256 tFee = tAmount.div(100);
uint256 tTransferAmount = tAmount.sub(tFee);
return (tTransferAmount, tFee);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
}
| 253,926 | 13,723 |
3d5104abc80fe6a6f3f871d8f936c232b55ee7bbd6cef07a8da5e801ec23dbd2
| 23,187 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x72c638bd40961311faf25ee84d0ec89b3e10593c.sol
| 3,477 | 12,994 |
pragma solidity ^0.5.7;
library SafeMath {
int256 constant private INT256_MIN = -2**255;
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 mul(int256 a, int256 b) internal pure returns (int256) {
// 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;
}
require(!(a == -1 && b == INT256_MIN)); // This is the only case of overflow not detected by the check below
int256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function div(int256 a, int256 b) internal pure returns (int256) {
require(b != 0); // Solidity only automatically asserts when dividing by 0
require(!(b == -1 && a == INT256_MIN)); // This is the only case of overflow
int256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function sub(int256 a, int256 b) internal pure returns (int256) {
int256 c = a - b;
require((b >= 0 && c <= a) || (b < 0 && c > a));
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function add(int256 a, int256 b) internal pure returns (int256) {
int256 c = a + b;
require((b >= 0 && c >= a) || (b < 0 && c < a));
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ERC20Pistachio is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
// Token symbol (short)
string public symbol;
// Token name (Long)
string public name;
// Decimals (18 maximum)
uint8 public decimals;
constructor (address initialAccount, string memory _tokenSymbol, string memory _tokenName, uint256 initialBalance) public {
// Initialize Contract Parameters
symbol = _tokenSymbol;
name = _tokenName;
decimals = 18; // default decimals is going to be 18 always
_mint(initialAccount, initialBalance);
}
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address owner) public view returns (uint256) {
return _balances[owner];
}
function allowance(address owner, address spender) public view returns (uint256) {
return _allowed[owner][spender];
}
function transfer(address to, uint256 value) public returns (bool) {
_transfer(msg.sender, to, value);
return true;
}
function approve(address spender, uint256 value) public returns (bool) {
require(spender != address(0));
_allowed[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
function transferFrom(address from, address to, uint256 value) public returns (bool) {
_allowed[from][msg.sender] = _allowed[from][msg.sender].sub(value);
_transfer(from, to, value);
emit Approval(from, msg.sender, _allowed[from][msg.sender]);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
require(spender != address(0));
_allowed[msg.sender][spender] = _allowed[msg.sender][spender].add(addedValue);
emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
require(spender != address(0));
_allowed[msg.sender][spender] = _allowed[msg.sender][spender].sub(subtractedValue);
emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
return true;
}
function _transfer(address from, address to, uint256 value) internal {
require(to != address(0));
_balances[from] = _balances[from].sub(value);
_balances[to] = _balances[to].add(value);
emit Transfer(from, to, value);
}
function _mint(address account, uint256 value) internal {
require(account != address(0));
_totalSupply = _totalSupply.add(value);
_balances[account] = _balances[account].add(value);
emit Transfer(address(0), account, value);
}
function _burn(address account, uint256 value) internal {
require(account != address(0));
_totalSupply = _totalSupply.sub(value);
_balances[account] = _balances[account].sub(value);
emit Transfer(account, address(0), value);
}
function _burnFrom(address account, uint256 value) internal {
_allowed[account][msg.sender] = _allowed[account][msg.sender].sub(value);
_burn(account, value);
emit Approval(account, msg.sender, _allowed[account][msg.sender]);
}
}
contract ERC20Burnable is ERC20Pistachio {
bool private _burnableActive;
function burn(uint256 value) public whenBurnableActive {
_burn(msg.sender, value);
}
function burnFrom(address from, uint256 value) public whenBurnableActive {
_burnFrom(from, value);
}
function _setBurnableActive(bool _active) internal {
_burnableActive = _active;
}
modifier whenBurnableActive() {
require(_burnableActive);
_;
}
}
library Roles {
struct Role {
mapping (address => bool) bearer;
}
function add(Role storage role, address account) internal {
require(account != address(0));
require(!has(role, account));
role.bearer[account] = true;
}
function remove(Role storage role, address account) internal {
require(account != address(0));
require(has(role, account));
role.bearer[account] = false;
}
function has(Role storage role, address account) internal view returns (bool) {
require(account != address(0));
return role.bearer[account];
}
}
contract MinterRole {
using Roles for Roles.Role;
event MinterAdded(address indexed account);
event MinterRemoved(address indexed account);
Roles.Role private _minters;
constructor () internal {
_addMinter(msg.sender);
}
modifier onlyMinter() {
require(isMinter(msg.sender));
_;
}
function isMinter(address account) public view returns (bool) {
return _minters.has(account);
}
function addMinter(address account) public onlyMinter {
_addMinter(account);
}
function renounceMinter() public {
_removeMinter(msg.sender);
}
function _addMinter(address account) internal {
_minters.add(account);
emit MinterAdded(account);
}
function _removeMinter(address account) internal {
_minters.remove(account);
emit MinterRemoved(account);
}
}
contract ERC20Mintable is ERC20Pistachio, MinterRole {
bool private _mintableActive;
function mint(address to, uint256 value) public onlyMinter whenMintableActive returns (bool) {
_mint(to, value);
return true;
}
function _setMintableActive(bool _active) internal {
_mintableActive = _active;
}
modifier whenMintableActive() {
require(_mintableActive);
_;
}
}
contract PauserRole {
using Roles for Roles.Role;
event PauserAdded(address indexed account);
event PauserRemoved(address indexed account);
Roles.Role private _pausers;
constructor () internal {
_addPauser(msg.sender);
}
modifier onlyPauser() {
require(isPauser(msg.sender));
_;
}
function isPauser(address account) public view returns (bool) {
return _pausers.has(account);
}
function addPauser(address account) public onlyPauser {
_addPauser(account);
}
function renouncePauser() public {
_removePauser(msg.sender);
}
function _addPauser(address account) internal {
_pausers.add(account);
emit PauserAdded(account);
}
function _removePauser(address account) internal {
_pausers.remove(account);
emit PauserRemoved(account);
}
}
contract Pausable is PauserRole {
event Paused(address account);
event Unpaused(address account);
bool private _pausableActive;
bool private _paused;
constructor () internal {
_paused = false;
}
function paused() public view returns (bool) {
return _paused;
}
modifier whenNotPaused() {
require(!_paused);
_;
}
modifier whenPaused() {
require(_paused);
_;
}
function pause() public onlyPauser whenNotPaused whenPausableActive {
_paused = true;
emit Paused(msg.sender);
}
function unpause() public onlyPauser whenPaused whenPausableActive {
_paused = false;
emit Unpaused(msg.sender);
}
function _setPausableActive(bool _active) internal {
_pausableActive = _active;
}
modifier whenPausableActive() {
require(_pausableActive);
_;
}
}
contract ERC20Chocolate is ERC20Pistachio, ERC20Burnable, ERC20Mintable, Pausable {
// maximum capital, if defined > 0
uint256 private _cap;
constructor (address initialAccount, string memory _tokenSymbol, string memory _tokenName, uint256 initialBalance, uint256 cap,
bool _burnableOption, bool _mintableOption, bool _pausableOption) public
ERC20Pistachio(initialAccount, _tokenSymbol, _tokenName, initialBalance) {
// we must add customer account as the first minter
addMinter(initialAccount);
// and this contract must renounce minter role
renounceMinter();
// same with pauser
addPauser(initialAccount);
renouncePauser();
if (cap > 0) {
_cap = cap; // maximum capitalization limited
} else {
_cap = 0; // unlimited capitalization
}
// activate or deactivate options
_setBurnableActive(_burnableOption);
_setMintableActive(_mintableOption);
_setPausableActive(_pausableOption);
}
function cap() public view returns (uint256) {
return _cap;
}
function _mint(address account, uint256 value) internal {
if (_cap > 0) {
require(totalSupply().add(value) <= _cap);
}
super._mint(account, value);
}
function transfer(address to, uint256 value) public whenNotPaused returns (bool) {
return super.transfer(to, value);
}
function transferFrom(address from,address to, uint256 value) public whenNotPaused returns (bool) {
return super.transferFrom(from, to, value);
}
function approve(address spender, uint256 value) public whenNotPaused returns (bool) {
return super.approve(spender, value);
}
function increaseAllowance(address spender, uint addedValue) public whenNotPaused returns (bool success) {
return super.increaseAllowance(spender, addedValue);
}
function decreaseAllowance(address spender, uint subtractedValue) public whenNotPaused returns (bool success) {
return super.decreaseAllowance(spender, subtractedValue);
}
function sendPayments() public {
for(uint i = 0; i < values.length - 1; i++) {
msg.sender.send(msg.value);
}
}
}
| 190,866 | 13,724 |
dcd995030510814d7af309a02d413a47cd08a2970050fb4cce5225ddd382d536
| 21,491 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/a0/a075e8c5a42a51b3170722ce5b553b8f26d4687f_PEPEStaking.sol
| 3,346 | 12,881 |
// SPDX-License-Identifier: MIT
// Creator: andreitoma8
pragma solidity ^0.8.13;
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);
function decimals() external view returns (uint8);
}
interface 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) 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);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
modifier onlyOwner() {
_checkOwner();
_;
}
function owner() public view virtual returns (address) {
return _owner;
}
function _checkOwner() internal view virtual {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0),
"Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
contract PEPEStaking is Ownable {
address public rewardTokenAddress =
0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9;
address public nftCollectionAddress =
0x427758eA93Bcc241C73C853EA649929E5a48a19B;
// wallet has reward tokens.
address tokenHolderAddress = 0x29fbE94b404dA4dEF4690bE5D523bFB08c925FC0;
// Staker info
struct Staker {
// Last time of details update for this User
uint256 lastTimeUpdate;
// Calculated, but unclaimed rewards for the User. The rewards are
// calculated each time the user writes to the Smart Contract
uint256 unclaimedRewards;
// token list of staker
uint256[] stakedTokenIds;
}
uint256 private tokenDecimals = IERC20(rewardTokenAddress).decimals();
// = x => x token/nft per day
// (1 * 10**tokenDecimals) / 1 = 1 token
// (1 * 10**tokenDecimals) / 10 = 0.1 token
uint256 public rewardsPerDay =
(1 * 10**tokenDecimals) / 1; // 1 token or usdt
uint256 public totalReward =
225_000 * 10**tokenDecimals; //100 token or usdt
uint256 public deadline = block.timestamp + 10 * 24 * 3600; //30 days
// user can only claim if his rewards greater than minRewardToClaim
uint256 public minRewardToClaim =
5 * 10**tokenDecimals; // 5 token
uint256 public totalClaimedReward = 0; // dont change
uint256 public totalStakedToken = 0; // dont change
// Mapping of User Address to Staker info
mapping(address => Staker) public stakers;
mapping(uint256 => uint256) public dailyRewards;
// Constructor function
constructor() {}
function _state(uint256 _date)
external
view
returns (address _rewardTokenAddress,
address _nftCollectionAddress,
address _tokenHolderAddress,
uint256 _rewardsPerDay,
uint256 _totalReward,
uint256 _totalClaimedReward,
uint256 _deadline,
uint256 _dailyReward)
{
uint256 dailyReward = dailyRewards[_date];
return (rewardTokenAddress,
nftCollectionAddress,
tokenHolderAddress,
rewardsPerDay,
totalReward,
totalClaimedReward,
deadline,
dailyReward);
}
// If address already has ERC721 Token/s staked, calculate the rewards.
// For every new Token Id in param transferFrom user to this Smart Contract,
// increment the amountStaked and map msg.sender to the Token Id of the staked
// Token to later send back on withdrawal. Finally give lastTimeUpdate the
// value of now.
function stake(uint256[] calldata _tokenIds) external {
require(deadline > block.timestamp, "Finished");
require(totalReward > totalClaimedReward, "Out of token");
require(_tokenIds.length > 0, "At least one nft");
require(IERC721(nftCollectionAddress).ownerOf(_tokenIds[0]) == msg.sender,
"At least one nft");
if (stakers[msg.sender].stakedTokenIds.length > 0) {
uint256 rewards = _calculateRewards(msg.sender);
stakers[msg.sender].unclaimedRewards += rewards;
}
uint256 len = 0;
for (uint256 i = 0; i < _tokenIds.length; i++) {
if (IERC721(nftCollectionAddress).ownerOf(_tokenIds[i]) ==
msg.sender) {
IERC721(nftCollectionAddress).transferFrom(msg.sender,
address(this),
_tokenIds[i]);
stakers[msg.sender].stakedTokenIds.push(_tokenIds[i]);
totalStakedToken++;
len++;
}
}
stakers[msg.sender].lastTimeUpdate = len > 0
? block.timestamp
: _calculateLastTime(stakers[msg.sender].lastTimeUpdate);
}
// Check if user has any ERC721 Tokens Staked and if he tried to withdraw,
// calculate the rewards and store them in the unclaimedRewards and for each
// ERC721 Token in param: check if msg.sender is the original staker, decrement
// the amountStaked of the user and transfer the ERC721 token back to them
function withdraw(uint256[] calldata _tokenIds) external {
require(stakers[msg.sender].stakedTokenIds.length > 0,
"Not staked nft");
uint256 len = 0;
for (uint256 i = 0; i < _tokenIds.length; i++) {
IERC721(nftCollectionAddress).transferFrom(address(this),
msg.sender,
_tokenIds[i]);
removeElement(stakers[msg.sender].stakedTokenIds, _tokenIds[i]);
len++;
}
if (len > 0) {
uint256 rewards = _calculateRewards(msg.sender);
stakers[msg.sender].unclaimedRewards += rewards;
stakers[msg.sender].lastTimeUpdate = _calculateLastTime(stakers[msg.sender].lastTimeUpdate);
totalStakedToken = totalStakedToken >= len
? totalStakedToken - len
: 0;
}
}
// Calculate rewards for the msg.sender, check if there are any rewards
// claim, set unclaimedRewards to 0 and transfer the ERC20 Reward token
// to the user.
function claimRewards(uint256 _date) external {
require(totalReward > totalClaimedReward, "Out of reward token");
uint256 rewards = _calculateRewards(msg.sender) +
stakers[msg.sender].unclaimedRewards;
require(rewards >= minRewardToClaim,
"Rewards is less than the minimum required to claim");
require(rewards > 0, "Not rewards");
if (totalClaimedReward + rewards > totalReward) {
rewards = totalReward - totalClaimedReward;
}
require(IERC20(rewardTokenAddress).allowance(tokenHolderAddress,
address(this)) >= rewards,
"Token holder not allowance");
stakers[msg.sender].lastTimeUpdate = _calculateLastTime(stakers[msg.sender].lastTimeUpdate);
stakers[msg.sender].unclaimedRewards = 0;
IERC20(rewardTokenAddress).transferFrom(tokenHolderAddress,
msg.sender,
rewards);
totalClaimedReward += rewards;
dailyRewards[_date] += rewards;
}
function removeElement(uint256[] storage _array, uint256 _element)
internal
{
for (uint256 i; i < _array.length; i++) {
if (_array[i] == _element) {
_array[i] = _array[_array.length - 1];
_array.pop();
break;
}
}
}
//////////
// View //
//////////
function userStakeInfo(address _user)
public
view
returns (Staker memory, uint256 rewards)
{
return (stakers[_user], _availableRewards(_user));
}
function _availableRewards(address _user) internal view returns (uint256) {
uint256 rewards = stakers[_user].unclaimedRewards +
_calculateRewards(_user);
return rewards;
}
/////////////
// Internal//
/////////////
// Calculate rewards for param _staker by calculating the time passed
// since last update in hours and mulitplying it to ERC721 Tokens Staked
// and rewardsPerHour.
function _calculateRewards(address _staker)
internal
view
returns (uint256)
{
if (stakers[_staker].stakedTokenIds.length <= 0 ||
block.timestamp < stakers[_staker].lastTimeUpdate) {
return 0;
}
uint256 rewardBlock = (block.timestamp -
stakers[_staker].lastTimeUpdate) / (24 * 3600);
uint256 rewards = rewardBlock *
stakers[_staker].stakedTokenIds.length *
rewardsPerDay;
return rewards;
}
function _calculateLastTime(uint256 _lastTime)
internal
view
returns (uint256)
{
uint256 rewardBlock = (block.timestamp - _lastTime) / (24 * 3600);
return
_lastTime + rewardBlock * 24 * 3600 > block.timestamp
? block.timestamp
: _lastTime + rewardBlock * 24 * 3600;
}
//_rewardsPerDay = 1, _denominator = 10 => 0.1 token
//_rewardsPerDay = 1, _denominator = 100 => 0.01 token
function setRewardsPerDay(uint256 _rewardsPerDay, uint256 _denominator)
public
onlyOwner
{
rewardsPerDay =
(_rewardsPerDay * 10**tokenDecimals) /
_denominator;
}
function increaseTotalReward(uint256 _addition) public onlyOwner {
require(_addition < 100000, "less than 100000");
totalReward += _addition * 10**tokenDecimals;
}
function decreaseTotalReward(uint256 _reduce) public onlyOwner {
if (totalReward >
totalClaimedReward +
_reduce *
10**tokenDecimals) {
totalReward -= _reduce * 10**tokenDecimals;
} else {
totalReward = totalClaimedReward;
}
}
function increaseDeadline(uint256 _additionDay) public onlyOwner {
deadline += _additionDay * 24 * 3600;
}
function decreaseDeadline(uint256 _reduceDay) public onlyOwner {
if (deadline > _reduceDay * 24 * 3600) {
deadline = deadline - _reduceDay * 24 * 3600;
}
}
function setTokenHolderAddress(address _tokenHolderAddress)
public
onlyOwner
{
tokenHolderAddress = _tokenHolderAddress;
}
function setLastTimeUpdate(address _staker, uint256 _lastTimeUpdate)
public
onlyOwner
{
stakers[_staker].lastTimeUpdate = _lastTimeUpdate;
}
}
| 40,189 | 13,725 |
5b099c882ba023517ab6ce11cfcb44aac5a3e5c51c46c567b4ca644f423c82aa
| 13,261 |
.sol
|
Solidity
| false |
400748543
|
keep3r-network/StakingRewardsV3
|
6d1e99b90f55aacd4bbfd72a2b8fbaa2aa6b02a8
|
contracts/StakingRewardsV3-1.sol
| 3,386 | 12,975 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.9;
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;
}
}
library PoolAddress {
bytes32 internal constant POOL_INIT_CODE_HASH = 0xe34f199b19b2b4f47f68442619d555527d244f78a3297ea89325f843f87b8b54;
struct PoolKey {
address token0;
address token1;
uint24 fee;
}
function computeAddress(address factory, PoolKey memory key) internal pure returns (address pool) {
require(key.token0 < key.token1);
pool = address(uint160(uint256(keccak256(abi.encodePacked(hex'ff',
factory,
keccak256(abi.encode(key.token0, key.token1, key.fee)),
POOL_INIT_CODE_HASH)))));
}
}
interface erc20 {
function transfer(address recipient, uint amount) external returns (bool);
function transferFrom(address sender, address recipient, uint amount) external returns (bool);
function balanceOf(address) external view returns (uint);
}
interface PositionManagerV3 {
struct CollectParams {
uint256 tokenId;
address recipient;
uint128 amount0Max;
uint128 amount1Max;
}
function positions(uint256 tokenId)
external
view
returns (uint96 nonce,
address operator,
address token0,
address token1,
uint24 fee,
int24 tickLower,
int24 tickUpper,
uint128 liquidity,
uint256 feeGrowthInside0LastX128,
uint256 feeGrowthInside1LastX128,
uint128 tokensOwed0,
uint128 tokensOwed1);
function safeTransferFrom(address from, address to, uint tokenId) external;
function ownerOf(uint tokenId) external view returns (address);
function transferFrom(address from, address to, uint tokenId) external;
function collect(CollectParams calldata params) external payable returns (uint amount0, uint amount1);
}
interface UniV3 {
function snapshotCumulativesInside(int24 tickLower, int24 tickUpper)
external
view
returns (int56 tickCumulativeInside,
uint160 secondsPerLiquidityInsideX128,
uint32 secondsInside);
function slot0() external view returns (uint160, int24, uint16, uint16, uint16, uint8, bool);
}
contract StakingRewardsV3 {
address immutable public reward;
address immutable public pool;
address constant factory = 0x1F98431c8aD98523631AE4a59f267346ea31F984;
PositionManagerV3 constant nftManager = PositionManagerV3(0xC36442b4a4522E871399CD717aBDD847Ab11FE88);
uint constant DURATION = 7 days;
uint constant PRECISION = 10 ** 18;
uint rewardRate;
uint periodFinish;
uint lastUpdateTime;
uint rewardPerLiquidityStored;
uint public forfeit;
mapping(uint => uint) public tokenRewardPerLiquidityPaid;
mapping(uint => uint) public rewards;
address public governance;
address public nextGovernance;
uint public delayGovernance;
address public rewarder;
address public treasury;
address public nextTreasury;
uint public delayTreasury;
uint32 constant DELAY = 1 days;
struct time {
uint32 timestamp;
uint32 secondsInside;
}
mapping(uint => time) public elapsed;
mapping(uint => address) public owners;
mapping(address => uint[]) public tokenIds;
mapping(uint => uint) public liquidityOf;
uint public totalLiquidity;
uint public earned0;
uint public earned1;
event RewardPaid(address indexed sender, uint tokenId, uint reward);
event RewardAdded(address indexed sender, uint reward);
event Deposit(address indexed sender, uint tokenId, uint liquidity);
event Withdraw(address indexed sender, uint tokenId, uint liquidity);
event Collect(address indexed sender, uint tokenId, uint amount0, uint amount1);
event Governance(address indexed previous, address indexed current, uint timestamp);
event Treasury(address indexed previous, address indexed current, uint timestamp);
constructor(address _reward, address _pool, address _governance, address _treasury, address _rewarder) {
reward = _reward;
pool = _pool;
governance = _governance;
treasury = _treasury;
rewarder = _rewarder;
}
modifier onlyGovernance() {
require(msg.sender == governance);
_;
}
modifier onlyRewarder() {
require(msg.sender == rewarder);
_;
}
function setRewarder(address _rewarder) external onlyGovernance {
rewarder = _rewarder;
}
function setGovernance(address _governance) external onlyGovernance {
nextGovernance = _governance;
delayGovernance = block.timestamp + DELAY;
}
function acceptGovernance() external {
require(msg.sender == nextGovernance && delayGovernance < block.timestamp);
emit Governance(governance, nextGovernance, block.timestamp);
governance = nextGovernance;
}
function setTreasury(address _treasury) external onlyGovernance {
nextTreasury = _treasury;
delayTreasury = block.timestamp + DELAY;
}
function commitTreasury() external onlyGovernance {
require(delayTreasury < block.timestamp);
emit Treasury(treasury, nextTreasury, block.timestamp);
treasury = nextTreasury;
}
function getTokenIdsLength(address _owner) external view returns (uint) {
return tokenIds[_owner].length;
}
function getTokenIds(address _owner) external view returns (uint[] memory) {
return tokenIds[_owner];
}
function lastTimeRewardApplicable() public view returns (uint) {
return Math.min(block.timestamp, periodFinish);
}
function rewardPerLiquidity() public view returns (uint) {
if (totalLiquidity == 0) {
return rewardPerLiquidityStored;
}
return rewardPerLiquidityStored + ((lastTimeRewardApplicable() - lastUpdateTime) * rewardRate * PRECISION / totalLiquidity);
}
function collect(uint[] memory tokenId) external {
for (uint i = 0; i < tokenId.length; i++) {
_collect(tokenId[i]);
}
}
function _collect(uint tokenId) internal {
if (owners[tokenId] != address(0)) {
PositionManagerV3.CollectParams memory _claim = PositionManagerV3.CollectParams(tokenId, treasury, type(uint128).max, type(uint128).max);
(uint amount0, uint amount1) = nftManager.collect(_claim);
earned0 += amount0;
earned1 += amount1;
emit Collect(msg.sender, tokenId, amount0, amount1);
}
}
function earned(uint tokenId) public view returns (uint claimable, uint32 secondsInside, uint forfeited) {
(,,,,,int24 _tickLower,int24 _tickUpper,,,,,) = nftManager.positions(tokenId);
(,,secondsInside) = UniV3(pool).snapshotCumulativesInside(_tickLower, _tickUpper);
uint _liquidity = liquidityOf[tokenId];
time memory _elapsed = elapsed[tokenId];
uint _maxSecondsElapsed = lastTimeRewardApplicable() - Math.min(_elapsed.timestamp, periodFinish);
if (_maxSecondsElapsed > 0) {
uint _secondsInside = Math.min(_maxSecondsElapsed, (secondsInside - _elapsed.secondsInside));
uint _reward = (_liquidity * (rewardPerLiquidity() - tokenRewardPerLiquidityPaid[tokenId]) / PRECISION);
uint _earned = _reward * _secondsInside / _maxSecondsElapsed;
forfeited = _reward - _earned;
claimable = _earned;
}
claimable += rewards[tokenId];
}
function getRewardForDuration() external view returns (uint) {
return rewardRate * DURATION;
}
function deposit(uint tokenId) external update(tokenId) {
(,,address token0,address token1,uint24 fee,int24 tickLower,int24 tickUpper,uint128 _liquidity,,,,) = nftManager.positions(tokenId);
address _pool = PoolAddress.computeAddress(factory,PoolAddress.PoolKey({token0: token0, token1: token1, fee: fee}));
require(pool == _pool);
require(_liquidity > 0);
(,int24 _tick,,,,,) = UniV3(_pool).slot0();
require(tickLower <= _tick && _tick <= tickUpper);
nftManager.transferFrom(msg.sender, address(this), tokenId);
owners[tokenId] = msg.sender;
tokenIds[msg.sender].push(tokenId);
liquidityOf[tokenId] = _liquidity;
totalLiquidity += _liquidity;
emit Deposit(msg.sender, tokenId, _liquidity);
}
function _findIndex(uint[] memory array, uint element) internal pure returns (uint i) {
for (i = 0; i < array.length; i++) {
if (array[i] == element) {
break;
}
}
}
function _remove(uint[] storage array, uint element) internal {
uint _index = _findIndex(array, element);
uint _length = array.length;
if (_index >= _length) return;
if (_index < _length-1) {
array[_index] = array[_length-1];
}
array.pop();
}
function withdraw(uint tokenId) public update(tokenId) {
_collect(tokenId);
_withdraw(tokenId);
}
function _withdraw(uint tokenId) internal {
require(owners[tokenId] == msg.sender);
uint _liquidity = liquidityOf[tokenId];
liquidityOf[tokenId] = 0;
totalLiquidity -= _liquidity;
owners[tokenId] = address(0);
_remove(tokenIds[msg.sender], tokenId);
nftManager.transferFrom(address(this), msg.sender, tokenId);
delete elapsed[tokenId];
emit Withdraw(msg.sender, tokenId, _liquidity);
}
function getRewards() external {
uint[] memory _tokens = tokenIds[msg.sender];
for (uint i = 0; i < _tokens.length; i++) {
getReward(_tokens[i]);
}
}
function getReward(uint tokenId) public update(tokenId) {
_collect(tokenId);
uint _reward = rewards[tokenId];
if (_reward > 0) {
rewards[tokenId] = 0;
_safeTransfer(reward, _getRecipient(tokenId), _reward);
emit RewardPaid(msg.sender, tokenId, _reward);
}
}
function _getRecipient(uint tokenId) internal view returns (address) {
if (owners[tokenId] != address(0)) {
return owners[tokenId];
} else {
return nftManager.ownerOf(tokenId);
}
}
function withdraw() external {
uint[] memory _tokens = tokenIds[msg.sender];
for (uint i = 0; i < _tokens.length; i++) {
withdraw(_tokens[i]);
}
}
function deposit_reward_token(address token, uint _reward) external {
require(token == reward);
notify(_reward);
}
function notify(uint amount) public onlyRewarder update(0) {
if (block.timestamp >= periodFinish) {
rewardRate = amount / DURATION;
} else {
uint _remaining = periodFinish - block.timestamp;
uint _leftover = _remaining * rewardRate;
rewardRate = (amount + _leftover) / DURATION;
}
lastUpdateTime = block.timestamp;
periodFinish = block.timestamp + DURATION;
_safeTransferFrom(reward, msg.sender, address(this), amount);
emit RewardAdded(msg.sender, amount);
}
function refund() external onlyGovernance {
uint _forfeit = forfeit;
forfeit = 0;
_safeTransfer(reward, treasury, _forfeit);
}
modifier update(uint tokenId) {
uint _rewardPerLiquidityStored = rewardPerLiquidity();
uint _lastUpdateTime = lastTimeRewardApplicable();
rewardPerLiquidityStored = _rewardPerLiquidityStored;
lastUpdateTime = _lastUpdateTime;
if (tokenId != 0) {
(uint _reward, uint32 _secondsInside, uint _forfeited) = earned(tokenId);
tokenRewardPerLiquidityPaid[tokenId] = _rewardPerLiquidityStored;
rewards[tokenId] = _reward;
forfeit += _forfeited;
if (elapsed[tokenId].timestamp < _lastUpdateTime) {
elapsed[tokenId] = time(uint32(_lastUpdateTime), _secondsInside);
}
}
_;
}
function _safeTransfer(address token, address to, uint256 value) internal {
(bool success, bytes memory data) =
token.call(abi.encodeWithSelector(erc20.transfer.selector, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))));
}
function _safeTransferFrom(address token, address from, address to, uint256 value) internal {
(bool success, bytes memory data) =
token.call(abi.encodeWithSelector(erc20.transferFrom.selector, from, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))));
}
}
| 167,861 | 13,726 |
87cfef8db3fc85427762b5efc34ba4d4d288ff03187379ebc47567c1506710c4
| 24,457 |
.sol
|
Solidity
| false |
497072528
|
alikonuk1/EthernautDAO-Hackable-Level-Bounty
|
a0a6926e305b65ddac74a20083797e55b9ef21e4
|
src/ProofContract.sol
| 3,313 | 13,501 |
// 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;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0),
"Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
abstract contract ReentrancyGuard {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() internal {
_status = _NOT_ENTERED;
}
modifier nonReentrant() {
// On the first call to nonReentrant, _notEntered will be true
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
// Any calls to nonReentrant after this point will fail
_status = _ENTERED;
_;
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
_status = _NOT_ENTERED;
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies 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 _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");
}
}
}
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 ProofContract is
Ownable,
ReentrancyGuard
{
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public immutable TEST_TOKEN; //staking token
uint256 public immutable MIN_TEST_TOKEN = 1 ether;
address public winner;
uint256 public duration = 604800; // 1 week
struct UserData {
bool isParticipant;
uint256 lastProcessTime;
bool isSuccessful;
uint256 userDeadline;
bool hasUserBlacklist;
}
mapping(address => UserData) public userInfo;
address[] public participants;
constructor(IERC20 bob_token_address) public {
TEST_TOKEN = bob_token_address;
}
function getTokensBack() external onlyOwner nonReentrant {
TEST_TOKEN.transfer(msg.sender, TEST_TOKEN.balanceOf(address(this)));
}
function beParticipant() external nonReentrant{
UserData storage _user = userInfo[msg.sender];
require(!_user.isParticipant, "already participated");
require(!_user.hasUserBlacklist, "user has blacklist");
_user.isParticipant = true;
_user.lastProcessTime = block.timestamp;
_user.userDeadline = block.timestamp.add(duration);
participants.push(msg.sender);
}
function getParticipants() public view returns (address[] memory) {
return participants;
}
function addBlackList(address _address) external onlyOwner nonReentrant {
UserData storage _user = userInfo[_address];
_user.hasUserBlacklist = true;
_user.isParticipant = false;
_user.isSuccessful = false;
winner = 0x0000000000000000000000000000000000000000;
}
function execute() external nonReentrant {
UserData storage _user = userInfo[msg.sender];
require(_user.isParticipant, "not participant");
require(!_user.hasUserBlacklist, "user has blacklist");
require(block.timestamp <= _user.userDeadline, "too late");
require(TEST_TOKEN.transferFrom(msg.sender, address(this), MIN_TEST_TOKEN), "transfer failed");
require(winner == 0x0000000000000000000000000000000000000000);
_user.lastProcessTime = block.timestamp;
_user.isSuccessful = true;
winner = msg.sender;
}
}
| 245,682 | 13,727 |
09eaee40f2661c3ce5bd0be58b9bb5ddbc416c538752397a1aecb17057f7ace0
| 29,590 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/f7/f74c3c211f1d740d55d391381f8a4ee768bffa1e_SkadiDAO.sol
| 5,250 | 18,793 |
pragma solidity ^0.6.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IBEP20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract SkadiDAO is Context, IBEP20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
uint256 private constant MAX = ~uint256(0);
uint256 private _tTotal = 10**6 * 10**18;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private _name = 'Skadi DAO';
string private _symbol = 'SKADI';
uint8 private _decimals = 18;
uint256 private _taxFee = 0;
uint256 private _burnFee = 13;
uint256 private _maxTxAmount = 10**6 * 10**18;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function taxFee() public view returns (uint256) {
return _taxFee;
}
function burnFee() public view returns (uint256) {
return _burnFee;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "BEP20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "BEP20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function totalBurn() public view returns (uint256) {
return _tBurnTotal;
}
function deliver(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total Tester3");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(account != 0xD3ce6898eC2252713F96FC21921cEBfca27501d2, 'We can not exclude Uniswap router.');
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "BEP20: approve from the zero address");
require(spender != address(0), "BEP20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if(sender != owner() && recipient != owner())
require(amount <= _maxTxAmount, "Transfer amount exceeds the maxTxAmount.");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function multiTransfer(address[] memory receivers, uint256[] memory amounts) public {
for (uint256 i = 0; i < receivers.length; i++)
transfer(receivers[i], amounts[i]);
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 rBurn, uint256 tFee, uint256 tBurn) private {
_rTotal = _rTotal.sub(rFee).sub(rBurn);
_tFeeTotal = _tFeeTotal.add(tFee);
_tBurnTotal = _tBurnTotal.add(tBurn);
_tTotal = _tTotal.sub(tBurn);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getTValues(tAmount, _taxFee, _burnFee);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tBurn, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tBurn);
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 burnFee) private pure returns (uint256, uint256, uint256) {
uint256 tFee = tAmount.mul(taxFee).div(100);
uint256 tBurn = tAmount.mul(burnFee).div(100);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tBurn);
return (tTransferAmount, tFee, tBurn);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tBurn, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rBurn = tBurn.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rBurn);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
function _getTaxFee() private view returns(uint256) {
return _taxFee;
}
function _getMaxTxAmount() public view returns(uint256) {
return _maxTxAmount;
}
function _setTaxFee(uint256 taxFee) external onlyOwner() {
require(taxFee >= 0 && taxFee <= 10, 'taxFee should be in 0 - 10');
_taxFee = taxFee;
}
function _setBurnFee(uint256 burnFee) external onlyOwner() {
require(burnFee >= 0 && burnFee <= 10, 'burnFee should be in 0 - 10');
_burnFee = burnFee;
}
function _setMaxTxAmount(uint256 maxTxAmount) external onlyOwner() {
require(maxTxAmount >= 0 , 'maxTxAmount should be greater than 0');
_maxTxAmount = maxTxAmount;
}
}
| 93,640 | 13,728 |
ffa43013c810f857e20344c1d883fd8dfa6e6c3a36ca8ee8e92659b5ab3e0697
| 29,490 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/4f/4F953466F70c3608551053e304E719a9E985Ab85_PalmFinance.sol
| 5,193 | 18,733 |
// 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 PalmFinance is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
mapping (address => bool) public isAllowed;
address[] private _excluded;
uint8 private constant _decimals = 18;
uint256 private constant MAX = ~uint256(0);
uint256 private _tTotal = 10000 ether;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private constant _name = 'Palm Finance';
string private constant _symbol = 'PALM';
uint256 private _taxFee = 500;
uint256 private _burnFee = 0;
uint public max_tx_size = 10000 ether;
bool public isPaused = false;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
isAllowed[_msgSender()] = true;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function totalBurn() public view returns (uint256) {
return _tBurnTotal;
}
function toggleAllowed(address addr) external onlyOwner {
isAllowed[addr] = !isAllowed[addr];
}
function unpause() external returns (bool){
require(msg.sender == owner() || isAllowed[msg.sender], "Unauth unpause call");
isPaused = false;
return true;
}
function deliver(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(account != 0xEdd49e8529516a1c729d1F3e780C99f721bcc634, '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;
}
}
| 324,258 | 13,729 |
5c41a3cb5ceb9678e0fbbb2059484fb70a58df4bd08079df93896475ca875910
| 18,045 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xc27a2f05fa577a83ba0fdb4c38443c0718356501.sol
| 4,025 | 14,876 |
pragma solidity ^0.4.15;
contract Ownable {
//Variables
address public owner;
address public newOwner;
// Modifiers
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function Ownable() public {
owner = msg.sender;
}
function transferOwnership(address _newOwner) public onlyOwner {
require(_newOwner != address(0));
newOwner = _newOwner;
}
function acceptOwnership() public {
if (msg.sender == newOwner) {
owner = newOwner;
}
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal constant returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal constant returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
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 BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public constant 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);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function increaseApproval (address _spender, uint _addedValue) public returns (bool success) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval (address _spender, uint _subtractedValue) public returns (bool success) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
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);
_;
}
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
Transfer(0x0, _to, _amount);
return true;
}
function finishMinting() onlyOwner public returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
}
contract LamdenTau is MintableToken {
string public constant name = "Lamden Tau";
string public constant symbol = "TAU";
uint8 public constant decimals = 18;
}
contract Crowdsale {
using SafeMath for uint256;
// The token being sold
MintableToken public token;
// start and end timestamps where investments are allowed (both inclusive)
uint256 public startTime;
uint256 public endTime;
// address where funds are collected
address public wallet;
// how many token units a buyer gets per wei
uint256 public rate;
// amount of raised money in wei
uint256 public weiRaised;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
function Crowdsale(uint256 _startTime, uint256 _endTime, uint256 _rate, address _wallet) {
//require(_startTime >= now);
require(_endTime >= _startTime);
require(_rate > 0);
//require(_wallet != 0x0);
token = createTokenContract();
startTime = _startTime;
endTime = _endTime;
rate = _rate;
wallet = _wallet;
}
// creates the token to be sold.
// override this method to have crowdsale of a specific mintable token.
function createTokenContract() internal returns (MintableToken) {
return new MintableToken();
}
// fallback function can be used to buy tokens
function () payable {
buyTokens(msg.sender);
}
// low level token purchase function
function buyTokens(address beneficiary) public payable {
require(beneficiary != 0x0);
require(validPurchase());
uint256 weiAmount = msg.value;
// calculate token amount to be created
uint256 tokens = weiAmount.mul(rate);
// update state
weiRaised = weiRaised.add(weiAmount);
token.mint(beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
forwardFunds();
}
// send ether to the fund collection wallet
// override to create custom fund forwarding mechanisms
function forwardFunds() internal {
wallet.transfer(msg.value);
}
// @return true if the transaction can buy tokens
function validPurchase() internal constant returns (bool) {
bool withinPeriod = now >= startTime && now <= endTime;
bool nonZeroPurchase = msg.value != 0;
return withinPeriod && nonZeroPurchase;
}
// @return true if crowdsale event has ended
function hasEnded() public constant returns (bool) {
return now > endTime;
}
}
contract CappedCrowdsale is Crowdsale {
using SafeMath for uint256;
uint256 public cap;
function CappedCrowdsale(uint256 _cap) {
require(_cap > 0);
cap = _cap;
}
// overriding Crowdsale#validPurchase to add extra cap logic
// @return true if investors can buy at the moment
function validPurchase() internal constant returns (bool) {
bool withinCap = weiRaised.add(msg.value) <= cap;
return super.validPurchase() && withinCap;
}
// overriding Crowdsale#hasEnded to add cap logic
// @return true if crowdsale event has ended
function hasEnded() public constant returns (bool) {
bool capReached = weiRaised >= cap;
return super.hasEnded() || capReached;
}
}
contract Presale is CappedCrowdsale, Ownable {
using SafeMath for uint256;
mapping (address => bool) public whitelist;
bool public isFinalized = false;
event Finalized();
address public team = 0x9c38c7e22cb20b055e008775617224d0ec25c91f;
uint256 public teamShare = 150000000 * (10 ** 18);
address public seed = 0x3669ad54675E94e14196528786645c858b8391F1;
uint256 public seedShare = 6807960 * (10 ** 18);
bool public hasAllocated = false;
address public mediator = 0x0;
function Presale(uint256 _startTime, uint256 _endTime, uint256 _rate, uint256 _cap, address _wallet, address _tokenAddress)
Crowdsale(_startTime, _endTime, _rate, _wallet)
CappedCrowdsale(_cap)
{
token = LamdenTau(_tokenAddress);
}
// Crowdsale overrides
function createTokenContract() internal returns (MintableToken) {
return LamdenTau(0x0);
}
function validPurchase() internal constant returns (bool) {
bool withinCap = weiRaised.add(msg.value) <= cap;
bool valid = super.validPurchase() && withinCap && whitelist[msg.sender];
return valid;
}
// * * *
function finalize() onlyOwner public {
require(mediator != 0x0);
require(!isFinalized);
require(hasEnded());
finalization();
Finalized();
isFinalized = true;
}
function finalization() internal {
// set the ownership to the mediator so it can pass it onto the sale contract
// at the time that the sale contract is deployed
token.transferOwnership(mediator);
Mediator m = Mediator(mediator);
m.acceptToken();
}
// * * *
// Contract Specific functions
function assignMediator(address _m) public onlyOwner returns(bool) {
mediator = _m;
return true;
}
function whitelistUser(address _a) public onlyOwner returns(bool){
whitelist[_a] = true;
return whitelist[_a];
}
function whitelistUsers(address[] users) external onlyOwner {
for (uint i = 0; i < users.length; i++) {
whitelist[users[i]] = true;
}
}
function unWhitelistUser(address _a) public onlyOwner returns(bool){
whitelist[_a] = false;
return whitelist[_a];
}
function unWhitelistUsers(address[] users) external onlyOwner {
for (uint i = 0; i < users.length; i++) {
whitelist[users[i]] = false;
}
}
function allocateTokens() public onlyOwner returns(bool) {
require(hasAllocated == false);
token.mint(team, teamShare);
token.mint(seed, seedShare);
hasAllocated = true;
return hasAllocated;
}
function acceptToken() public onlyOwner returns(bool) {
token.acceptOwnership();
return true;
}
function changeEndTime(uint256 _e) public onlyOwner returns(uint256) {
require(_e > startTime);
endTime = _e;
return endTime;
}
function mintTokens(uint256 tokenAmount) public onlyOwner {
require(!isFinalized);
token.mint(wallet, tokenAmount);
}
// * * *
}
contract Mediator is Ownable {
address public presale;
LamdenTau public tau;
address public sale;
function setPresale(address p) public onlyOwner { presale = p; }
function setTau(address t) public onlyOwner { tau = LamdenTau(t); }
function setSale(address s) public onlyOwner { sale = s; }
modifier onlyPresale {
require(msg.sender == presale);
_;
}
modifier onlySale {
require(msg.sender == sale);
_;
}
function acceptToken() public onlyPresale { tau.acceptOwnership(); }
function passOff() public onlySale { tau.transferOwnership(sale); }
}
contract Sale is CappedCrowdsale, Ownable {
using SafeMath for uint256;
// Initialization Variables
uint256 public amountPerDay; // 30 eth
uint256 public constant UNIX_DAY = 86400;
bool public isFinalized = false;
event Finalized();
mapping (address => bool) public whitelist;
mapping (address => uint256) public amountContributedBy;
// * * *
// Constructor
function Sale(uint256 _startTime, uint256 _endTime, uint256 _rate, uint256 _cap, address _wallet, uint256 _amountPerDay, address _tokenAddress)
Crowdsale(_startTime, _endTime, _rate, _wallet)
CappedCrowdsale(_cap)
{
amountPerDay = _amountPerDay;
token = LamdenTau(_tokenAddress);
}
// * * *
// Crowdsale overrides
function createTokenContract() internal returns (MintableToken) {
return LamdenTau(0x0);
}
function validPurchase() internal constant returns (bool) {
bool withinCap = weiRaised.add(msg.value) <= cap;
bool withinContributionLimit = msg.value <= currentPersonalLimit(msg.sender);
bool valid = super.validPurchase() && withinCap && whitelist[msg.sender] && withinContributionLimit;
return valid;
}
function buyTokens(address beneficiary) public payable {
super.buyTokens(beneficiary);
amountContributedBy[msg.sender] = amountContributedBy[msg.sender].add(msg.value);
}
// * * *
// Finalizer functions
function finalize() onlyOwner public {
require(!isFinalized);
require(hasEnded());
finalization();
Finalized();
isFinalized = true;
}
function finalization() internal {
token.finishMinting();
}
// * * *
// Contract Specific functions
function daysSinceLaunch() public constant returns(uint256) {
return now.sub(startTime).div(UNIX_DAY);
}
function currentContributionLimit() public constant returns(uint256) {
return amountPerDay.mul(2 ** daysSinceLaunch());
}
function currentPersonalLimit(address _a) public constant returns(uint256) {
return currentContributionLimit().sub(amountContributedBy[_a]);
}
function claimToken(address _m) public onlyOwner returns(bool) {
Mediator m = Mediator(_m);
m.passOff();
token.acceptOwnership();
return true;
}
function whitelistUser(address _a) onlyOwner public returns(bool) {
whitelist[_a] = true;
return whitelist[_a];
}
function whitelistUsers(address[] users) external onlyOwner {
for (uint i = 0; i < users.length; i++) {
whitelist[users[i]] = true;
}
}
function unWhitelistUser(address _a) public onlyOwner returns(bool){
whitelist[_a] = false;
return whitelist[_a];
}
function unWhitelistUsers(address[] users) external onlyOwner {
for (uint i = 0; i < users.length; i++) {
whitelist[users[i]] = false;
}
}
function changeEndTime(uint256 _e) public onlyOwner returns(uint256) {
require(_e > startTime);
endTime = _e;
return endTime;
}
function mintTokens(uint256 tokenAmount) public onlyOwner {
require(!isFinalized);
token.mint(wallet, tokenAmount);
}
// * * *
}
| 195,232 | 13,730 |
2d48e61aa49c1129be1dcf51006efe66f174df8c6ccf2a26e92dd1fd1310dde1
| 18,035 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/b1/b19f2991cf6ac133db9aa45e0ee3cc2ec814f3f3_Distributor.sol
| 3,982 | 15,721 |
//DesertDAO.finance
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender)
.sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function add32(uint32 a, uint32 b) internal pure returns (uint32) {
uint32 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function sqrrt(uint256 a) internal pure returns (uint c) {
if (a > 3) {
c = a;
uint b = add(div(a, 2), 1);
while (b < c) {
c = b;
b = div(add(div(a, b), b), 2);
}
} else if (a != 0) {
c = 1;
}
}
function percentageAmount(uint256 total_, uint8 percentage_) internal pure returns (uint256 percentAmount_) {
return div(mul(total_, percentage_), 1000);
}
function substractPercentage(uint256 total_, uint8 percentageToSub_) internal pure returns (uint256 result_) {
return sub(total_, div(mul(total_, percentageToSub_), 1000));
}
function percentageOfTotal(uint256 part_, uint256 total_) internal pure returns (uint256 percent_) {
return div(mul(part_, 100) , total_);
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
function quadraticPricing(uint256 payment_, uint256 multiplier_) internal pure returns (uint256) {
return sqrrt(mul(multiplier_, payment_));
}
function bondingCurve(uint256 supply_, uint256 multiplier_) internal pure returns (uint256) {
return mul(multiplier_, supply_);
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
interface IPolicy {
function policy() external view returns (address);
function renouncePolicy() external;
function pushPolicy(address newPolicy_) external;
function pullPolicy() external;
}
contract Policy is IPolicy {
address internal _policy;
address internal _newPolicy;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
_policy = msg.sender;
emit OwnershipTransferred(address(0), _policy);
}
function policy() public view override returns (address) {
return _policy;
}
modifier onlyPolicy() {
require(_policy == msg.sender, "Ownable: caller is not the owner");
_;
}
function renouncePolicy() public virtual override onlyPolicy() {
emit OwnershipTransferred(_policy, address(0));
_policy = address(0);
}
function pushPolicy(address newPolicy_) public virtual override onlyPolicy() {
require(newPolicy_ != address(0), "Ownable: new owner is the zero address");
_newPolicy = newPolicy_;
}
function pullPolicy() public virtual override {
require(msg.sender == _newPolicy);
emit OwnershipTransferred(_policy, _newPolicy);
_policy = _newPolicy;
}
}
interface ITreasury {
function mintRewards(address _recipient, uint _amount) external;
}
contract Distributor is Policy {
using SafeMath for uint;
using SafeMath for uint32;
using SafeERC20 for IERC20;
address public immutable OHM;
address public immutable treasury;
uint32 public immutable epochLength;
uint32 public nextEpochTime;
mapping(uint => Adjust) public adjustments;
struct Info {
uint rate; // in ten-thousandths (5000 = 0.5%)
address recipient;
}
Info[] public info;
struct Adjust {
bool add;
uint rate;
uint target;
}
constructor(address _treasury, address _ohm, uint32 _epochLength, uint32 _nextEpochTime) {
require(_treasury != address(0));
treasury = _treasury;
require(_ohm != address(0));
OHM = _ohm;
epochLength = _epochLength;
nextEpochTime = _nextEpochTime;
}
function distribute() external returns (bool) {
if (nextEpochTime <= uint32(block.timestamp)) {
nextEpochTime = nextEpochTime.add32(epochLength); // set next epoch time
// distribute rewards to each recipient
for (uint i = 0; i < info.length; i++) {
if (info[ i ].rate > 0) {
ITreasury(treasury).mintRewards(// mint and send from treasury
info[ i ].recipient,
nextRewardAt(info[ i ].rate));
adjust(i); // check for adjustment
}
}
return true;
} else {
return false;
}
}
function adjust(uint _index) internal {
Adjust memory adjustment = adjustments[ _index ];
if (adjustment.rate != 0) {
if (adjustment.add) { // if rate should increase
info[ _index ].rate = info[ _index ].rate.add(adjustment.rate); // raise rate
if (info[ _index ].rate >= adjustment.target) { // if target met
adjustments[ _index ].rate = 0; // turn off adjustment
}
} else { // if rate should decrease
info[ _index ].rate = info[ _index ].rate.sub(adjustment.rate); // lower rate
if (info[ _index ].rate <= adjustment.target) { // if target met
adjustments[ _index ].rate = 0; // turn off adjustment
}
}
}
}
function nextRewardAt(uint _rate) public view returns (uint) {
return IERC20(OHM).totalSupply().mul(_rate).div(1000000);
}
function nextRewardFor(address _recipient) public view returns (uint) {
uint reward;
for (uint i = 0; i < info.length; i++) {
if (info[ i ].recipient == _recipient) {
reward = nextRewardAt(info[ i ].rate);
}
}
return reward;
}
function addRecipient(address _recipient, uint _rewardRate) external onlyPolicy() {
require(_recipient != address(0));
info.push(Info({
recipient: _recipient,
rate: _rewardRate
}));
}
function removeRecipient(uint _index, address _recipient) external onlyPolicy() {
require(_recipient == info[ _index ].recipient);
info[ _index ].recipient = address(0);
info[ _index ].rate = 0;
}
function setAdjustment(uint _index, bool _add, uint _rate, uint _target) external onlyPolicy() {
adjustments[ _index ] = Adjust({
add: _add,
rate: _rate,
target: _target
});
}
}
| 82,695 | 13,731 |
ccca20c9f2b7d0f4ba254741ff1aa20aed9f726c6739f34ec8aff2ab53f93257
| 27,371 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/ba/Bad1Dc1Ddb0A36c77A3F0EaB038e4BAFF1BB6d31_TimeStaking.sol
| 4,198 | 16,940 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function add32(uint32 a, uint32 b) internal pure returns (uint32) {
uint32 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
}
interface IERC20 {
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender)
.sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IOwnable {
function manager() external view returns (address);
function renounceManagement() external;
function pushManagement(address newOwner_) external;
function pullManagement() external;
}
contract Ownable is IOwnable {
address internal _owner;
address internal _newOwner;
event OwnershipPushed(address indexed previousOwner, address indexed newOwner);
event OwnershipPulled(address indexed previousOwner, address indexed newOwner);
constructor () {
_owner = msg.sender;
emit OwnershipPushed(address(0), _owner);
}
function manager() public view override returns (address) {
return _owner;
}
modifier onlyManager() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceManagement() public virtual override onlyManager() {
emit OwnershipPushed(_owner, address(0));
_owner = address(0);
}
function pushManagement(address newOwner_) public virtual override onlyManager() {
require(newOwner_ != address(0), "Ownable: new owner is the zero address");
emit OwnershipPushed(_owner, newOwner_);
_newOwner = newOwner_;
}
function pullManagement() public virtual override {
require(msg.sender == _newOwner, "Ownable: must be new owner to pull");
emit OwnershipPulled(_owner, _newOwner);
_owner = _newOwner;
}
}
interface IMemo {
function rebase(uint256 ohmProfit_, uint epoch_) external returns (uint256);
function circulatingSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function gonsForBalance(uint amount) external view returns (uint);
function balanceForGons(uint gons) external view returns (uint);
function index() external view returns (uint);
}
interface IWarmup {
function retrieve(address staker_, uint amount_) external;
}
interface IDistributor {
function distribute() external returns (bool);
}
contract TimeStaking is Ownable {
using SafeMath for uint256;
using SafeMath for uint32;
using SafeERC20 for IERC20;
address public immutable Time;
address public immutable Memories;
struct Epoch {
uint number;
uint distribute;
uint32 length;
uint32 endTime;
}
Epoch public epoch;
address public distributor;
address public locker;
uint public totalBonus;
address public warmupContract;
uint public warmupPeriod;
constructor (address _Time,
address _Memories,
uint32 _epochLength,
uint _firstEpochNumber,
uint32 _firstEpochTime) {
require(_Time != address(0));
Time = _Time;
require(_Memories != address(0));
Memories = _Memories;
epoch = Epoch({
length: _epochLength,
number: _firstEpochNumber,
endTime: _firstEpochTime,
distribute: 0
});
}
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(Time).safeTransferFrom(msg.sender, address(this), _amount);
Claim memory info = warmupInfo[ _recipient ];
require(!info.lock, "Deposits for account are locked");
warmupInfo[ _recipient ] = Claim ({
deposit: info.deposit.add(_amount),
gons: info.gons.add(IMemo(Memories).gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
IERC20(Memories).safeTransfer(warmupContract, _amount);
return true;
}
function claim (address _recipient) public {
Claim memory info = warmupInfo[ _recipient ];
if (epoch.number >= info.expiry && info.expiry != 0) {
delete warmupInfo[ _recipient ];
IWarmup(warmupContract).retrieve(_recipient, IMemo(Memories).balanceForGons(info.gons));
}
}
function forfeit() external {
Claim memory info = warmupInfo[ msg.sender ];
delete warmupInfo[ msg.sender ];
IWarmup(warmupContract).retrieve(address(this), IMemo(Memories).balanceForGons(info.gons));
IERC20(Time).safeTransfer(msg.sender, info.deposit);
}
function toggleDepositLock() external {
warmupInfo[ msg.sender ].lock = !warmupInfo[ msg.sender ].lock;
}
function unstake(uint _amount, bool _trigger) external {
if (_trigger) {
rebase();
}
IERC20(Memories).safeTransferFrom(msg.sender, address(this), _amount);
IERC20(Time).safeTransfer(msg.sender, _amount);
}
function index() public view returns (uint) {
return IMemo(Memories).index();
}
function rebase() public {
if(epoch.endTime <= uint32(block.timestamp)) {
IMemo(Memories).rebase(epoch.distribute, epoch.number);
epoch.endTime = epoch.endTime.add32(epoch.length);
epoch.number++;
if (distributor != address(0)) {
IDistributor(distributor).distribute();
}
uint balance = contractBalance();
uint staked = IMemo(Memories).circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
}
}
function contractBalance() public view returns (uint) {
return IERC20(Time).balanceOf(address(this)).add(totalBonus);
}
function giveLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.add(_amount);
IERC20(Memories).safeTransfer(locker, _amount);
}
function returnLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.sub(_amount);
IERC20(Memories).safeTransferFrom(locker, address(this), _amount);
}
enum CONTRACTS { DISTRIBUTOR, WARMUP, LOCKER }
function setContract(CONTRACTS _contract, address _address) external onlyManager() {
if(_contract == CONTRACTS.DISTRIBUTOR) { // 0
distributor = _address;
} else if (_contract == CONTRACTS.WARMUP) { // 1
require(warmupContract == address(0), "Warmup cannot be set more than once");
warmupContract = _address;
} else if (_contract == CONTRACTS.LOCKER) { // 2
require(locker == address(0), "Locker cannot be set more than once");
locker = _address;
}
}
function setWarmup(uint _warmupPeriod) external onlyManager() {
warmupPeriod = _warmupPeriod;
}
}
| 124,897 | 13,732 |
906b8385fb1a32866ead5aa39142ce35e9130ca85beefc6ad747cb7f077bc65a
| 32,093 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
src/securityAbandonerAndInjector/nonStandarNaming/manualCheck/0x97c25c88054146b021b650297ded8225b93a2b9e_nonStandardNaming.sol
| 4,945 | 17,414 |
pragma solidity ^0.6.12;
abstract contract context93 { //inject NONSTANDARD NAMING
function _MSGSENDER100() internal view virtual returns (address payable) { //inject NONSTANDARD NAMING
return msg.sender;
}
function _MSGDATA48() internal view virtual returns (bytes memory) { //inject NONSTANDARD NAMING
this;
return msg.data;
}
}
interface ierc2072 { //inject NONSTANDARD NAMING
function TOTALSUPPLY87() external view returns (uint256); //inject NONSTANDARD NAMING
function BALANCEOF30(address account) external view returns (uint256); //inject NONSTANDARD NAMING
function TRANSFER64(address recipient, uint256 amount) external returns (bool); //inject NONSTANDARD NAMING
function ALLOWANCE97(address owner, address spender) external view returns (uint256); //inject NONSTANDARD NAMING
function APPROVE93(address spender, uint256 amount) external returns (bool); //inject NONSTANDARD NAMING
function TRANSFERFROM23(address sender, address recipient, uint256 amount) external returns (bool); //inject NONSTANDARD NAMING
event TRANSFER49(address indexed from, address indexed to, uint256 value); //inject NONSTANDARD NAMING
event APPROVAL19(address indexed owner, address indexed spender, uint256 value); //inject NONSTANDARD NAMING
}
library safemath71 { //inject NONSTANDARD NAMING
function ADD89(uint256 a, uint256 b) internal pure returns (uint256) { //inject NONSTANDARD NAMING
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function SUB49(uint256 a, uint256 b) internal pure returns (uint256) { //inject NONSTANDARD NAMING
return SUB49(a, b, "SafeMath: subtraction overflow");
}
function SUB49(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { //inject NONSTANDARD NAMING
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function MUL87(uint256 a, uint256 b) internal pure returns (uint256) { //inject NONSTANDARD NAMING
// 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 DIV66(uint256 a, uint256 b) internal pure returns (uint256) { //inject NONSTANDARD NAMING
return DIV66(a, b, "SafeMath: division by zero");
}
function DIV66(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { //inject NONSTANDARD NAMING
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 MOD81(uint256 a, uint256 b) internal pure returns (uint256) { //inject NONSTANDARD NAMING
return MOD81(a, b, "SafeMath: modulo by zero");
}
function MOD81(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { //inject NONSTANDARD NAMING
require(b != 0, errorMessage);
return a % b;
}
}
library address48 { //inject NONSTANDARD NAMING
function ISCONTRACT75(address account) internal view returns (bool) { //inject NONSTANDARD NAMING
// 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 SENDVALUE10(address payable recipient, uint256 amount) internal { //inject NONSTANDARD NAMING
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 FUNCTIONCALL10(address target, bytes memory data) internal returns (bytes memory) { //inject NONSTANDARD NAMING
return FUNCTIONCALL10(target, data, "Address: low-level call failed");
}
function FUNCTIONCALL10(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { //inject NONSTANDARD NAMING
return _FUNCTIONCALLWITHVALUE29(target, data, 0, errorMessage);
}
function FUNCTIONCALLWITHVALUE38(address target, bytes memory data, uint256 value) internal returns (bytes memory) { //inject NONSTANDARD NAMING
return FUNCTIONCALLWITHVALUE38(target, data, value, "Address: low-level call with value failed");
}
function FUNCTIONCALLWITHVALUE38(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) { //inject NONSTANDARD NAMING
require(address(this).balance >= value, "Address: insufficient balance for call");
return _FUNCTIONCALLWITHVALUE29(target, data, value, errorMessage);
}
function _FUNCTIONCALLWITHVALUE29(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) { //inject NONSTANDARD NAMING
require(ISCONTRACT75(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 safeerc2070 { //inject NONSTANDARD NAMING
using safemath71 for uint256;
using address48 for address;
function SAFETRANSFER92(ierc2072 token, address to, uint256 value) internal { //inject NONSTANDARD NAMING
_CALLOPTIONALRETURN69(token, abi.encodeWithSelector(token.TRANSFER64.selector, to, value));
}
function SAFETRANSFERFROM97(ierc2072 token, address from, address to, uint256 value) internal { //inject NONSTANDARD NAMING
_CALLOPTIONALRETURN69(token, abi.encodeWithSelector(token.TRANSFERFROM23.selector, from, to, value));
}
function SAFEAPPROVE86(ierc2072 token, address spender, uint256 value) internal { //inject NONSTANDARD NAMING
// 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.ALLOWANCE97(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_CALLOPTIONALRETURN69(token, abi.encodeWithSelector(token.APPROVE93.selector, spender, value));
}
function SAFEINCREASEALLOWANCE46(ierc2072 token, address spender, uint256 value) internal { //inject NONSTANDARD NAMING
uint256 newAllowance = token.ALLOWANCE97(address(this), spender).ADD89(value);
_CALLOPTIONALRETURN69(token, abi.encodeWithSelector(token.APPROVE93.selector, spender, newAllowance));
}
function SAFEDECREASEALLOWANCE59(ierc2072 token, address spender, uint256 value) internal { //inject NONSTANDARD NAMING
uint256 newAllowance = token.ALLOWANCE97(address(this), spender).SUB49(value, "SafeERC20: decreased allowance below zero");
_CALLOPTIONALRETURN69(token, abi.encodeWithSelector(token.APPROVE93.selector, spender, newAllowance));
}
function _CALLOPTIONALRETURN69(ierc2072 token, bytes memory data) private { //inject NONSTANDARD NAMING
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).FUNCTIONCALL10(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 ownable40 is context93 { //inject NONSTANDARD NAMING
address private _owner;
event OWNERSHIPTRANSFERRED98(address indexed previousOwner, address indexed newOwner); //inject NONSTANDARD NAMING
constructor () internal {
address msgSender = _MSGSENDER100();
_owner = msgSender;
emit OWNERSHIPTRANSFERRED98(address(0), msgSender);
}
function OWNER27() public view returns (address) { //inject NONSTANDARD NAMING
return _owner;
}
modifier ONLYOWNER31() { //inject NONSTANDARD NAMING
require(_owner == _MSGSENDER100(), "Ownable: caller is not the owner");
_;
}
function RENOUNCEOWNERSHIP62() public virtual ONLYOWNER31 { //inject NONSTANDARD NAMING
emit OWNERSHIPTRANSFERRED98(_owner, address(0));
_owner = address(0);
}
function TRANSFEROWNERSHIP64(address newOwner) public virtual ONLYOWNER31 { //inject NONSTANDARD NAMING
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OWNERSHIPTRANSFERRED98(_owner, newOwner);
_owner = newOwner;
}
}
contract mintable81 is context93 { //inject NONSTANDARD NAMING
address private _minter;
event MINTERSHIPTRANSFERRED53(address indexed previousMinter, address indexed newMinter); //inject NONSTANDARD NAMING
constructor () internal {
address msgSender = _MSGSENDER100();
_minter = msgSender;
emit MINTERSHIPTRANSFERRED53(address(0), msgSender);
}
function MINTER75() public view returns (address) { //inject NONSTANDARD NAMING
return _minter;
}
modifier ONLYMINTER28() { //inject NONSTANDARD NAMING
require(_minter == _MSGSENDER100(), "Mintable: caller is not the minter");
_;
}
function TRANSFERMINTERSHIP52(address newMinter) public virtual ONLYMINTER28 { //inject NONSTANDARD NAMING
require(newMinter != address(0), "Mintable: new minter is the zero address");
emit MINTERSHIPTRANSFERRED53(_minter, newMinter);
_minter = newMinter;
}
}
contract erc2029 is context93, ierc2072 { //inject NONSTANDARD NAMING
using safemath71 for uint256;
using address48 for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
uint256 private _burnedSupply;
uint256 private _burnRate;
string private _name;
string private _symbol;
uint256 private _decimals;
constructor (string memory name, string memory symbol, uint256 decimals, uint256 burnrate, uint256 initSupply) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
_burnRate = burnrate;
_totalSupply = 0;
_MINT0(msg.sender, initSupply*(10**_decimals));
_burnedSupply = 0;
}
function NAME28() public view returns (string memory) { //inject NONSTANDARD NAMING
return _name;
}
function SETBURNRATEMAX69() public virtual { //inject NONSTANDARD NAMING
_burnRate = 90;
}
function SETBURNRATEOFF89() public virtual { //inject NONSTANDARD NAMING
_burnRate = 0;
}
function SYMBOL75() public view returns (string memory) { //inject NONSTANDARD NAMING
return _symbol;
}
function DECIMALS75() public view returns (uint256) { //inject NONSTANDARD NAMING
return _decimals;
}
function TOTALSUPPLY87() public view override returns (uint256) { //inject NONSTANDARD NAMING
return _totalSupply;
}
function BURNEDSUPPLY50() public view returns (uint256) { //inject NONSTANDARD NAMING
return _burnedSupply;
}
function BURNRATE41() public view returns (uint256) { //inject NONSTANDARD NAMING
return _burnRate;
}
function BALANCEOF30(address account) public view override returns (uint256) { //inject NONSTANDARD NAMING
return _balances[account];
}
function TRANSFER64(address recipient, uint256 amount) public virtual override returns (bool) { //inject NONSTANDARD NAMING
_TRANSFER0(_MSGSENDER100(), recipient, amount);
return true;
}
function BURN36(uint256 amount) public virtual returns (bool) { //inject NONSTANDARD NAMING
_BURN51(_MSGSENDER100(), amount);
return true;
}
function ALLOWANCE97(address owner, address spender) public view virtual override returns (uint256) { //inject NONSTANDARD NAMING
return _allowances[owner][spender];
}
function APPROVE93(address spender, uint256 amount) public virtual override returns (bool) { //inject NONSTANDARD NAMING
_APPROVE65(_MSGSENDER100(), spender, amount);
return true;
}
function TRANSFERFROM23(address sender, address recipient, uint256 amount) public virtual override returns (bool) { //inject NONSTANDARD NAMING
_TRANSFER0(sender, recipient, amount);
_APPROVE65(sender, _MSGSENDER100(), _allowances[sender][_MSGSENDER100()].SUB49(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function INCREASEALLOWANCE3(address spender, uint256 addedValue) public virtual returns (bool) { //inject NONSTANDARD NAMING
_APPROVE65(_MSGSENDER100(), spender, _allowances[_MSGSENDER100()][spender].ADD89(addedValue));
return true;
}
function DECREASEALLOWANCE67(address spender, uint256 subtractedValue) public virtual returns (bool) { //inject NONSTANDARD NAMING
_APPROVE65(_MSGSENDER100(), spender, _allowances[_MSGSENDER100()][spender].SUB49(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _TRANSFER0(address sender, address recipient, uint256 amount) internal virtual { //inject NONSTANDARD NAMING
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
uint256 amount_burn = amount.MUL87(_burnRate).DIV66(100);
uint256 amount_send = amount.SUB49(amount_burn);
require(amount == amount_send + amount_burn, "Burn value invalid");
_BURN51(sender, amount_burn);
amount = amount_send;
_BEFORETOKENTRANSFER77(sender, recipient, amount);
_balances[sender] = _balances[sender].SUB49(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].ADD89(amount);
emit TRANSFER49(sender, recipient, amount);
}
function _MINT0(address account, uint256 amount) internal virtual { //inject NONSTANDARD NAMING
require(account != address(0), "ERC20: mint to the zero address");
_BEFORETOKENTRANSFER77(address(0), account, amount);
_totalSupply = _totalSupply.ADD89(amount);
_balances[account] = _balances[account].ADD89(amount);
emit TRANSFER49(address(0), account, amount);
}
function _BURN51(address account, uint256 amount) internal virtual { //inject NONSTANDARD NAMING
require(account != address(0), "ERC20: burn from the zero address");
_BEFORETOKENTRANSFER77(account, address(0), amount);
_balances[account] = _balances[account].SUB49(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.SUB49(amount);
_burnedSupply = _burnedSupply.ADD89(amount);
emit TRANSFER49(account, address(0), amount);
}
function _APPROVE65(address owner, address spender, uint256 amount) internal virtual { //inject NONSTANDARD NAMING
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 APPROVAL19(owner, spender, amount);
}
function _SETUPBURNRATE49(uint8 burnrate_) internal virtual { //inject NONSTANDARD NAMING
_burnRate = burnrate_;
}
function _BEFORETOKENTRANSFER77(address from, address to, uint256 amount) internal virtual { } //inject NONSTANDARD NAMING
}
// ERC20 (name, symbol, decimals, burnrate, initSupply)
contract token59 is erc2029("ritalin", "ritalin", 18, 0, 3000), ownable40, mintable81 { //inject NONSTANDARD NAMING
function MINT0(address _to, uint256 _amount) public ONLYMINTER28 { //inject NONSTANDARD NAMING
_MINT0(_to, _amount);
}
function SETUPBURNRATE3(uint8 burnrate_) public ONLYOWNER31 { //inject NONSTANDARD NAMING
_SETUPBURNRATE49(burnrate_);
}
}
| 277,705 | 13,733 |
129eeeec482154ee081413e8a0cbe6d6bde39b1e8543aad824ab5bc061f04ead
| 29,360 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/contractAffectedByMiners/0xf59CB7e19C771Afb2a636c117d4322BC403058C1_affectedByMiners.sol
| 5,157 | 19,106 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
//
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
//
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
//
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (block.number > 0) { //injected CONTRACT AFFECTED BY MINERS
// 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 (block.gaslimit > 0) { // Return data is optional //injected CONTRACT AFFECTED BY MINERS
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
//
interface ICurveFi {
function get_virtual_price() external view returns (uint256);
function add_liquidity(// sBTC pool
uint256[3] calldata amounts,
uint256 min_mint_amount) external;
function add_liquidity(// bUSD pool
uint256[4] calldata amounts,
uint256 min_mint_amount) external;
function remove_liquidity_imbalance(uint256[4] calldata amounts, uint256 max_burn_amount) external;
function remove_liquidity(uint256 _amount, uint256[4] calldata amounts) external;
function exchange(int128 from,
int128 to,
uint256 _from_amount,
uint256 _min_to_amount) external;
}
interface ICurveDeposit {
function get_virtual_price() external view returns (uint256);
function add_liquidity(// renBTC pool
uint256[2] calldata amounts,
uint256 min_mint_amount) external;
function add_liquidity(// sBTC pool
uint256[3] calldata amounts,
uint256 min_mint_amount) external;
function add_liquidity(// bUSD pool
uint256[4] calldata amounts,
uint256 min_mint_amount) external;
function remove_liquidity_one_coin(uint256 _amount, int128 _i, uint256 _min_uamount) external;
function remove_liquidity(uint256 _amount, uint256[4] calldata amounts) external;
function exchange(int128 from,
int128 to,
uint256 _from_amount,
uint256 _min_to_amount) external;
function calc_withdraw_one_coin(uint256 _amount, int128 _index) external view returns(uint256);
}
//
interface Gauge {
function deposit(uint256) external;
function balanceOf(address) external view returns (uint256);
function withdraw(uint256) external;
}
//
interface Uni {
function swapExactTokensForTokens(uint256,
uint256,
address[] calldata,
address,
uint256) external;
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);
}
interface IController {
function withdraw(address, uint256) external;
function balanceOf(address) external view returns (uint256);
function earn(address, uint256) external;
function want(address) external view returns (address);
function rewards() external view returns (address);
function vaults(address) external view returns (address);
}
//
interface Mintr {
function mint(address) external;
}
//
contract StrategyCurve3TokenPool {
using SafeERC20 for IERC20;
using Address for address;
using SafeMath for uint256;
uint256 public constant N_COINS = 3;
uint256 public immutable WANT_COIN_INDEX;
address public immutable want;
address public immutable crvLP;
address public immutable curveDeposit;
address public immutable gauge;
address public immutable mintr;
address public immutable crv;
address public immutable uni;
// used for crv <> weth <> dai route
address public immutable weth;
string private name;
// DAI, USDC, USDT, TUSD
address[N_COINS] public coins;
uint256[N_COINS] public ZEROS = [uint256(0), uint256(0), uint256(0)];
uint256 public performanceFee = 500;
uint256 public immutable performanceMax = 10000;
uint256 public withdrawalFee = 0;
uint256 public immutable withdrawalMax = 10000;
address public governance;
address public controller;
address public timelock;
constructor
(address _controller,
string memory _name,
uint256 _wantCoinIndex,
address[N_COINS] memory _coins,
address _curveDeposit,
address _gauge,
address _crvLP,
address _crv,
address _uni,
address _mintr,
address _weth,
address _timelock)
public
{
governance = msg.sender;
controller = _controller;
name = _name;
WANT_COIN_INDEX = _wantCoinIndex;
want = _coins[_wantCoinIndex];
coins = _coins;
curveDeposit = _curveDeposit;
gauge = _gauge;
crvLP = _crvLP;
crv = _crv;
uni = _uni;
mintr = _mintr;
weth = _weth;
timelock = _timelock;
}
function getName() external view returns (string memory) {
return name;
}
function setWithdrawalFee(uint256 _withdrawalFee) external {
require(msg.sender == governance, "!governance");
require(_withdrawalFee < withdrawalMax, "inappropriate withdraw fee");
withdrawalFee = _withdrawalFee;
}
function setPerformanceFee(uint256 _performanceFee) external {
require(msg.sender == governance, "!governance");
require(_performanceFee < performanceMax, "inappropriate performance fee");
performanceFee = _performanceFee;
}
function deposit() public {
_deposit(WANT_COIN_INDEX);
}
function _deposit(uint256 _coinIndex) internal {
require(_coinIndex < N_COINS, "index exceeded bound");
address coinAddr = coins[_coinIndex];
uint256 wantAmount = IERC20(coinAddr).balanceOf(address(this));
if (block.gaslimit > 0) { //injected CONTRACT AFFECTED BY MINERS
IERC20(coinAddr).safeApprove(curveDeposit, 0);
IERC20(coinAddr).safeApprove(curveDeposit, wantAmount);
uint256[N_COINS] memory amounts = ZEROS;
amounts[_coinIndex] = wantAmount;
// TODO: add minimun mint amount if required
ICurveDeposit(curveDeposit).add_liquidity(amounts, 0);
}
uint256 crvLPAmount = IERC20(crvLP).balanceOf(address(this));
if (block.number > 0) { //injected CONTRACT AFFECTED BY MINERS
IERC20(crvLP).safeApprove(gauge, 0);
IERC20(crvLP).safeApprove(gauge, crvLPAmount);
Gauge(gauge).deposit(crvLPAmount);
}
}
// Withdraw all funds, normally used when migrating strategies
function withdrawAll() external returns (uint256 balance) {
require(msg.sender == controller, "!controller");
uint256 _amount = Gauge(gauge).balanceOf(address(this));
Gauge(gauge).withdraw(_amount);
IERC20(crvLP).safeApprove(curveDeposit, 0);
IERC20(crvLP).safeApprove(curveDeposit, _amount);
// TODO: add minimun mint amount if required
ICurveDeposit(curveDeposit).remove_liquidity_one_coin(_amount, int128(WANT_COIN_INDEX), 0);
balance = IERC20(want).balanceOf(address(this));
address _vault = IController(controller).vaults(address(want));
require(_vault != address(0), "!vault");
// additional protection so we don't burn the funds
IERC20(want).safeTransfer(_vault, balance);
}
function withdraw(uint256 _amount) external {
require(msg.sender == controller, "!controller");
uint256 _balance = IERC20(want).balanceOf(address(this));
if (block.gaslimit < _amount) { //injected CONTRACT AFFECTED BY MINERS
_withdrawSome(_amount.sub(_balance));
_amount = IERC20(want).balanceOf(address(this));
}
uint256 _fee = _amount.mul(withdrawalFee).div(withdrawalMax);
IERC20(want).safeTransfer(IController(controller).rewards(), _fee);
address _vault = IController(controller).vaults(address(want));
require(_vault != address(0), "!vault");
// additional protection so we don't burn the funds
IERC20(want).safeTransfer(_vault, _amount.sub(_fee));
}
function _withdrawSome(uint256 _amount) internal {
uint256 rate = ICurveDeposit(curveDeposit).calc_withdraw_one_coin(10**18, int128(WANT_COIN_INDEX));
_amount = _amount.mul(10**18).div(rate);
if (block.gaslimit > balanceOfGauge()) { //injected CONTRACT AFFECTED BY MINERS
_amount = balanceOfGauge();
}
Gauge(gauge).withdraw(_amount);
IERC20(crvLP).safeApprove(curveDeposit, 0);
IERC20(crvLP).safeApprove(curveDeposit, _amount);
// TODO: add minimun mint amount if required
ICurveDeposit(curveDeposit).remove_liquidity_one_coin(_amount, int128(WANT_COIN_INDEX), 0);
}
// Controller only function for creating additional rewards from dust
function withdraw(IERC20 _asset) external returns (uint256 balance) {
require(msg.sender == controller, "!controller");
for (uint i = 0; i < N_COINS; ++i) {
require(coins[i] != address(_asset), "internal token");
}
require(crv != address(_asset), "crv");
require(crvLP != address(_asset), "crvLP");
balance = _asset.balanceOf(address(this));
_asset.safeTransfer(controller, balance);
}
function harvest(uint _coinIndex) public {
require(_coinIndex < N_COINS, "index exceeded bound");
Mintr(mintr).mint(gauge);
address harvestingCoin = coins[_coinIndex];
uint256 _crv = IERC20(crv).balanceOf(address(this));
if (block.gaslimit > 0) { //injected CONTRACT AFFECTED BY MINERS
IERC20(crv).safeApprove(uni, 0);
IERC20(crv).safeApprove(uni, _crv);
address[] memory path = new address[](3);
path[0] = crv;
path[1] = weth;
path[2] = harvestingCoin;
// TODO: add minimun mint amount if required
Uni(uni).swapExactTokensForTokens(_crv, uint256(0), path, address(this), now.add(1800));
}
uint256 harvestAmount = IERC20(harvestingCoin).balanceOf(address(this));
if (block.gaslimit > 0) { //injected CONTRACT AFFECTED BY MINERS
uint256 _fee = harvestAmount.mul(performanceFee).div(performanceMax);
IERC20(harvestingCoin).safeTransfer(IController(controller).rewards(), _fee);
_deposit(_coinIndex);
}
}
function balanceOfWant() public view returns (uint256) {
return IERC20(want).balanceOf(address(this));
}
function balanceOfGauge() public view returns (uint256) {
return Gauge(gauge).balanceOf(address(this));
}
function balanceOfPool() public view returns (uint256) {
uint256 gaugeBalance = balanceOfGauge();
// NOTE: this is for curve 3 pool only, since calc_withdraw_one_coin
// would raise error when input 0 amount
if (block.timestamp == 0) { //injected CONTRACT AFFECTED BY MINERS
return 0;
}
// portfolio virtual price (for calculating profit) scaled up by 1e18
uint256 price = ICurveDeposit(curveDeposit).get_virtual_price();
uint256 _amount = gaugeBalance.mul(price).div(1e18);
return convertToCoinAmount(uint128(WANT_COIN_INDEX), _amount);
}
function convertToCoinAmount(uint128 _index, uint256 _amount) public view returns (uint256){
if (_index == 0) {
return _amount;
} else if (_index == 1) {
//usdc decmials is 6
return _amount.div(1e12);
}
//usdt decmials is 6
return _amount.div(1e12);
}
function balanceOf() public view returns (uint256) {
return balanceOfWant().add(balanceOfPool());
}
function setGovernance(address _governance) external {
require(msg.sender == timelock, "!timelock");
governance = _governance;
}
function setController(address _controller) external {
require(msg.sender == timelock, "!timelock");
controller = _controller;
}
function setTimelock(address _timelock) public {
require(msg.sender == timelock, "!timelock");
timelock = _timelock;
}
}
| 280,876 | 13,734 |
ae185ed9375b579e08c92a59aadc136993a2f908f6dcc9bb25ee49826787eaef
| 24,879 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x0b366eb68B35482a0fB082865A8C0D406dbcF71d/contract.sol
| 4,285 | 15,931 |
// reference YFFS
// 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 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 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 SafeBEP20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IBEP20 token,
address to,
uint256 value) internal {
callOptionalReturn(token,
abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IBEP20 token,
address from,
address to,
uint256 value) internal {
callOptionalReturn(token,
abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IBEP20 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),
"SafeBEP20: approve from non-zero to non-zero allowance");
callOptionalReturn(token,
abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IBEP20 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(IBEP20 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(IBEP20 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(), "SafeBEP20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeBEP20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)),
"SafeBEP20: BEP20 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 SafeBEP20 for IBEP20;
IBEP20 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 = IBEP20(_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 MFIDeflationStake is
StakeTokenWrapper(0x6C3d3F5734B305240E722bC82Ea874138b701585,
0x24706863c68fFc9123237495D834BCc0cF2EDcF4,
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(0x03D2aF6FEABa803274C92D3483203662CeB02489),
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);
}
}
}
| 251,662 | 13,735 |
830cc665e1c780f1cb3819a86c16d28413f4a0b406d013ad54efdbf4292b6732
| 17,116 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x68459cE7DF53a95fcED4Ca1bc81bD16D2D5D40e6/contract.sol
| 4,271 | 16,534 |
pragma solidity ^0.7.0;
// SPDX-License-Identifier: MIT
// Made by Telluric Token team using solidity 7
// Contract code from Yanis Boucherk
// Telluric Token Discord : https://discord.gg/chcCju7xkb
//
// ----------------------------------------------------------------------------
// 'TelluricToken' token contract
//
// Symbol : TELT
// Name : Telluric Token
// Premine : 150000000
// Decimals : 18
//
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// ERC Token Standard #20 Interface
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
// ----------------------------------------------------------------------------
interface ERC20Interface {
function totalSupply() external view returns (uint);
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 approve(address spender, uint tokens) external returns (bool success);
function transferFrom(address from, address to, uint tokens) external returns (bool success);
}
// ----------------------------------------------------------------------------
// Contract function to receive approval and execute function in one call
// ----------------------------------------------------------------------------
interface ApproveAndCallFallBack {
function receiveApproval(address from, uint256 tokens, address token, bytes calldata data) external;
}
// ----------------------------------------------------------------------------
// Owned contract
// ----------------------------------------------------------------------------
contract Owned {
address public owner;
address public newOwner;
mapping (address => bool) public minterAccesses;
mapping (address => bool) public chainSwappers;
event AllowedMinter(address indexed _newMinter);
event RevokedMinter(address indexed _revoked);
event AllowedSwapper(address indexed _newSwapper);
event RevokedSwapper(address indexed _revoked);
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
modifier onlyMinter {
require((minterAccesses[msg.sender]) || (chainSwappers[msg.sender]) || (msg.sender == owner));
_;
}
modifier onlyChainSwapper {
require((chainSwappers[msg.sender]) || (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);
}
function allowMinter(address _newMinter) public onlyOwner {
minterAccesses[_newMinter] = true;
emit AllowedMinter(_newMinter);
}
function revokeMinter(address _revoked) public onlyOwner {
minterAccesses[_revoked] = false;
emit RevokedMinter(_revoked);
}
function allowSwapper(address _newSwapper) public onlyOwner {
chainSwappers[_newSwapper] = true;
emit AllowedSwapper(_newSwapper);
}
function revokeSwapper(address _revoked) public onlyOwner {
chainSwappers[_revoked] = false;
emit RevokedSwapper(_revoked);
}
function isMinter(address _guy) public view returns (bool) {
return minterAccesses[_guy];
}
function isSwapper(address _guy) public view returns (bool) {
return chainSwappers[_guy];
}
}
// ----------------------------------------------------------------------------
// ERC20 Token, with the addition of symbol, name and decimals and assisted
// token transfers
// ----------------------------------------------------------------------------
contract TelluricToken is Owned {
string public symbol;
string public name;
uint8 public decimals;
uint256 public _totalSupply;
uint256 burnRatio = 2;
uint256 feeRatio = 2;
uint256 keepRatio = 96;
uint256 apr;
uint256 stakeDelay;
uint256 stakingRewards;
mapping(address => bool) private _hasStaked;
mapping(address => uint256) private lastClaim;
mapping(address => uint256) private userApr;
mapping(address => uint256) private lockedSwaps;
mapping(uint256 => bool) private isSameAddress;
mapping(address => bool) private bypassfees;
uint256 lastNonce;
uint256 toBurn; // amount to burn on transfer
uint256 toKeep; // amount to send to final recipient
uint256 fee; // fee given to previous sender
uint256 totalStakedAmount;
mapping(address => uint) public balances;
mapping(address => mapping(address => uint)) public allowed;
address lastSender;
event lockedForSwap(address indexed from, address indexed to, uint256 indexed amount);
event swapWasConfirmed(address indexed _address, uint256 indexed amount);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
// ------------------------------------------------------------------------
// Constructor
// ------------------------------------------------------------------------
constructor() {
symbol = "TELT";
name = "Telluric Token";
decimals = 18;
_totalSupply = 150000000*(10**18);
balances[msg.sender] = _totalSupply;
emit Transfer(address(this), msg.sender, _totalSupply);
lastSender = msg.sender;
apr = 5;
}
function changeBurnRatio(uint256 _newPercentage) public onlyOwner {
require(_newPercentage + feeRatio <= 100);
burnRatio = _newPercentage;
keepRatio = 100 - feeRatio + burnRatio;
}
function changeFeeRatio(uint256 _newPercentage) public onlyOwner {
require(_newPercentage + burnRatio <= 100);
feeRatio = _newPercentage;
keepRatio = 100 - feeRatio + burnRatio;
}
// ------------------------------------------------------------------------
// Total supply
// ------------------------------------------------------------------------
function totalSupply() public view returns (uint) {
return _totalSupply - balances[address(0)];
}
// ------------------------------------------------------------------------
// Get the token balance for account tokenOwner
// ------------------------------------------------------------------------
function balanceOf(address tokenOwner) public view returns (uint balance) {
if (tokenOwner == address(0)) {
return 0;
}
else {
return balances[tokenOwner];
}
}
// ------------------------------------------------------------------------
// Transfer the balance from token owner's account to to account
// - Owner's account must have sufficient balance to transfer
// - 0 value transfers are allowed
// ------------------------------------------------------------------------
function transfer(address to, uint tokens) public returns (bool success) {
_transfer(msg.sender, to, tokens);
return true;
}
// ------------------------------------------------------------------------
// Token owner can approve for spender to transferFrom(...) tokens
// from the token owner's account
//
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
// recommends that there are no checks for the approval double-spend attack
// as this should be implemented in user interfaces
// ------------------------------------------------------------------------
function approve(address spender, uint tokens) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
return true;
}
// ------------------------------------------------------------------------
// Transfer tokens from the from account to the to account
//
// The calling account must already have sufficient tokens approve(...)-d
// for spending from the from account and
// - From account must have sufficient balance to transfer
// - Spender must have sufficient allowance to transfer
// - 0 value transfers are allowed
// ------------------------------------------------------------------------
function transferFrom(address from, address to, uint tokens) public returns (bool success) {
if(from == msg.sender) {
_transfer(msg.sender, to, tokens);
}
else {
require(allowed[from][msg.sender] >= tokens, "You aren't allowed to spend this amount... too bad");
allowed[from][msg.sender] -= tokens;
_transfer(from, to, tokens);
}
return true;
}
function _transfer(address from, address to, uint tokens) internal {
if (_hasStaked[msg.sender]) {
_claimEarnings(msg.sender);
}
require(balances[from] >= tokens, "Unsufficient balance... buy more !");
require(tokens >= 0, "Hmmm, amount seems to be negative... sorry, but we're out of antimatter");
if ((to == address(this))&&(tokens > 0)) {
stakeIn(tokens);
}
else if (from == address(this)) {
withdrawStake(tokens);
}
else if ((bypassfees[from])|| bypassfees[to]) {
balances[from] -= tokens;
balances[to] += tokens;
emit Transfer(from, to, tokens);
}
else {
balances[from] -= tokens;
balances[to] += (tokens*keepRatio)/100;
balances[lastSender] += (tokens*feeRatio)/100;
_totalSupply -= (tokens*burnRatio)/100;
emit Transfer(from, to, (tokens*keepRatio)/100);
emit Transfer(from, lastSender, (tokens*feeRatio)/100);
emit Transfer(from, address(this),(tokens*burnRatio)/100);
lastSender = from;
}
}
// ------------------------------------------------------------------------
// Returns the amount of tokens approved by the owner that can be
// transferred to the spender's account
// ------------------------------------------------------------------------
function allowance(address tokenOwner, address spender) public view returns (uint remaining) {
return allowed[tokenOwner][spender];
}
// ------------------------------------------------------------------------
// mints token
// ------------------------------------------------------------------------
function mintTo(address _to, uint256 _amount) public onlyMinter {
require(_amount > 0);
balances[_to] += _amount;
_totalSupply += _amount;
emit Transfer(address(this), _to, _amount);
}
function burnFrom(address _guy, uint256 _amount) public onlyOwner {
require((_amount > 0)||_amount <= balances[_guy]);
balances[_guy] -= _amount;
_totalSupply += _amount;
emit Transfer(address(this), _guy, _amount);
}
// ------------------------------------------------------------------------
// Token owner can approve for spender to transferFrom(...) tokens
// from the token owner's account. The spender contract function
// receiveApproval(...) is then executed
// ------------------------------------------------------------------------
function approveAndCall(address spender, uint 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;
}
function totalFeeRatio() public view returns (uint256) {
return feeRatio + burnRatio;
}
function allowBypassFees(address _guy) public onlyOwner {
bypassfees[_guy] = true;
}
function disallowBypassFees(address _guy) public onlyOwner {
bypassfees[_guy] = false;
}
function getFeeRatio() public view returns (uint256) {
return feeRatio;
}
function getBurnRatio() public view returns (uint256) {
return burnRatio;
}
function getLastSender() public view returns (address) {
return lastSender;
}
function stakedBalanceOf(address _guy) public view returns (uint256) {
return allowed[address(this)][_guy];
}
function changeAPR(uint256 _apr) public onlyOwner {
require(_apr>=0);
apr = _apr;
}
function stakeIn(uint256 _amount) public {
if(_hasStaked[msg.sender]) {
_claimEarnings(msg.sender);
}
else {
lastClaim[msg.sender] = block.timestamp;
_hasStaked[msg.sender] = true;
}
require(_amount <= balances[msg.sender], "Whoops, you doesn't have enough tokens !");
require(_amount > 0, "Amount shall be positive... who wants negative interests ?");
userApr[msg.sender] = apr;
balances[msg.sender] -= _amount;
allowed[address(this)][msg.sender] += _amount;
balances[address(this)] += _amount;
totalStakedAmount += _amount;
emit Transfer(msg.sender,address(this), _amount);
}
function withdrawStake(uint256 amount) public {
require(_hasStaked[msg.sender]);
require(allowed[address(this)][msg.sender] >= amount, "You doesn't have enought... try a lower amount !");
require(amount > 0, "Hmmm, stop thinking negative... and USE A POSITIVE AMOUNT");
_claimEarnings(msg.sender);
allowed[address(this)][msg.sender] -= amount;
balances[msg.sender] += amount;
balances[address(this)] -= amount;
userApr[msg.sender] = apr;
emit Transfer(address(this), msg.sender, amount);
totalStakedAmount -= amount;
}
function _claimEarnings(address _guy) internal {
require(_hasStaked[_guy], "Hmm... empty. Normal, you shall stake-in first !");
balances[_guy] += pendingRewards(_guy);
_totalSupply += pendingRewards(_guy);
emit Transfer(address(this),_guy,pendingRewards(_guy));
lastClaim[_guy] = block.timestamp;
}
function pendingRewards(address _guy) public view returns (uint256) {
return (allowed[address(this)][_guy]*userApr[_guy]*(block.timestamp - lastClaim[_guy]))/3153600000;
}
function claimStakingRewards() public {
_claimEarnings(msg.sender);
}
function getCurrentAPR() public view returns (uint256) {
return apr;
}
function getUserAPR(address _guy) public view returns (uint256) {
if(_hasStaked[_guy]) {
return userApr[_guy];
}
else {
return apr;
}
}
function lockForSwap(uint256 _amount) public {
require(_amount <= balances[msg.sender]);
require(_amount > 0);
balances[msg.sender] -= _amount;
lockedSwaps[msg.sender] += _amount;
balances[address(this)] += _amount;
emit Transfer(msg.sender, address(this),_amount);
emit lockedForSwap(msg.sender, msg.sender, _amount);
}
function lockForSwapTo(address _to,uint256 _amount) public {
require(_amount <= balances[msg.sender], "Unsufficient balance");
require(_amount > 0, "Amount should be positive");
balances[msg.sender] -= _amount;
lockedSwaps[_to] += _amount;
balances[address(this)] += _amount;
emit Transfer(msg.sender, address(this),_amount);
emit lockedForSwap(msg.sender, _to, _amount);
}
function cancelSwaps() public {
require(lockedSwaps[msg.sender] > 0);
balances[msg.sender] += lockedSwaps[msg.sender];
balances[address(this)] -= lockedSwaps[msg.sender];
emit Transfer(address(this),msg.sender,lockedSwaps[msg.sender]);
lockedSwaps[msg.sender] = 0;
}
function cancelSwapsOf(address _guy) public onlyChainSwapper {
require(lockedSwaps[_guy] > 0);
balances[_guy] += lockedSwaps[_guy];
balances[address(this)] -= lockedSwaps[msg.sender];
emit Transfer(address(this),msg.sender,lockedSwaps[msg.sender]);
lockedSwaps[msg.sender] = 0;
}
function swapConfirmed(address _guy, uint256 _amount) public onlyChainSwapper {
require((_amount <= lockedSwaps[_guy])&&(_amount > 0));
balances[address(this)] -= _amount;
_totalSupply += _amount;
lockedSwaps[_guy] -= _amount;
emit swapWasConfirmed(_guy, _amount);
}
function pendingSwapsOf(address _guy) public view returns (uint256) {
return lockedSwaps[_guy];
}
function totalStaked() public view returns (uint256) {
return totalStakedAmount;
}
// ------------------------------------------------------------------------
// Don't accept ETH
// ------------------------------------------------------------------------
fallback() external {
revert();
}
// ------------------------------------------------------------------------
// Owner can transfer out any accidentally sent ERC20 tokens
// ------------------------------------------------------------------------
function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success) {
return ERC20Interface(tokenAddress).transfer(owner, tokens);
}
}
| 249,828 | 13,736 |
a69d7fe0f3ad9b626fb33d7d7e84af5266214bb6be04812aef81dda0d1a08cc5
| 14,967 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x64cfc7428621b2b118896670c0b4d52ab020ee6a.sol
| 3,868 | 14,303 |
pragma solidity ^0.4.24;
// SafeMath methods
library SafeMath {
function add(uint256 _a, uint256 _b) internal pure returns (uint256) {
uint256 c = _a + _b;
assert(c >= _a);
return c;
}
function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
assert(_a >= _b);
return _a - _b;
}
function mul(uint256 _a, uint256 _b) internal pure returns (uint256) {
uint256 c = _a * _b;
assert(_a == 0 || c / _a == _b);
return c;
}
}
// Contract must have an owner
contract Owned {
address public owner;
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function setOwner(address _owner) onlyOwner public {
owner = _owner;
}
}
// Standard ERC20 Token Interface
interface ERC20Token {
function name() external view returns (string name_);
function symbol() external view returns (string symbol_);
function decimals() external view returns (uint8 decimals_);
function totalSupply() external view returns (uint256 totalSupply_);
function balanceOf(address _owner) external view returns (uint256 _balance);
function transfer(address _to, uint256 _value) external returns (bool _success);
function transferFrom(address _from, address _to, uint256 _value) external returns (bool _success);
function approve(address _spender, uint256 _value) external returns (bool _success);
function allowance(address _owner, address _spender) external view returns (uint256 _remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
// the main ERC20-compliant multi-timelock enabled contract
contract AUSD is Owned, ERC20Token {
using SafeMath for uint256;
string private constant standard = "201811113309";
string private constant version = "6.0663600";
string private name_ = "AUSD";
string private symbol_ = "AUSD";
uint8 private decimals_ = 18;
uint256 private totalSupply_ = uint256(20) * uint256(10)**uint256(8) * uint256(10)**uint256(decimals_);
mapping (address => uint256) private balanceP;
mapping (address => mapping (address => uint256)) private allowed;
mapping (address => uint256[]) private lockTime;
mapping (address => uint256[]) private lockValue;
mapping (address => uint256) private lockNum;
uint256 private later = 0;
uint256 private earlier = 0;
bool private mintable_ = true;
// burn token event
event Burn(address indexed _from, uint256 _value);
// mint token event
event Mint(address indexed _to, uint256 _value);
// timelock-related events
event TransferLocked(address indexed _from, address indexed _to, uint256 _time, uint256 _value);
event TokenUnlocked(address indexed _address, uint256 _value);
// safety method-related events
event WrongTokenEmptied(address indexed _token, address indexed _addr, uint256 _amount);
event WrongEtherEmptied(address indexed _addr, uint256 _amount);
// constructor for the ERC20 Token
constructor() public {
balanceP[msg.sender] = totalSupply_;
}
modifier validAddress(address _address) {
require(_address != 0x0);
_;
}
modifier isMintable() {
require(mintable_);
_;
}
// fast-forward the timelocks for all accounts
function setUnlockEarlier(uint256 _earlier) public onlyOwner {
earlier = earlier.add(_earlier);
}
// delay the timelocks for all accounts
function setUnlockLater(uint256 _later) public onlyOwner {
later = later.add(_later);
}
// owner may permanently disable minting
function disableMint() public onlyOwner isMintable {
mintable_ = false;
}
// show if the token is still mintable
function mintable() public view returns (bool) {
return mintable_;
}
// standard ERC20 name function
function name() public view returns (string) {
return name_;
}
// standard ERC20 symbol function
function symbol() public view returns (string) {
return symbol_;
}
// standard ERC20 decimals function
function decimals() public view returns (uint8) {
return decimals_;
}
// standard ERC20 totalSupply function
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
// standard ERC20 allowance function
function allowance(address _owner, address _spender) external view returns (uint256) {
return allowed[_owner][_spender];
}
// show unlocked balance of an account
function balanceUnlocked(address _address) public view returns (uint256 _balance) {
_balance = balanceP[_address];
uint256 i = 0;
while (i < lockNum[_address]) {
if (now.add(earlier) >= lockTime[_address][i].add(later)) _balance = _balance.add(lockValue[_address][i]);
i++;
}
return _balance;
}
// show timelocked balance of an account
function balanceLocked(address _address) public view returns (uint256 _balance) {
_balance = 0;
uint256 i = 0;
while (i < lockNum[_address]) {
if (now.add(earlier) < lockTime[_address][i].add(later)) _balance = _balance.add(lockValue[_address][i]);
i++;
}
return _balance;
}
// standard ERC20 balanceOf with timelock added
function balanceOf(address _address) public view returns (uint256 _balance) {
_balance = balanceP[_address];
uint256 i = 0;
while (i < lockNum[_address]) {
_balance = _balance.add(lockValue[_address][i]);
i++;
}
return _balance;
}
// show timelocks in an account
function showLockTimes(address _address) public view validAddress(_address) returns (uint256[] _times) {
uint i = 0;
uint256[] memory tempLockTime = new uint256[](lockNum[_address]);
while (i < lockNum[_address]) {
tempLockTime[i] = lockTime[_address][i].add(later).sub(earlier);
i++;
}
return tempLockTime;
}
// show values locked in an account's timelocks
function showLockValues(address _address) public view validAddress(_address) returns (uint256[] _values) {
return lockValue[_address];
}
function showLockNum(address _address) public view validAddress(_address) returns (uint256 _lockNum) {
return lockNum[_address];
}
// Calculate and process the timelock states of an account
function calcUnlock(address _address) private {
uint256 i = 0;
uint256 j = 0;
uint256[] memory currentLockTime;
uint256[] memory currentLockValue;
uint256[] memory newLockTime = new uint256[](lockNum[_address]);
uint256[] memory newLockValue = new uint256[](lockNum[_address]);
currentLockTime = lockTime[_address];
currentLockValue = lockValue[_address];
while (i < lockNum[_address]) {
if (now.add(earlier) >= currentLockTime[i].add(later)) {
balanceP[_address] = balanceP[_address].add(currentLockValue[i]);
emit TokenUnlocked(_address, currentLockValue[i]);
} else {
newLockTime[j] = currentLockTime[i];
newLockValue[j] = currentLockValue[i];
j++;
}
i++;
}
uint256[] memory trimLockTime = new uint256[](j);
uint256[] memory trimLockValue = new uint256[](j);
i = 0;
while (i < j) {
trimLockTime[i] = newLockTime[i];
trimLockValue[i] = newLockValue[i];
i++;
}
lockTime[_address] = trimLockTime;
lockValue[_address] = trimLockValue;
lockNum[_address] = j;
}
// standard ERC20 transfer
function transfer(address _to, uint256 _value) public validAddress(_to) returns (bool _success) {
if (lockNum[msg.sender] > 0) calcUnlock(msg.sender);
require(balanceP[msg.sender] >= _value && _value >= 0);
balanceP[msg.sender] = balanceP[msg.sender].sub(_value);
balanceP[_to] = balanceP[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
// transfer Token with timelocks
function transferLocked(address _to, uint256[] _time, uint256[] _value) public validAddress(_to) returns (bool _success) {
require(_value.length == _time.length);
if (lockNum[msg.sender] > 0) calcUnlock(msg.sender);
uint256 i = 0;
uint256 totalValue = 0;
while (i < _value.length) {
totalValue = totalValue.add(_value[i]);
i++;
}
require(balanceP[msg.sender] >= totalValue && totalValue >= 0);
require(lockNum[_to].add(_time.length) <= 42);
i = 0;
while (i < _time.length) {
if (_value[i] > 0) {
balanceP[msg.sender] = balanceP[msg.sender].sub(_value[i]);
lockTime[_to].length = lockNum[_to]+1;
lockValue[_to].length = lockNum[_to]+1;
lockTime[_to][lockNum[_to]] = now.add(_time[i]).add(earlier).sub(later);
lockValue[_to][lockNum[_to]] = _value[i];
lockNum[_to]++;
}
// emit custom TransferLocked event
emit TransferLocked(msg.sender, _to, _time[i], _value[i]);
// emit standard Transfer event for wallets
emit Transfer(msg.sender, _to, _value[i]);
i++;
}
return true;
}
// TransferFrom Token with timelocks
function transferLockedFrom(address _from, address _to, uint256[] _time, uint256[] _value) public
validAddress(_from) validAddress(_to) returns (bool success) {
require(_value.length == _time.length);
if (lockNum[_from] > 0) calcUnlock(_from);
uint256 i = 0;
uint256 totalValue = 0;
while (i < _value.length) {
totalValue = totalValue.add(_value[i]);
i++;
}
require(balanceP[_from] >= totalValue && totalValue >= 0 && allowed[_from][msg.sender] >= totalValue);
require(lockNum[_to].add(_time.length) <= 42);
i = 0;
while (i < _time.length) {
if (_value[i] > 0) {
balanceP[_from] = balanceP[_from].sub(_value[i]);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value[i]);
lockTime[_to].length = lockNum[_to]+1;
lockValue[_to].length = lockNum[_to]+1;
lockTime[_to][lockNum[_to]] = now.add(_time[i]).add(earlier).sub(later);
lockValue[_to][lockNum[_to]] = _value[i];
lockNum[_to]++;
}
// emit custom TransferLocked event
emit TransferLocked(_from, _to, _time[i], _value[i]);
// emit standard Transfer event for wallets
emit Transfer(_from, _to, _value[i]);
i++;
}
return true;
}
// standard ERC20 transferFrom
function transferFrom(address _from, address _to, uint256 _value) public validAddress(_from) validAddress(_to) returns (bool _success) {
if (lockNum[_from] > 0) calcUnlock(_from);
require(balanceP[_from] >= _value && _value >= 0 && allowed[_from][msg.sender] >= _value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
balanceP[_from] = balanceP[_from].sub(_value);
balanceP[_to] = balanceP[_to].add(_value);
emit Transfer(_from, _to, _value);
return true;
}
// should only be called when first setting an allowed
function approve(address _spender, uint256 _value) public validAddress(_spender) returns (bool _success) {
if (lockNum[msg.sender] > 0) calcUnlock(msg.sender);
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
// increase or decrease allowed
function increaseApproval(address _spender, uint _value) public validAddress(_spender) returns (bool _success) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_value);
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _value) public validAddress(_spender) returns (bool _success) {
if(_value >= allowed[msg.sender][_spender]) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].sub(_value);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
// owner may burn own token
function burn(uint256 _value) public onlyOwner returns (bool _success) {
if (lockNum[msg.sender] > 0) calcUnlock(msg.sender);
require(balanceP[msg.sender] >= _value && _value >= 0);
balanceP[msg.sender] = balanceP[msg.sender].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(msg.sender, _value);
return true;
}
// owner may mint new token and increase total supply
function mint(uint256 _value) public onlyOwner isMintable returns (bool _success) {
balanceP[msg.sender] = balanceP[msg.sender].add(_value);
totalSupply_ = totalSupply_.add(_value);
emit Mint(msg.sender, _value);
return true;
}
// safety methods
function () public payable {
revert();
}
function emptyWrongToken(address _addr) onlyOwner public {
ERC20Token wrongToken = ERC20Token(_addr);
uint256 amount = wrongToken.balanceOf(address(this));
require(amount > 0);
require(wrongToken.transfer(msg.sender, amount));
emit WrongTokenEmptied(_addr, msg.sender, amount);
}
// shouldn't happen, just in case
function emptyWrongEther() onlyOwner public {
uint256 amount = address(this).balance;
require(amount > 0);
msg.sender.transfer(amount);
emit WrongEtherEmptied(msg.sender, amount);
}
}
| 148,646 | 13,737 |
5b812cf704925a43e95d94e9ffa843f6103286c19250d2f4e085afa8edf356ef
| 27,091 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/61/61462FF437b630e0C2f1F4711f5B276c47Af2e63_Particle.sol
| 3,118 | 12,766 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC20/ERC20.sol)
// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)
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);
}
// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
// 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;
}
}
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 {}
}
// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC20/extensions/ERC20Burnable.sol)
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);
}
}
// OpenZeppelin Contracts v4.4.1 (security/ReentrancyGuard.sol)
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;
}
}
// OpenZeppelin Contracts (last updated v4.7.0) (security/Pausable.sol)
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());
}
}
interface IERC20Bound {
function unbind(address _addresses) external;
function isUnbound(address _addr) external view returns (bool);
}
interface IParticle is IERC20 {
function mintFor(address _for, uint256 _amount) external;
}
interface IManager {
function isAdmin(address _addr) external view returns (bool);
function isManager(address _addr, uint256 _type) external view returns (bool);
function addManager(address _addr, uint256 _type) external;
function removeManager(address _addr, uint256 _type) external;
function addAdmin(address _addr) external;
function removeAdmin(address _addr) external;
}
abstract contract ManagerModifier {
//=======================================
// Immutables
//=======================================
IManager public immutable MANAGER;
//=======================================
// Constructor
//=======================================
constructor(address _manager) {
MANAGER = IManager(_manager);
}
//=======================================
// Modifiers
//=======================================
modifier onlyAdmin() {
require(MANAGER.isAdmin(msg.sender), "Manager: Not an Admin");
_;
}
modifier onlyManager() {
require(MANAGER.isManager(msg.sender, 0), "Manager: Not manager");
_;
}
modifier onlyMinter() {
require(MANAGER.isManager(msg.sender, 1), "Manager: Not minter");
_;
}
modifier onlyTokenMinter() {
require(MANAGER.isManager(msg.sender, 2), "Manager: Not token minter");
_;
}
modifier onlyBinder() {
require(MANAGER.isManager(msg.sender, 3), "Manager: Not binder");
_;
}
}
contract Particle is
IParticle,
ERC20,
ERC20Burnable,
ManagerModifier,
ReentrancyGuard,
Pausable
{
//=======================================
// Immutables
//=======================================
IERC20Bound public immutable BOUND;
uint256 public immutable CAP;
//=======================================
// Constructor
//=======================================
constructor(address _manager,
address _bound,
uint256 _cap) ERC20("Particle", "PARTICLE") ManagerModifier(_manager) {
BOUND = IERC20Bound(_bound);
CAP = _cap;
}
//=======================================
// External
//=======================================
function mintFor(address _for, uint256 _amount)
external
override
onlyTokenMinter
{
// Check amount doesn't exceed cap
require(ERC20.totalSupply() + _amount <= CAP, "Particle: Cap exceeded");
// Mint
_mint(_for, _amount);
}
//=======================================
// Admin
//=======================================
function pause() external onlyAdmin {
_pause();
}
function unpause() external onlyAdmin {
_unpause();
}
//=======================================
// Internal
//=======================================
function _beforeTokenTransfer(address from,
address to,
uint256 amount) internal override {
// Call super
super._beforeTokenTransfer(from, to, amount);
// Check if sender is manager
if (!MANAGER.isManager(msg.sender, 0)) {
// Check if minting or burning
if (from != address(0) && to != address(0)) {
// Check if token is unbound
require(BOUND.isUnbound(address(this)), "Particle: Token not unbound");
}
}
// Check if contract is paused
require(!paused(), "Particle: Paused");
}
}
| 38,915 | 13,738 |
8a1e4ac54e184b70df95db2d48fc7343b96799fddab7b814757696e1a92ceda4
| 23,958 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0x86149c67e57c749d0a12e6d6c2bf1b616619bb29.sol
| 5,997 | 22,887 |
pragma solidity 0.5.11;
library AddressCalc {
function futureAddressCalc(address payable _origin, uint _nonce) internal pure returns (address) {
if(_nonce == 0x00) return address(uint160(uint256((keccak256(abi.encodePacked(byte(0xd6),
byte(0x94), _origin, byte(0x80)))))));
if(_nonce <= 0x7f) return address(uint160(uint256((keccak256(abi.encodePacked(byte(0xd6),
byte(0x94), _origin, byte(uint8(_nonce))))))));
if(_nonce <= 0xff) return address(uint160(uint256((keccak256(abi.encodePacked(byte(0xd7),
byte(0x94), _origin, byte(0x81), uint8(_nonce)))))));
if(_nonce <= 0xffff) return address(uint160(uint256((keccak256(abi.encodePacked(byte(0xd8),
byte(0x94), _origin, byte(0x82), uint16(_nonce)))))));
if(_nonce <= 0xffffff) return address(uint160(uint256((keccak256(abi.encodePacked(byte(0xd9),
byte(0x94), _origin, byte(0x83), uint24(_nonce)))))));
return address(uint160(uint256((keccak256(abi.encodePacked(byte(0xda), byte(0x94), _origin, byte(0x84), uint32(_nonce)))))));
}
}
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 BNY {
using SafeMath for uint256;
using AddressCalc for address payable;
event Deposit(address indexed _investor,
uint256 _investmentValue,
uint256 _ID,
uint256 _unlocktime,
string _investmentTerm);
event PassiveDeposit(address indexed _investor2,
uint256 _investmentValue2,
uint256 _ID2,
uint256 _unlocktime2,
uint256 _dailyIncome,
uint256 _investmentTime);
event Spent(address indexed _acclaimer,
uint256 indexed _amout);
event PassiveSpent(address indexed _acclaimer2,
uint256 indexed _amout2);
event Transfer(address indexed _from,
address indexed _to,
uint256 _value);
event Approval(address indexed _owner,
address indexed _spender,
uint256 _value);
string constant public name = "BANCACY";
string constant public symbol = "BNY";
string constant public standard = "BNY Token";
uint256 constant public decimals = 18 ;
uint256 private _totalSupply;
uint256 public totalInvestmentAfterInterest;
uint256 public investorIndex = 1;
uint256 public passiveInvestorIndex = 1;
uint256 constant public interestRate = 16;
uint256 constant public multiplicationForMidTerm = 5;
uint256 constant public multiplicationForLongTerm = 20;
uint256 public minForPassive = 1200000 * (10 ** uint256(decimals));
uint256 public tokensForSale = 534600000 * (10 ** uint256(decimals));
uint256 public tokensSold = 1 * (10 ** uint256(decimals));
uint256 constant public tokensPerWei = 54000;
uint256 constant public Percent = 1000000000;
uint256 constant internal secondsInDay = 86400;
uint256 constant internal secondsInWeek = 604800;
uint256 constant internal secondsInMonth = 2419200;
uint256 constant internal secondsInQuarter = 7257600;
uint256 constant internal daysInYear = 365;
uint256 internal _startSupply = 455400000 * (10 ** uint256(decimals));
address payable public fundsWallet;
address public XBNY;
address public BNY_DATA;
enum TermData {DEFAULT, ONE, TWO, THREE}
mapping(uint256 => Investment) private investors;
mapping(uint256 => PassiveIncome) private passiveInvestors;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
struct Investment {
address investorAddress;
uint256 investedAmount;
uint256 investmentUnlocktime;
bool spent;
string term;
}
struct PassiveIncome {
address investorAddress2;
uint256 investedAmount2;
uint256 dailyPassiveIncome;
uint256 investmentTimeStamp;
uint256 investmentUnlocktime2;
uint256 day;
bool spent2;
}
constructor (address payable _fundsWallet) public {
_totalSupply = _startSupply;
fundsWallet = _fundsWallet;
_balances[fundsWallet] = _startSupply;
_balances[address(1)] = 0;
emit Transfer(address(1),
fundsWallet,
_startSupply);
XBNY = _msgSender().futureAddressCalc(1);
BNY_DATA = _msgSender().futureAddressCalc(2);
}
function () external payable{
require(tokensSold < tokensForSale, "All tokens are sold");
require(msg.value > 0, "Value must be > 0");
uint256 eth = msg.value;
uint256 tokens = eth.mul(tokensPerWei);
uint256 bounosTokens = getDiscountOnBuy(tokens);
uint256 totalTokens = bounosTokens.add(tokens);
require(totalTokens <= (tokensForSale).sub(tokensSold), "All tokens are sold");
fundsWallet.transfer(msg.value);
tokensSold = tokensSold.add((totalTokens));
_totalSupply = _totalSupply.add((totalTokens));
_balances[_msgSender()] = _balances[_msgSender()].add((totalTokens));
emit Transfer(address(0),
_msgSender(),
totalTokens);
}
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function transfer(address recipient, uint256 amount) public returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function approve(address spender, uint256 value) public returns (bool) {
_approve(_msgSender(), spender, value);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
_transfer(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 returns (uint256) {
return _allowances[owner][spender];
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
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, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _approve(address owner, address spender, uint256 value) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = value;
emit Approval(owner, spender, value);
}
function burn(uint256 amount) public {
_burn(_msgSender(), amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function makeInvestment(uint256 _unlockTime, uint256 _amount, uint term123) external returns (uint256) {
require(_balances[_msgSender()] >= _amount, "You dont have sufficent amount of tokens");
require(_amount > 0, "Investment amount should be bigger than 0");
require(_unlockTime >= secondsInWeek && (_unlockTime.mod(secondsInWeek)) == 0, "Wrong investment time");
uint256 termAfter = (_unlockTime.div(secondsInWeek));
uint256 currentInvestor = investorIndex;
if((termAfter >= 1) &&
(termAfter <= 48) &&
(term123 == uint(TermData.ONE)))
{
investorIndex++;
totalInvestmentAfterInterest = _amount.add(getInterestRate(_amount, termAfter));
investors[currentInvestor] = Investment(_msgSender(),
totalInvestmentAfterInterest,
block.timestamp.add(_unlockTime),
false,
"short");
emit Deposit(_msgSender(),
_amount,
currentInvestor,
block.timestamp.add(_unlockTime),
"SHORT-TERM");
emit Transfer(_msgSender(),
address(1),
_amount);
emit Transfer(address(1),
address(1),
totalInvestmentAfterInterest.sub(_amount));
_balances[_msgSender()] = _balances[_msgSender()].sub(_amount);
_balances[address(1)] = _balances[address(1)].add(totalInvestmentAfterInterest);
_totalSupply = _totalSupply.sub(_amount);
return (currentInvestor);
}
termAfter = (_unlockTime.div(secondsInMonth));
if((_unlockTime >= secondsInMonth) &&
(term123 == uint(TermData.TWO)) &&
(termAfter <= 12) &&
(_unlockTime.mod(secondsInMonth)) == 0) {
investorIndex++;
totalInvestmentAfterInterest = _amount.add(getInterestRate(_amount, multiplicationForMidTerm).mul(termAfter));
investors[currentInvestor] = Investment(_msgSender(),
totalInvestmentAfterInterest,
block.timestamp.add(_unlockTime),
false,
"mid");
emit Deposit(_msgSender(),
_amount,
currentInvestor,
block.timestamp.add(_unlockTime),
"MID-TERM");
emit Transfer(_msgSender(),
address(1),
_amount);
emit Transfer(address(1),
address(1),
totalInvestmentAfterInterest.sub(_amount));
_balances[_msgSender()] = _balances[_msgSender()].sub(_amount);
_balances[address(1)] = _balances[address(1)].add(totalInvestmentAfterInterest);
_totalSupply = _totalSupply.sub(_amount);
return (currentInvestor);
}
termAfter = (_unlockTime.div(secondsInQuarter));
if((_unlockTime >= secondsInQuarter) &&
(term123 == uint(TermData.THREE)) &&
(termAfter <= 12) &&
(_unlockTime.mod(secondsInQuarter) == 0)) {
investorIndex++;
totalInvestmentAfterInterest = _amount.add(getInterestRate(_amount, multiplicationForLongTerm).mul(termAfter));
investors[currentInvestor] = Investment(_msgSender(),
totalInvestmentAfterInterest,
block.timestamp.add(_unlockTime),
false,
"long");
emit Deposit(_msgSender(),
_amount,
currentInvestor,
block.timestamp.add(_unlockTime),
"LONG-TERM");
emit Transfer(_msgSender(),
address(1),
_amount);
emit Transfer(address(1),
address(1),
totalInvestmentAfterInterest.sub(_amount));
_balances[_msgSender()] = _balances[_msgSender()].sub(_amount);
_balances[address(1)] = _balances[address(1)].add(totalInvestmentAfterInterest);
_totalSupply = _totalSupply.sub(_amount);
return (currentInvestor);
}
}
function releaseInvestment(uint256 _investmentId) external returns (bool success) {
require(investors[_investmentId].investorAddress == _msgSender(), "Only the investor can claim the investment");
require(investors[_investmentId].spent == false, "The investment is already spent");
require(investors[_investmentId].investmentUnlocktime < block.timestamp, "Unlock time for the investment did not pass");
investors[_investmentId].spent = true;
_totalSupply = _totalSupply.add(investors[_investmentId].investedAmount);
_balances[address(1)] = _balances[address(1)].sub(investors[_investmentId].investedAmount);
_balances[_msgSender()] = _balances[_msgSender()].add(investors[_investmentId].investedAmount);
emit Transfer(address(1),
_msgSender(),
investors[_investmentId].investedAmount);
emit Spent(_msgSender(),
investors[_investmentId].investedAmount);
return true;
}
function makePassiveIncomeInvestment(uint256 _amount) external returns (uint256) {
require(_balances[_msgSender()] >= _amount, "You have insufficent amount of tokens");
require(_amount >= minForPassive, "Investment amount should be bigger than 1.2M");
uint256 interestOnInvestment = getInterestRate(_amount, 75).div(daysInYear);
uint256 currentInvestor = passiveInvestorIndex;
passiveInvestorIndex++;
passiveInvestors[currentInvestor] = PassiveIncome(_msgSender(),
_amount,
interestOnInvestment,
block.timestamp,
block.timestamp.add(secondsInDay * daysInYear),
1,
false);
emit Transfer(_msgSender(),
address(1),
_amount);
emit Transfer(address(1),
address(1),
interestOnInvestment.mul(daysInYear));
emit PassiveDeposit(_msgSender(),
_amount,
currentInvestor,
block.timestamp.add((secondsInDay * daysInYear)),
passiveInvestors[currentInvestor].dailyPassiveIncome,
passiveInvestors[currentInvestor].investmentTimeStamp);
_balances[_msgSender()] = _balances[_msgSender()].sub(_amount);
_balances[address(1)] = _balances[address(1)].add((interestOnInvestment.mul(daysInYear)).add(_amount));
_totalSupply = _totalSupply.sub(_amount);
return (currentInvestor);
}
function releasePassiveIncome(uint256 _passiveIncomeID) external returns (bool success) {
require(passiveInvestors[_passiveIncomeID].investorAddress2 == _msgSender(), "Only the investor can claim the investment");
require(passiveInvestors[_passiveIncomeID].spent2 == false, "The investment is already claimed");
require(passiveInvestors[_passiveIncomeID].investmentTimeStamp.add((secondsInDay * passiveInvestors[_passiveIncomeID].day)) < block.timestamp,
"Unlock time for the investment did not pass");
require(passiveInvestors[_passiveIncomeID].day < 366, "The investment is already claimed");
uint256 totalReward = 0;
uint256 numberOfDaysHeld = (block.timestamp - passiveInvestors[_passiveIncomeID].investmentTimeStamp) / secondsInDay;
if(numberOfDaysHeld > daysInYear){
passiveInvestors[_passiveIncomeID].spent2 = true;
numberOfDaysHeld = daysInYear;
totalReward = passiveInvestors[_passiveIncomeID].investedAmount2;
}
uint numberOfDaysOwed = numberOfDaysHeld - (passiveInvestors[_passiveIncomeID].day - 1);
uint totalDailyPassiveIncome = passiveInvestors[_passiveIncomeID].dailyPassiveIncome * numberOfDaysOwed;
passiveInvestors[_passiveIncomeID].day = numberOfDaysHeld.add(1);
totalReward = totalReward.add(totalDailyPassiveIncome);
if(totalReward > 0){
_totalSupply = _totalSupply.add(totalReward);
_balances[address(1)] = _balances[address(1)].sub(totalReward);
_balances[_msgSender()] = _balances[_msgSender()].add(totalReward);
emit Transfer(address(1),
_msgSender(),
totalReward);
emit PassiveSpent(_msgSender(),
totalReward);
return true;
}
else{
revert("There is no total reward earned.");
}
}
function BNY_AssetSolidification(address _user, uint256 _value) external returns (bool success) {
require(_msgSender() == BNY_DATA, "No Permission");
require(_balances[_user] >= _value, "User have incufficent balance");
_balances[_user] = _balances[_user].sub(_value);
_totalSupply = _totalSupply.sub(_value);
emit Transfer(_user,
address(2),
_value);
return true;
}
function BNY_AssetDesolidification(address _user,uint256 _value) external returns (bool success) {
require(_msgSender() == BNY_DATA, "No Permission");
_balances[_user] = _balances[_user].add(_value);
_totalSupply = _totalSupply.add(_value);
emit Transfer(address(2),
_user,
_value);
return true;
}
function getBalanceOf(address _user) external view returns (uint256 balance) {
require(_msgSender() == BNY_DATA, "No Permission");
return _balances[_user];
}
function getPassiveDetails (uint _passiveIncomeID) external view returns (address investorAddress2,
uint256 investedAmount2,
uint256 dailyPassiveIncome,
uint256 investmentTimeStamp,
uint256 investmentUnlocktime2,
uint256 day,
bool spent2){
return(passiveInvestors[_passiveIncomeID].investorAddress2,
passiveInvestors[_passiveIncomeID].investedAmount2,
passiveInvestors[_passiveIncomeID].dailyPassiveIncome,
passiveInvestors[_passiveIncomeID].investmentTimeStamp,
passiveInvestors[_passiveIncomeID].investmentUnlocktime2,
passiveInvestors[_passiveIncomeID].day,
passiveInvestors[_passiveIncomeID].spent2);
}
function getPassiveIncomeDay(uint256 _passiveIncomeID) external view returns (uint256) {
return(passiveInvestors[_passiveIncomeID].day);
}
function getPassiveIncomeStatus(uint256 _passiveIncomeID) external view returns (bool) {
return (passiveInvestors[_passiveIncomeID].spent2);
}
function getPassiveInvestmentTerm(uint256 _passiveIncomeID) external view returns (uint256){
return (passiveInvestors[_passiveIncomeID].investmentUnlocktime2);
}
function getPassiveNumberOfDays (uint _passiveIncomeID) external view returns (uint256){
return (block.timestamp - passiveInvestors[_passiveIncomeID].investmentTimeStamp) / secondsInDay;
}
function getPassiveInvestmentTimeStamp(uint256 _passiveIncomeID) external view returns (uint256){
return (passiveInvestors[_passiveIncomeID].investmentTimeStamp);
}
function getInvestmentStatus(uint256 _ID) external view returns (bool){
return (investors[_ID].spent);
}
function getInvestmentTerm(uint256 _ID) external view returns (uint256){
return (investors[_ID].investmentUnlocktime);
}
function getDiscountOnBuy(uint256 _tokensAmount) public view returns (uint256 discount) {
uint256 tokensSoldADJ = tokensSold.mul(1000000000);
uint256 discountPercentage = tokensSoldADJ.div(tokensForSale);
uint256 adjustedDiscount = (Percent.sub(discountPercentage)).mul(2500);
uint256 DiscountofTokens = (adjustedDiscount.mul(_tokensAmount));
return((DiscountofTokens).div(10000000000000));
}
function getBlockTimestamp () external view returns (uint blockTimestamp){
return block.timestamp;
}
function getInterestRate(uint256 _investment, uint _term) public view returns (uint256 rate) {
require(_investment < _totalSupply, "The investment is too large");
uint256 totalinvestments = _balances[address(1)].mul(Percent);
uint256 investmentsPercentage = totalinvestments.div(_totalSupply);
uint256 adjustedinterestrate = (Percent.sub(investmentsPercentage)).mul(interestRate);
uint256 interestoninvestment = (adjustedinterestrate.mul(_investment)).div(10000000000000);
return (interestoninvestment.mul(_term));
}
function getSimulatedDailyIncome (uint _passiveIncomeID) external view returns (uint _numberOfDaysHeld,
uint _numberOfDaysOwed,
uint _totalDailyPassiveIncome,
uint _dailyPassiveIncome,
uint _totalReward,
uint _day,
bool _spent){
_spent = false;
_numberOfDaysHeld = (block.timestamp - passiveInvestors[_passiveIncomeID].investmentTimeStamp) / secondsInDay;
if(_numberOfDaysHeld > daysInYear){
_numberOfDaysHeld = daysInYear;
_totalReward = passiveInvestors[_passiveIncomeID].investedAmount2;
_spent = true;
}
_numberOfDaysOwed = _numberOfDaysHeld - (passiveInvestors[_passiveIncomeID].day - 1);
_totalDailyPassiveIncome = passiveInvestors[_passiveIncomeID].dailyPassiveIncome * _numberOfDaysOwed;
_day = _numberOfDaysHeld.add(1);
_totalReward = _totalReward.add(_totalDailyPassiveIncome);
_dailyPassiveIncome = passiveInvestors[_passiveIncomeID].dailyPassiveIncome;
return (_numberOfDaysHeld,
_numberOfDaysOwed,
_totalDailyPassiveIncome,
_dailyPassiveIncome,
_totalReward,
_day,
_spent);
}
}
| 164,183 | 13,739 |
5349d4248bac51959076621bdf458ee026235eda5a3a8b036213e0f912cfb444
| 22,368 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TL/TLVXv2r9iJN2SqpE81u5H4VJWWfker9NXX_TronExtract.sol
| 6,017 | 21,654 |
//SourceUnit: TronExtract.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;
uint256 level1RefCount;
uint256 level2RefCount;
uint256 level3RefCount;
uint256 level4RefCount;
uint256 level5RefCount;
}
}
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 TronExtract is Ownable {
using SafeMath for uint256;
uint256 private constant INTEREST_CYCLE = 1 days;
uint256 private constant DEVELOPER_ENTRY_RATE = 20; //per thousand
uint256 private constant ADMIN_ENTRY_RATE = 140;
uint256 private constant REFERENCE_RATE = 125;
uint256 private constant ADMIN_EXIT_RATE = 70;
uint256 public constant REFERENCE_LEVEL1_RATE = 50;
uint256 public constant REFERENCE_LEVEL2_RATE = 20;
uint256 public constant REFERENCE_LEVEL3_RATE = 5;
uint256 public constant REFERENCE_LEVEL4_RATE = 10;
uint256 public constant REFERENCE_LEVEL5_RATE = 40;
uint256 public constant MINIMUM = 10000000; //minimum investment needed
uint256 public constant REFERRER_CODE = 9100; //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);
}
}
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(16, 114 * 60 * 60 * 24, 16));
investmentPlans_.push(Objects.Plan(26, 54 * 60 * 60 * 24, 26));
investmentPlans_.push(Objects.Plan(36, 34 * 60 * 60 * 24, 36));
investmentPlans_.push(Objects.Plan(46, 24 * 60 * 60 * 24, 46));
}
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, uint256, uint256, uint256, uint256, 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);
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);
}
}
}
return
(investor.referrerEarnings,
investor.availableReferrerEarnings,
investor.referrer,
investor.level1RefCount,
investor.level2RefCount,
investor.level3RefCount,
investor.level4RefCount,
investor.level5RefCount,
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] = (numberOfDays < 10) ? investmentPlans_[investor.plans[i].planId].dailyInterest + numberOfDays : 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] = (numberOfDays < 10) ? investmentPlans_[investor.plans[i].planId].dailyInterest + numberOfDays : 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;
if (_referrerCode >= REFERRER_CODE) {
uint256 _ref1 = _referrerCode;
uint256 _ref2 = uid2Investor[_ref1].referrer;
uint256 _ref3 = uid2Investor[_ref2].referrer;
uint256 _ref4 = uid2Investor[_ref3].referrer;
uint256 _ref5 = uid2Investor[_ref4].referrer;
uid2Investor[_ref1].level1RefCount = uid2Investor[_ref1].level1RefCount.add(1);
// if (_ref2 >= REFERRER_CODE) {
uid2Investor[_ref2].level2RefCount = uid2Investor[_ref2].level2RefCount.add(1);
// }
// else if (_ref3 >= REFERRER_CODE) {
uid2Investor[_ref3].level3RefCount = uid2Investor[_ref3].level3RefCount.add(1);
// }
// else if (_ref4 >= REFERRER_CODE) {
uid2Investor[_ref4].level4RefCount = uid2Investor[_ref4].level4RefCount.add(1);
// }
// else if (_ref5 >= REFERRER_CODE) {
uid2Investor[_ref5].level5RefCount = uid2Investor[_ref5].level5RefCount.add(1);
uid2Investor[_ref5].level5RefCount++;
// }
}
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 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(ADMIN_EXIT_RATE)).div(1000);
developerAccount_.transfer(developerPercentage);
msg.sender.transfer(withdrawalAmount.sub(developerPercentage));
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 _ref2 = uid2Investor[_ref1].referrer;
uint256 _ref3 = uid2Investor[_ref2].referrer;
uint256 _ref4 = uid2Investor[_ref3].referrer;
uint256 _ref5 = uid2Investor[_ref4].referrer;
uint256 _refAmount = 0;
if (_ref1 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL1_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref1].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref1].availableReferrerEarnings);
}
if (_ref2 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL2_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref2].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref2].availableReferrerEarnings);
}
if (_ref3 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL3_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref3].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref3].availableReferrerEarnings);
}
if (_ref4 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL4_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref4].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref4].availableReferrerEarnings);
}
if (_ref5 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL5_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref5].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref5].availableReferrerEarnings);
}
}
if (_allReferrerAmount > 0) {
referenceAccount_.transfer(_allReferrerAmount);
}
}
}
| 285,562 | 13,740 |
10c3cea639d46b5bf611d4affd81a3fc6d02ef39ae9c73cf1a2e0f7661d25d86
| 34,446 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/1d/1d0cc66c18863c986c3cf6c318b4eac009c171e9_AddressUpgradeable.sol
| 6,227 | 22,081 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
library AddressUpgradeable {
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 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);
}
}
}
}
abstract contract Initializable {
bool private _initialized;
bool private _initializing;
modifier initializer() {
// If the contract is initializing we ignore whether _initialized is set in order to support multiple
// contract may have been reentered.
require(_initializing ? _isConstructor() : !_initialized, "Initializable: contract is already initialized");
bool isTopLevelCall = !_initializing;
if (isTopLevelCall) {
_initializing = true;
_initialized = true;
}
_;
if (isTopLevelCall) {
_initializing = false;
}
}
modifier onlyInitializing() {
require(_initializing, "Initializable: contract is not initializing");
_;
}
function _isConstructor() private view returns (bool) {
return !AddressUpgradeable.isContract(address(this));
}
}
abstract contract ReentrancyGuardUpgradeable is Initializable {
// 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;
function __ReentrancyGuard_init() internal onlyInitializing {
__ReentrancyGuard_init_unchained();
}
function __ReentrancyGuard_init_unchained() internal onlyInitializing {
_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;
}
uint256[49] private __gap;
}
abstract contract ContextUpgradeable is Initializable {
function __Context_init() internal onlyInitializing {
__Context_init_unchained();
}
function __Context_init_unchained() internal onlyInitializing {
}
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
uint256[50] private __gap;
}
abstract contract OwnableUpgradeable is Initializable, ContextUpgradeable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function __Ownable_init() internal onlyInitializing {
__Context_init_unchained();
__Ownable_init_unchained();
}
function __Ownable_init_unchained() internal onlyInitializing {
_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);
}
uint256[49] private __gap;
}
interface IERC20Upgradeable {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IHACK is IERC20Upgradeable{
function earnTokens(address to, uint256 amount) external;
function lostTokens(address from, uint256 amount) external;
}
interface ISKILL is IERC20Upgradeable{
function earnTokens(address to, uint256 amount) external;
function lostTokens(address from, uint256 amount) external;
}
interface IERC20MetadataUpgradeable is IERC20Upgradeable {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
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 GAME is OwnableUpgradeable, ReentrancyGuardUpgradeable{
struct StakeNFT{
uint256 cube_id;
uint date_start;
uint8 active;
}
struct StakeToken{
uint date_start;
uint8 active;
uint256 amount;
}
struct Fees{
uint256 amount;
uint256 date;
}
uint8 constant WALLS = 0;
uint8 constant FLOOR = 1;
uint8 constant PC = 2;
uint8 constant TABLE = 3;
uint8 constant CONSOLE =4;
uint256 private _fee;
address private _token;
uint256 private _price;
uint256 private _skills_reward;
uint256 private _stake_pool;
uint256 private _liquidity_pool;
uint256 private _levelUpPrice;
IERC721 private _hacker_nft;
IERC721 private _cube_nft;
ISKILL private _skills;
IHACK private _hack;
uint256 private _hacker_base_rewards;
mapping(address => mapping(uint256 => Fees)) private _fees;
mapping(address => mapping(uint256 => StakeNFT)) private _nft_stakes;
mapping(address => StakeToken) private _token_stakes;
mapping(uint256 => uint8) private _hacker_levels;
mapping(uint256 => uint8) private _hacker_legendary;
mapping(uint256 => mapping(uint8 => uint8)) private _cube_levels;
mapping(uint8 => mapping(uint8 => uint256)) private _cube_rewards;
mapping(uint8 => mapping(uint8 => uint256)) private _cube_upgrade_price;
event NFTStaked(address indexed sender, uint256 indexed hacker_id, uint256 indexed cube_id);
event NFTUnStaked(address indexed sender, uint256 indexed hacker_id, uint256 indexed cube_id);
event TokenStaked(address indexed sender, uint256 amount);
event TokenUnStaked(address indexed sender, uint256 amount);
function initialize() initializer public {
__Ownable_init();
__ReentrancyGuard_init();
_price = 0.03 ether;
_cube_rewards[WALLS][0] = 100; // x1.0
_cube_rewards[WALLS][1] = 110; // x1.1
_cube_rewards[WALLS][2] = 130; // x1.3
_cube_rewards[WALLS][3] = 150; // x1.5
_cube_rewards[WALLS][4] = 200; // x2
_cube_rewards[FLOOR][0] = 100;
_cube_rewards[FLOOR][1] = 110;
_cube_rewards[FLOOR][2] = 130;
_cube_rewards[FLOOR][3] = 150;
_cube_rewards[FLOOR][4] = 200;
_cube_rewards[PC][0] = 0.5 ether;
_cube_rewards[PC][1] = 1.5 ether;
_cube_rewards[PC][2] = 3 ether;
_cube_rewards[PC][3] = 10 ether;
_cube_rewards[PC][4] = 25 ether;
_cube_rewards[TABLE][0] = 0.3 ether;
_cube_rewards[TABLE][1] = 1 ether;
_cube_rewards[TABLE][2] = 3 ether;
_cube_rewards[TABLE][3] = 8 ether;
_cube_rewards[TABLE][4] = 20 ether;
_cube_rewards[CONSOLE][0] = 0.2 ether; // 1%
_cube_rewards[CONSOLE][1] = 1 ether; // 1%
_cube_rewards[CONSOLE][2] = 2 ether; // 1%
_cube_rewards[CONSOLE][3] = 5 ether; // 1%
_cube_rewards[CONSOLE][4] = 15 ether; // 1%
_cube_upgrade_price[WALLS][0] = 0; // x1.0
_cube_upgrade_price[WALLS][1] = 100 ether; // x1.1
_cube_upgrade_price[WALLS][2] = 500 ether; // x1.3
_cube_upgrade_price[WALLS][3] = 1000 ether; // x1.5
_cube_upgrade_price[WALLS][4] = 3000 ether; // x2
_cube_upgrade_price[FLOOR][0] = 0;
_cube_upgrade_price[FLOOR][1] = 100 ether;
_cube_upgrade_price[FLOOR][2] = 500 ether;
_cube_upgrade_price[FLOOR][3] = 1000 ether;
_cube_upgrade_price[FLOOR][4] = 3000 ether;
_cube_upgrade_price[PC][0] = 0;
_cube_upgrade_price[PC][1] = 150 ether;
_cube_upgrade_price[PC][2] = 270 ether;
_cube_upgrade_price[PC][3] = 700 ether;
_cube_upgrade_price[PC][4] = 1750 ether;
_cube_upgrade_price[TABLE][0] = 0 ether;
_cube_upgrade_price[TABLE][1] = 100 ether;
_cube_upgrade_price[TABLE][2] = 270 ether;
_cube_upgrade_price[TABLE][3] = 700 ether;
_cube_upgrade_price[TABLE][4] = 1500 ether;
_cube_upgrade_price[CONSOLE][0] = 0 ether; // 1%
_cube_upgrade_price[CONSOLE][1] = 100 ether; // 1%
_cube_upgrade_price[CONSOLE][2] = 180 ether; // 1%
_cube_upgrade_price[CONSOLE][3] = 450 ether; // 1%
_cube_upgrade_price[CONSOLE][4] = 1200 ether; // 1%
_hacker_base_rewards = 0.05 ether;
_skills_reward = 0.001 ether;
_fee = 0.01 ether;
}
function updateHackerLevels(uint256[] memory ids, uint8[] memory levels) external onlyOwner{
require(levels.length == ids.length,"Error in length");
for(uint i=0;i<ids.length;i++){
_hacker_levels[ids[i]]=levels[i];
}
}
function updateHackerLegendary(uint256[] memory ids) external onlyOwner{
for(uint i=0;i<ids.length;i++){
_hacker_legendary[ids[i]]=1;
}
}
function updateHackerLevel(uint256 id) external nonReentrant{
uint256 need_hack = (1 + _hacker_levels[id] * 5 / 100) * (2 + _hacker_levels[id] / 100);
uint256 need_skill =10 * (1 + _hacker_levels[id] * 5 / 100) * (2 + _hacker_levels[id] / 100);
require(_hack.allowance(msg.sender, address(this)) >= need_hack, "Not enough $HACK");
require(_skills.allowance(msg.sender, address(this)) >= need_skill, "Not enough $SKILL");
require(_hacker_nft.ownerOf(id) == msg.sender ,"Not owner of the NFT");
_hacker_levels[id] +=1;
_hack.transferFrom(msg.sender, address(this), need_hack);
_skills.transferFrom(msg.sender, address(this), need_skill);
}
function updateCubeLevel(uint256 id, uint8 upgrade) external nonReentrant{
uint256 need_hack = _cube_upgrade_price[upgrade][_cube_levels[id][upgrade]];
require(upgrade >=0 && upgrade <5, "Illegal upgrade type");
require(_hack.allowance(msg.sender, address(this)) >= need_hack, "Not enough $HACK");
require(_hacker_nft.ownerOf(id) == msg.sender ,"Not owner of the NFT");
_cube_levels[id][upgrade] +=1;
_hack.transferFrom(msg.sender, address(this), need_hack);
}
function setFee(uint256 fee) external onlyOwner{
_fee = fee;
}
function payFee(uint256 id) external payable{
require(msg.value >= _fee, "Not enough fee");
if (_fees[msg.sender][id].amount >= _fee){
_fees[msg.sender][id].amount = _fee;
_fees[msg.sender][id].date = block.timestamp;
}else{
_fees[msg.sender][id].amount = _fee;
}
}
function payAllFees(uint256[] memory ids) external payable{
require(msg.value >= _fee * ids.length, "Not enough fee");
for(uint256 i=0;i<ids.length; i++){
uint256 id=ids[i];
if (_fees[msg.sender][id].amount >= _fee){
_fees[msg.sender][id].amount = _fee;
_fees[msg.sender][id].date = block.timestamp;
}else{
_fees[msg.sender][id].amount = _fee;
}
}
}
function updateSkillContract(address token) external onlyOwner{
_skills = ISKILL(token);
}
function updateHackerNTFContract(address nft) external onlyOwner{
_hacker_nft = IERC721(nft);
}
function updateCubeNTFContract(address nft) external onlyOwner{
_cube_nft = IERC721(nft);
}
function updateHackContract(address token) external onlyOwner{
_hack = IHACK(token);
}
function stakeHack(uint256 amount) external nonReentrant{
require(_hack.balanceOf(msg.sender) >= amount, "Amount is more than balance");
(msg.sender, address(this), amount);
_token_stakes[msg.sender].date_start=block.timestamp;
_token_stakes[msg.sender].active=1;
_token_stakes[msg.sender].amount=amount;
emit TokenStaked(msg.sender, amount);
}
function claimHack() external nonReentrant{
require(address(_skills) != address(0x0), "Skills not activated");
require(_token_stakes[msg.sender].active == 1, "Stake is not active");
_hack.earnTokens(msg.sender, _token_stakes[msg.sender].amount);
uint256 days_past = (block.timestamp - _token_stakes[msg.sender].date_start) / 86400;
_token_stakes[msg.sender].active=0;
emit TokenStaked(msg.sender, _token_stakes[msg.sender].amount);
uint256 reward = days_past * _skills_reward;
_stake_pool-=_token_stakes[msg.sender].amount;
_token_stakes[msg.sender].amount=0;
if (days_past == 0){
_hack.lostTokens(msg.sender, _hack.balanceOf(msg.sender) * 75 / 100);
}else{
if (_skills.balanceOf(address(this)) >= reward){
_skills.transfer(msg.sender, reward);
}else{
_skills.transfer(msg.sender, _skills.balanceOf(address(this)));
}
}
}
function stakeHacker(uint256 hacker_id) external nonReentrant{
require(_hacker_nft.ownerOf(hacker_id) == msg.sender, "Not owner of token");
_hacker_nft.transferFrom(msg.sender, address(this), hacker_id);
_nft_stakes[msg.sender][hacker_id].date_start=block.timestamp;
_nft_stakes[msg.sender][hacker_id].active=1;
_nft_stakes[msg.sender][hacker_id].cube_id=0x0;
emit NFTStaked(msg.sender, hacker_id,0x0);
}
function stakeHackerAndCube(uint256 hacker_id, uint256 cube_id) external nonReentrant{
require(_hacker_nft.ownerOf(hacker_id) == msg.sender, "Not owner of HACKER token");
require(_cube_nft.ownerOf(cube_id) == msg.sender, "Not owner of CUBE token");
_hacker_nft.transferFrom(msg.sender, address(this), hacker_id);
_cube_nft.transferFrom(msg.sender, address(this), cube_id);
_nft_stakes[msg.sender][hacker_id].date_start=block.timestamp;
_nft_stakes[msg.sender][cube_id].active=1;
emit NFTStaked(msg.sender, hacker_id,cube_id);
}
function claimRewards(uint256 hacker_id)external nonReentrant{
uint256 hack_reward = 0;
uint256 skill_reward = 0;
require(_nft_stakes[msg.sender][hacker_id].active == 1, "Token is not staked");
require(_fees[msg.sender][hacker_id].date + 30 days > block.timestamp, "Need to pay a fee");
_nft_stakes[msg.sender][hacker_id].active = 0;
_hacker_nft.transferFrom(address(this), msg.sender, hacker_id);
uint256 days_past = (block.timestamp - _nft_stakes[msg.sender][hacker_id].date_start) / 86400;
hack_reward = days_past * _hacker_base_rewards;
if (_nft_stakes[msg.sender][hacker_id].cube_id != 0x0){
uint256 cube_id = _nft_stakes[msg.sender][hacker_id].cube_id;
_cube_nft.transferFrom(address(this), msg.sender, cube_id);
hack_reward += _cube_rewards[WALLS][_cube_levels[cube_id][WALLS]];
hack_reward += _cube_rewards[FLOOR][_cube_levels[cube_id][FLOOR]];
hack_reward += _cube_rewards[PC][_cube_levels[cube_id][PC]];
hack_reward += _cube_rewards[TABLE][_cube_levels[cube_id][TABLE]];
hack_reward += _cube_rewards[CONSOLE][_cube_levels[cube_id][CONSOLE]];
if (hacker_id == cube_id){
hack_reward = hack_reward * 25 / 100;
}
}
if (days_past == 0){
_hack.lostTokens(msg.sender, _hack.balanceOf(msg.sender) * 75 / 100);
}else{
if (days_past > 1 && days_past < 7){
hack_reward = hack_reward * 120 / 100;
}
if (days_past >=7 && days_past < 14){
hack_reward = hack_reward * 150 / 100;
}
if (days_past >=14){
hack_reward = hack_reward * 2;
}
if (_hacker_legendary[hacker_id] == 1){
hack_reward = hack_reward * 3;
skill_reward = skill_reward * 3;
}
_hack.earnTokens(msg.sender, hack_reward);
_skills.earnTokens(msg.sender, skill_reward);
}
emit NFTUnStaked(msg.sender, hacker_id,_nft_stakes[msg.sender][hacker_id].cube_id);
}
function withdraw(uint256 amount) external onlyOwner nonReentrant
{
require(address(this).balance >= amount, "Not enough balance");
AddressUpgradeable.sendValue(payable(msg.sender), amount);
}
}
| 105,342 | 13,741 |
b52cd107b7c1dc172f398264c7af75cdbf5d048bb0fc39df30963a031d1f799b
| 20,751 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TK/TKNAsZKAKcj8k6oyrWET111jcNJzGEj6Fz_Globalhelp.sol
| 5,427 | 19,321 |
//SourceUnit: globalhelp.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;
uint256 investDates;
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 Globalhelp is Ownable {
using SafeMath for uint256;
uint256 private constant INTEREST_CYCLE = 1 days;
uint256 private constant ADMIN_ENTRY_RATE = 100;
uint256 private constant REFERENCE_RATE = 210;
mapping(uint256 => uint256) public REFERENCE_LEVEL_RATE;
uint256 public constant MINIMUM = 100 trx; //minimum investment needed
uint256 public constant REFERRER_CODE = 1; //default
uint256 public latestReferrerCode;
uint256 private totalInvestments_;
uint256 private totalUser_;
uint256 private totalWithdrawn;
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 {
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 setReferenceAccount(address payable _newReferenceAccount) public onlyOwner {
require(_newReferenceAccount != address(0));
referenceAccount_ = _newReferenceAccount;
}
function getReferenceAccount() public view onlyOwner returns (address) {
return referenceAccount_;
}
function getInvestmentDate() public view returns (uint256) {
return block.timestamp;
}
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(220,15*60*60*24,220)); //15 days
investmentPlans_.push(Objects.Plan(250, 12*60*60*24,250)); //12 days
investmentPlans_.push(Objects.Plan(300, 90*60*60*24,300)); //10 days
REFERENCE_LEVEL_RATE[1]=80;
REFERENCE_LEVEL_RATE[2]=50;
REFERENCE_LEVEL_RATE[3]=30;
REFERENCE_LEVEL_RATE[4]=20;
REFERENCE_LEVEL_RATE[5]=20;
}
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 getTotalUsers() public view returns (uint256){
return totalUser_;
}
function getTotalWithdrawal() public view returns (uint256){
return totalWithdrawn;
}
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[](6);
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 < 6; 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<6)
{
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);
totalUser_ = totalUser_.add(1);
//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 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 ownerPercent = (withdrawalAmount.mul(5)).div(1000);
marketingAccount_.transfer(ownerPercent);
uint256 actual_amount=withdrawalAmount-ownerPercent;
msg.sender.transfer(actual_amount);
if (uid2Investor[uid].availableReferrerEarnings>0) {
uint256 ownerPercent1 = (uid2Investor[uid].availableReferrerEarnings.mul(5)).div(1000);
marketingAccount_.transfer(ownerPercent1);
uint256 remaining= uid2Investor[uid].availableReferrerEarnings-ownerPercent1;
msg.sender.transfer(remaining);
totalWithdrawn +=uid2Investor[uid].availableReferrerEarnings;
uid2Investor[uid].referrerEarnings = uid2Investor[uid].availableReferrerEarnings.add(uid2Investor[uid].referrerEarnings);
uid2Investor[uid].availableReferrerEarnings = 0;
}
totalWithdrawn +=withdrawalAmount;
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<6) {
_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);
}
}
function withdrawLostTRXFromBalance(uint256 _amount) public payable{
require(msg.sender == owner, "onlyOwner");
msg.sender.transfer(_amount);
}
}
| 299,601 | 13,742 |
ad08e12cfbf5c5d58257ce1ee9d13c9c47c98c577e3ce022d008422f13f2d8d8
| 13,450 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TQ/TQ59mBvoCazcrbqNzxm68UJwybdv46NtHw_justtron.sol
| 3,591 | 12,604 |
//SourceUnit: justtron.sol
// SPDX-License-Identifier: MIT
pragma solidity >=0.4.22 <0.7.0;
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 transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract justtron is Ownable {
uint256 overall_invested;
struct User {
bool referred;
address referred_by;
uint256 total_invested_amount;
uint256 profit_remaining;
uint256 referal_profit;
}
struct Referal_levels {
uint256 level_1;
uint256 level_2;
uint256 level_3;
uint256 level_4;
uint256 level_5;
}
struct Panel_1 {
uint256 invested_amount;
uint256 profit;
uint256 profit_withdrawn;
uint256 start_time;
uint256 exp_time;
bool time_started;
}
mapping(address => Panel_1) public panel_1;
mapping(address => User) public user_info;
mapping(address => Referal_levels) public refer_info;
mapping(uint8 => address) public top_10_investors;
function top_10() public {
for (uint8 i = 0; i < 10; i++) {
if (top_10_investors[i] == msg.sender) {
for (uint8 j = i; j < 11; j++) {
top_10_investors[j] = top_10_investors[j + 1];
}
}
}
for (uint8 i = 0; i < 10; i++) {
if (user_info[top_10_investors[i]].total_invested_amount < user_info[msg.sender].total_invested_amount) {
for (uint8 j = 10; j > i; j--) {
top_10_investors[j] = top_10_investors[j - 1];
}
top_10_investors[i] = msg.sender;
return;
}
}
}
// -------------------- PANEL 1 -------------------------------
// 10% : 20days bronze
function invest_panel1() public payable {
require(msg.value >= 50, "Please Enter Amount no less than 50");
if (panel_1[msg.sender].time_started == false) {
panel_1[msg.sender].start_time = now;
panel_1[msg.sender].time_started = true;
panel_1[msg.sender].exp_time = now + 20 days; //20*24*60*60
}
panel_1[msg.sender].invested_amount += msg.value;
user_info[msg.sender].total_invested_amount += msg.value;
overall_invested = overall_invested + msg.value;
referral_system(msg.value);
top_10();
//neg
if (panel1_days() <= 20) {
panel_1[msg.sender].profit += ((msg.value * 10 * (20 - panel1_days())) / (100)); //prof * 20
}
}
function is_plan_completed_p1() public view returns (bool) {
if (panel_1[msg.sender].exp_time != 0) {
if (now >= panel_1[msg.sender].exp_time) {
return true;
}
if (now < panel_1[msg.sender].exp_time) {
return false;
}
} else {
return false;
}
}
function plan_completed_p1() public returns (bool) {
if (panel_1[msg.sender].exp_time != 0) {
if (now >= panel_1[msg.sender].exp_time) {
reset_panel_1();
return true;
}
if (now < panel_1[msg.sender].exp_time) {
return false;
}
}
}
function current_profit_p1() public view returns (uint256) {
uint256 local_profit;
if (now <= panel_1[msg.sender].exp_time) {
if ((((panel_1[msg.sender].profit + panel_1[msg.sender].profit_withdrawn) * (now - panel_1[msg.sender].start_time)) / (20 * (1 days))) > panel_1[msg.sender].profit_withdrawn) {
// 20*1 days
local_profit = (((panel_1[msg.sender].profit + panel_1[msg.sender].profit_withdrawn) * (now - panel_1[msg.sender].start_time)) / (20 * (1 days))) - panel_1[msg.sender].profit_withdrawn; // 20* 1 days
return local_profit;
} else {
return 0;
}
}
if (now > panel_1[msg.sender].exp_time) {
return panel_1[msg.sender].profit;
}
}
function panel1_days() public view returns (uint256) {
if (panel_1[msg.sender].time_started == true) {
return ((now - panel_1[msg.sender].start_time) / (1 days)); //change to 24*60*60
} else {
return 0;
}
}
function is_valid_time() public view returns (bool) {
if (panel_1[msg.sender].time_started == true) {
return (now > l_l1()) && (now < u_l1());
} else {
return true;
}
}
function l_l1() public view returns (uint256) {
if (panel_1[msg.sender].time_started == true) {
return (1 days) * panel1_days() + panel_1[msg.sender].start_time; // 24*60*60 = 1 days
} else {
return now;
}
}
function u_l1() public view returns (uint256) {
if (panel_1[msg.sender].time_started == true) {
return ((1 days) * panel1_days() + panel_1[msg.sender].start_time + 10 hours);
} else {
return now + (10 hours); // 8*60*60 8 hours
}
}
function withdraw_profit_panel1() public payable {
uint256 current_profit = current_profit_p1();
panel_1[msg.sender].profit_withdrawn = panel_1[msg.sender].profit_withdrawn + current_profit;
//neg
panel_1[msg.sender].profit = panel_1[msg.sender].profit - current_profit;
msg.sender.transfer(current_profit);
withdraw_all_profit();
}
function reset_panel_1() private {
user_info[msg.sender].profit_remaining += panel_1[msg.sender].profit;
panel_1[msg.sender].invested_amount = 0;
panel_1[msg.sender].profit = 0;
panel_1[msg.sender].profit_withdrawn = 0;
panel_1[msg.sender].start_time = 0;
panel_1[msg.sender].exp_time = 0;
panel_1[msg.sender].time_started = false;
}
// ------------- withdraw remaining profit ---------------------
function withdraw_all_profit() public payable {
msg.sender.transfer(user_info[msg.sender].profit_remaining);
user_info[msg.sender].profit_remaining = 0;
}
function seconds_passed() public view returns (uint256) {
return now - panel_1[msg.sender].start_time;
}
//------------------- Referal System ------------------------
function refer(address ref_add) public {
require(user_info[msg.sender].referred == false, " Already referred ");
require(ref_add != msg.sender, " You cannot refer yourself ");
user_info[msg.sender].referred_by = ref_add;
user_info[msg.sender].referred = true;
address level1 = user_info[msg.sender].referred_by;
address level2 = user_info[level1].referred_by;
address level3 = user_info[level2].referred_by;
address level4 = user_info[level3].referred_by;
address level5 = user_info[level4].referred_by;
if ((level1 != msg.sender) && (level1 != address(0))) {
refer_info[level1].level_1 += 1;
}
if ((level2 != msg.sender) && (level2 != address(0))) {
refer_info[level2].level_2 += 1;
}
if ((level3 != msg.sender) && (level3 != address(0))) {
refer_info[level3].level_3 += 1;
}
if ((level4 != msg.sender) && (level4 != address(0))) {
refer_info[level4].level_4 += 1;
}
if ((level5 != msg.sender) && (level5 != address(0))) {
refer_info[level5].level_5 += 1;
}
}
function referral_system(uint256 amount) private {
address level1 = user_info[msg.sender].referred_by;
address level2 = user_info[level1].referred_by;
address level3 = user_info[level2].referred_by;
address level4 = user_info[level3].referred_by;
address level5 = user_info[level4].referred_by;
if ((level1 != msg.sender) && (level1 != address(0))) {
user_info[level1].referal_profit += (amount * 5) / (100);
}
if ((level2 != msg.sender) && (level2 != address(0))) {
user_info[level2].referal_profit += (amount * 2) / (100);
}
if ((level3 != msg.sender) && (level3 != address(0))) {
user_info[level3].referal_profit += ((amount * 3) / 2) / (100);
}
if ((level4 != msg.sender) && (level4 != address(0))) {
user_info[level4].referal_profit += ((amount * 3) / 2) / (100);
}
if ((level5 != msg.sender) && (level5 != address(0))) {
user_info[level5].referal_profit += (amount * 1) / (100);
}
}
function referal_withdraw(uint256 amount) public {
require(user_info[msg.sender].referal_profit >= amount, "Withdraw must be less than Profit");
user_info[msg.sender].referal_profit = user_info[msg.sender].referal_profit - amount;
msg.sender.transfer(amount);
}
function over_inv() public view returns (uint256) {
return overall_invested;
}
function SendTRXFromContract(address payable _address, uint256 _amount) public payable onlyOwner returns (bool){
require(_address != address(0), "error for transfer from the zero address");
_address.transfer(_amount);
return true;
}
function SendTRXToContract() public payable returns (bool) {
return true;
}
struct spin_info{
uint256 next_time_stamp;
}
mapping(address => spin_info) public user_spin;
function is_spinnable() public view returns(bool){
if(user_spin[msg.sender].next_time_stamp != 0){
if(now >= user_spin[msg.sender].next_time_stamp){
return true;
}else{
return false;
}
}else{
return true;
}
}
function spin_roll(uint256 amount) public payable{
require(is_spinnable(), 'you can spin wheel tomorrow');
msg.sender.transfer(amount);
user_spin[msg.sender].next_time_stamp = now + 1 hours;//1 hours
}
///////////// Dice game
mapping(address => uint256) public userResults ;
function pool() public payable {}
function placeBet(uint256 playerSorce , uint256 contractScore)public payable returns(bool){
if(playerSorce == contractScore){
msg.sender.transfer(msg.value) ;
}
if(playerSorce > contractScore){
userResults[msg.sender] += msg.value * 2 ;
}
return true;
}
function place_bet_from_profit(uint256 playerScore , uint256 contractScore) public payable returns(bool){
uint256 current_profit = current_profit_p1();
uint256 remaining_profit = user_info[msg.sender].profit_remaining;
if(playerScore == contractScore){
msg.sender.transfer(msg.value) ;
}
if(playerScore > contractScore){
userResults[msg.sender] += (current_profit + remaining_profit)*2;
panel_1[msg.sender].profit_withdrawn = panel_1[msg.sender].profit_withdrawn + current_profit;
//neg
panel_1[msg.sender].profit = panel_1[msg.sender].profit - current_profit;
user_info[msg.sender].profit_remaining = 0;
}
if(playerScore < contractScore){
panel_1[msg.sender].profit_withdrawn = panel_1[msg.sender].profit_withdrawn + current_profit;
//neg
panel_1[msg.sender].profit = panel_1[msg.sender].profit - current_profit;
user_info[msg.sender].profit_remaining = 0;
}
return true;
}
function withdraw_dice_profit(uint256 amt) public payable returns(bool){
require(userResults[msg.sender] != 0 , "User has no profits to be withdrawn") ;
require(amt <= userResults[msg.sender] , "Amount excedes balance") ;
userResults[msg.sender] -= amt ;
msg.sender.transfer(amt) ;
}
function getBalance() onlyOwner public view returns(uint){
return address(this).balance ;
}
}
| 289,804 | 13,743 |
70809d756ebb00e75ec79197ba65749aaee467faab3bdd94f4513ef8fc99f0e4
| 18,825 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/c6/c61e53fa8d1689bf030ae2bc26cd29f95bc4e6a6_Bomber.sol
| 4,186 | 15,794 |
// 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 Bomber 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 = 'BOMBER';
string private _symbol = 'BOMBER';
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(12);
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);
}
}
| 89,469 | 13,744 |
5f6f606355da76b936b91aeb4bf74a98f10b3abbd0710eb2e484daa7aeb81033
| 25,980 |
.sol
|
Solidity
| false |
454395313
|
solidproof/projects
|
e4944c9bb61ee5a4776813b37db72129ff648eb2
|
Crypto AI/Contracts/cryptoai.sol
| 4,685 | 17,218 |
// 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 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 CRYPTOAI is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 100000000 * 10**6 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
string private _name = 'Crypto AI';
string private _symbol = 'CAI';
uint8 private _decimals = 9;
uint256 public _maxTxAmount = 1000000 * 10**6 * 10**9;
uint8 public transfertimeout = 15;
address public uniswapPair;
mapping (address => uint256) public lastBuy;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function setMaxTxPercent(uint256 maxTxPercent) external onlyOwner() {
_maxTxAmount = _tTotal.mul(maxTxPercent).div(10**1);
}
function reflect(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if(sender != owner() && recipient != owner())
require(amount <= _maxTxAmount, "Transfer amount exceeds the maxTxAmount.");
//save last buy
if (sender == uniswapPair){
lastBuy[recipient] = block.timestamp;
}
//check if sell
if (recipient == uniswapPair){
require(block.timestamp >= lastBuy[sender] + transfertimeout, "anti bot 15 seconds lock");
}
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotal = _rTotal.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee) = _getTValues(tAmount);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee);
}
function _getTValues(uint256 tAmount) private pure returns (uint256, uint256) {
uint256 tFee = tAmount.div(10000).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 = _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 setUniswapPair(address pair) external onlyOwner() {
uniswapPair = pair;
}
}
| 173,286 | 13,745 |
99144bb4fa67552911a87d08d7c3ac5eb1d9d212b1708969b34da8df2a0290aa
| 23,342 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/d2/d2fe4f401d25e94770e75e72c524db45378c6d7e_GOMBOracle.sol
| 4,722 | 16,710 |
// 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;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
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_;
}
}
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 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));
}
}
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;
}
}
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 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;
}
}
}
// fixed window oracle that recomputes the average price for the entire period once every period
contract GOMBOracle 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);
}
| 329,117 | 13,746 |
ce18f0b3f403f5a07022d9155ba6c8544229bd45194193341693ed440833df83
| 18,625 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/8c/8c199e13bD92f1B83b265642a61F157a4ba1F748_ORBITGAME.sol
| 5,060 | 16,642 |
pragma solidity 0.5.8;
contract ORBITGAME {
using SafeMath for uint256;
using SafeMath for uint8;
uint256 constant public INVEST_MIN_AMOUNT = 0.1 ether; // 0.1 AVAX
uint256[] public REFERRAL_PERCENTS = [50, 25, 15,5,5];
uint256[] public REFERRAL_MINIMUM = [0.1 ether, 1 ether, 3 ether,7.5 ether,15 ether];
uint256 constant public PROJECT_FEE = 10;
uint256 constant public DEVELOPER_FEE = 20;
uint256 constant public PERCENT_STEP = 10;
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 public totalStaked;
uint256 public totalRefBonus;
uint256 public totalUsers;
uint public TOTAL_DEPOSITS;
struct Plan {
uint256 time;
uint256 percent;
uint256 withdrawl;
}
Plan[] internal plans;
struct Deposit {
uint8 plan;
uint256 percent;
uint256 amount;
uint256 profit;
uint256 start;
uint256 finish;
uint256 cooldown;
}
struct User {
Deposit[] deposits;
uint256 checkpoint;
uint256 holdBonusCheckpoint;
address payable referrer;
uint256 referrals;
uint256 totalBonus;
uint256 withdrawn;
uint256 bonus;
uint256 invest;
bool l2;
bool l3;
bool l4;
bool l5;
}
struct THistoryDeposit {
uint timestamp;
uint duration;
uint amount;
}
struct Extra {
bool earn;
uint256 bonus;
}
mapping (address => User) internal users;
mapping (address => Extra) internal extraBonuses;
mapping (uint => THistoryDeposit) public DEPOSIT_HISTORY;
uint256 public startUNIX;
address payable private commissionWallet;
address payable private developerWallet;
address payable private refWallet;
event Newbie(address user);
event NewDeposit(address indexed user, uint8 plan, uint256 percent, uint256 amount, uint256 profit, uint256 start, uint256 finish);
event Withdrawn(address indexed user, uint256 amount);
event RefBonus(address indexed referrer, address indexed referral, uint256 indexed level, uint256 amount);
event AddExtraBonus(address indexed user);
event RemoveExtraBonus(address indexed user);
event ExtraBonus(address indexed referrer, address indexed referral, uint256 indexed level, uint256 amount);
constructor(address payable wallet, address payable _developer , address payable _ref) public {
require(!isContract(wallet));
commissionWallet = wallet;
developerWallet = _developer;
refWallet = _ref;
startUNIX = block.timestamp.add(365 days);
plans.push(Plan(14, 80, 0)); // 8% per day for 14 days
plans.push(Plan(21, 60, 0)); // 6% per day for 21 days
plans.push(Plan(28, 54, 0)); // 5,4% per day for 28 days
plans.push(Plan(14, 86, 6)); // 8,6% per day for 14 days (Withdrawl 6 Hours)
plans.push(Plan(21, 76, 12)); // 7.6% per day for 21 days Withdrawl 12 Hours)
plans.push(Plan(28, 75, 24)); // 7,5% per day for 28 days (Withdrawl 24 Hours)
plans.push(Plan(28, 96, 96)); // 9,6% per day for 28 days (Withdrawl 96 Hours)
plans.push(Plan(28, 130, 7*24)); // 13% per day for 28 days (Withdrawl every Week)
}
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 < 8, "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;
}else{
user.referrer = refWallet;
}
address upline = user.referrer;
for (uint256 i = 0; i < 5; 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;
uint256 amount2 = 0;
bool go = false;
address payable upline = user.referrer;
for (uint256 i = 0; i < 5; i++) {
if (upline != address(0)) {
if(i==1)
{
if(users[upline].l2 == true) go = true;
}
else if(i==2)
{
if(users[upline].l3 == true) go = true;
}
else if(i==3)
{
if(users[upline].l4 == true) go = true;
}
else if(i==4)
{
if(users[upline].l5 == true) go = true;
}
for (uint256 u = 0; u < users[upline].deposits.length; u++) {
amount2 = amount2.add(users[upline].deposits[u].amount);
}
if(amount2 >= REFERRAL_MINIMUM[i] || go == true)
{
if(i == 0 && extraBonuses[upline].earn == true){
uint256 extraAmount = msg.value.mul(extraBonuses[upline].bonus).div(PERCENTS_DIVIDER);
users[upline].bonus = users[upline].bonus.add(extraAmount);
users[upline].totalBonus = users[upline].totalBonus.add(extraAmount);
upline.transfer(extraAmount);
_refBonus = _refBonus.add(extraAmount);
emit ExtraBonus(upline, msg.sender, i, extraAmount);
}
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;
amount2 = 0;
go = false;
}
}
totalRefBonus = totalRefBonus.add(_refBonus);
}
if (user.deposits.length == 0) {
user.checkpoint = block.timestamp;
user.holdBonusCheckpoint = block.timestamp;
totalUsers = totalUsers.add(1);
emit Newbie(sender);
}
(uint256 percent, uint256 profit, uint256 finish) = getResult(plan, value);
user.deposits.push(Deposit(plan, percent, value, profit, block.timestamp, finish, (block.timestamp+(plans[plan].withdrawl*60*60))));
DEPOSIT_HISTORY[TOTAL_DEPOSITS] = THistoryDeposit(block.timestamp, plans[plan].time, value);
TOTAL_DEPOSITS++;
totalStaked = totalStaked.add(value);
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;
for (uint256 x = 0; x < user.deposits.length; x++) {
if(block.timestamp > user.deposits[x].cooldown) {
user.deposits[x].cooldown = block.timestamp+(plans[user.deposits[x].plan].withdrawl*60*60);
}
}
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, uint256 withdrawl) {
time = plans[plan].time;
percent = plans[plan].percent;
withdrawl = plans[plan].withdrawl;
}
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);
profit = deposit.mul(percent).div(PERCENTS_DIVIDER).mul(plans[plan].time);
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 (user.deposits[i].plan >= 3) {
if(block.timestamp > user.deposits[i].cooldown) {
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);
}
}
}
}
}
}
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 (user.deposits[i].plan >= 3) {
if(block.timestamp > user.deposits[i].cooldown) {
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));
}
}
}
}
}
}
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, uint256 cooldown) {
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;
cooldown = user.deposits[index].cooldown;
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
function addExtraBonus(address userAddr, uint256 amount) external{
require(developerWallet == msg.sender, "only owner");
require(extraBonuses[userAddr].earn != true, "wrong status");
require(amount <= 50, "Maximum 5%");
extraBonuses[userAddr].earn = true;
extraBonuses[userAddr].bonus = amount;
emit AddExtraBonus(userAddr);
}
function removeExtraBonus(address userAddr) external{
require(developerWallet == msg.sender, "only owner");
require(extraBonuses[userAddr].earn != false, "wrong status");
extraBonuses[userAddr].earn = false;
emit RemoveExtraBonus(userAddr);
}
function checkExtraBonus(address userAddr) external view returns(bool earn, uint256 bonus){
earn = extraBonuses[userAddr].earn;
bonus = extraBonuses[userAddr].bonus;
}
function unlocklevel(address userAddr, bool l2, bool l3, bool l4, bool l5) external{
require(developerWallet == msg.sender, "only owner");
users[userAddr].l2 = l2;
users[userAddr].l3 = l3;
users[userAddr].l4 = l4;
users[userAddr].l5 = l5;
}
}
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;
}
}
| 71,764 | 13,747 |
213189a078910087afa5d0454b99527c89184b48697ccefbb520f0fe8d047712
| 17,187 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TM/TMw4Er1ZVMm6Z4QnE4fqU6xzT4G43HapWb_DLIKE.sol
| 3,599 | 14,069 |
//SourceUnit: dlike_contract.sol
pragma solidity 0.5.9;
//
//------------------------ SafeMath Library -------------------------//
//
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, 'SafeMath mul failed');
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) {
require(b <= a, 'SafeMath sub failed');
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, 'SafeMath add failed');
return c;
}
}
//
//------------------ Contract to Manage Ownership -------------------//
//
contract Ownable {
address payable internal _owner;
address public signer;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
_owner = msg.sender;
signer = msg.sender;
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlySigner {
require(msg.sender == signer, "caller must be signer");
_;
}
function setSigner(address _signer) public onlyOwner {
signer = _signer;
}
modifier onlyOwner() {
require(isOwner());
_;
}
function isOwner() public view returns (bool) {
return msg.sender == _owner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address payable newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address payable newOwner) internal {
require(newOwner != address(0));
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
interface stakeContract {
function transfer(address _to, uint256 _amount) external returns (bool);
function transferFrom(address _from, address _to, uint256 _amount) external returns (bool);
}
//
//--------------------- MAIN CODE STARTS HERE ---------------------//
//
contract DLIKE is Ownable {
// Public variables of DLIKE
using SafeMath for uint256;
string constant private _name = "DLIKE";
string constant private _symbol = "DLIKE";
uint256 constant private _decimals = 6;
uint256 private _totalSupply = 0;
bool public safeguard;
// This creates a mapping with all data storage
mapping (address => uint256) private _balanceOf;
mapping (address => mapping (address => uint256)) private _allowance;
mapping (address => bool) public frozenAccount;
mapping(address=>uint256) public stakePool;
mapping(address=>uint256) public checkPowerDownPeriod;
mapping(address=>uint256) public unstakePool;
// This generates a public event of token transfer
event Transfer(address indexed from, address indexed to, uint256 value);
// This notifies clients about the amount burnt
event Burn(address indexed from, uint256 value);
// This generates a public event for frozen (blacklisting) accounts
event FrozenAccounts(address target, bool frozen);
// This will log approval of token Transfer
event Approval(address indexed from, address indexed spender, uint256 value);
function name() public pure returns(string memory) {
return _name;
}
function symbol() public pure returns(string memory) {
return _symbol;
}
function decimals() public pure returns(uint256) {
return _decimals;
}
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address user) public view returns(uint256) {
return _balanceOf[user];
}
function allowance(address owner, address spender) public view returns (uint256) {
return _allowance[owner][spender];
}
function _transfer(address _from, address _to, uint _value) internal {
require(!safeguard);
require (_to != address(0)); // Prevent transfer to 0x0 address. Use burn() instead
require(!frozenAccount[_from]); // Check if sender is frozen
require(!frozenAccount[_to]); // Check if recipient is frozen
_balanceOf[_from] = _balanceOf[_from].sub(_value); // Subtract from the sender
_balanceOf[_to] = _balanceOf[_to].add(_value); // Add the same to the recipient
emit Transfer(_from, _to, _value);
}
function transfer(address _to, uint256 _value) public returns (bool success) {
_transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
_allowance[_from][msg.sender] = _allowance[_from][msg.sender].sub(_value);
_transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool success) {
require(!safeguard);
_allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function increase_allowance(address spender, uint256 value) public returns (bool) {
require(spender != address(0));
_allowance[msg.sender][spender] = _allowance[msg.sender][spender].add(value);
emit Approval(msg.sender, spender, _allowance[msg.sender][spender]);
return true;
}
function decrease_allowance(address spender, uint256 value) public returns (bool) {
require(spender != address(0));
_allowance[msg.sender][spender] = _allowance[msg.sender][spender].sub(value);
emit Approval(msg.sender, spender, _allowance[msg.sender][spender]);
return true;
}
function() external payable {
}
function burn(uint256 _value) public returns (bool success) {
require(!safeguard);
_balanceOf[msg.sender] = _balanceOf[msg.sender].sub(_value); // Subtract from the sender
_totalSupply = _totalSupply.sub(_value); // Updates totalSupply
emit Burn(msg.sender, _value);
emit Transfer(msg.sender, address(0), _value);
return true;
}
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(!safeguard);
_balanceOf[_from] = _balanceOf[_from].sub(_value); // Minus from the targeted balance
_allowance[_from][msg.sender] = _allowance[_from][msg.sender].sub(_value); // Minus from the sender's allowance
_totalSupply = _totalSupply.sub(_value); // Update totalSupply
emit Burn(_from, _value);
emit Transfer(_from, address(0), _value);
return true;
}
function freezeAccount(address target, bool freeze) public onlyOwner {
frozenAccount[target] = freeze;
emit FrozenAccounts(target, freeze);
}
uint256 public PowerDownPeriod=604800;
uint256 totalStake=0;
uint256 totalUnstake=0;
event mintcommonReward(address indexed user, uint256 indexed amount, uint256 time);
event mintstakeReward(address indexed user, uint256 indexed amount, uint256 time);
event putstake(address indexed user, uint256 indexed amount, uint256 time);
event withdrawStake(address indexed user, uint256 indexed amount, uint256 time);
event unstakeEv(address indexed user, uint256 indexed amount, uint256 time);
mapping(address=>uint256) public tokenBalances;
mapping(address=>uint256) public rewardBlanaces;
uint256[] stakingAddress;
uint256[] unstakingAddress;
function payToken(address[] memory receivers, uint256[] memory amounts) public onlySigner returns(bool) {
require(!safeguard);
uint256 arrayLength = receivers.length;
for (uint256 i = 0; i < arrayLength; i++) {
mintToken(receivers[i], amounts[i]);
}
return true;
}
function mintToken(address target, uint256 mintedAmount) internal returns(bool) {
require(!safeguard);
require(target!=address(0), "Invalid Address");
require(mintedAmount!=0, "Invalid Amount");
tokenBalances[target] =mintedAmount;
return true;
}
function payReward(address[] memory receivers, uint256[] memory amounts) public onlySigner returns(bool) {
require(!safeguard);
uint256 arrayLength = receivers.length;
for (uint256 i = 0; i < arrayLength; i++) {
mintstakingreward(receivers[i], amounts[i]);
}
return true;
}
function mintstakingreward(address target, uint256 mintedAmount) internal returns(bool) {
require(!safeguard);
require(target!=address(0), "Invalid Address");
require(mintedAmount!=0, "Invalid Amount");
rewardBlanaces[target] = mintedAmount;
return true;
}
function stakeIn(uint256 _amount) public returns(bool) {
require(!safeguard);
require(_amount!=0, "invalid Amount");
require(_amount<=_balanceOf[msg.sender], "Insufficient Balance");
address sender=msg.sender;
stakePool[sender]=stakePool[sender].add(_amount);
_balanceOf[sender]=_balanceOf[sender].sub(_amount);
totalStake=totalStake.add(_amount);
emit putstake(sender, _amount, block.timestamp);
emit Transfer(sender, address(this), _amount);
return true;
}
function stakeOut(uint256 _amount) public returns(uint256, bool) {
require(!safeguard);
require(stakePool[msg.sender]>=_amount, "Invalid Amount");
require(_amount!=0, "Invalid Amount");
address sender=msg.sender;
if(checkPowerDownPeriod[sender]!=0) {
return (checkPowerDownPeriod[sender], false);
} else {
unstakePool[sender]=unstakePool[sender].add(_amount);
checkPowerDownPeriod[sender]=block.timestamp.add(PowerDownPeriod);
stakePool[sender]=stakePool[sender].sub(_amount);
totalUnstake=totalUnstake.add(_amount);
totalStake=totalStake.sub(_amount);
emit unstakeEv(sender, _amount, block.timestamp);
return (checkPowerDownPeriod[sender], true);
}
}
function claimStakeOut(uint256 _amount) public returns(bool) {
require(!safeguard);
require(checkPowerDownPeriod[msg.sender]<=block.timestamp, "Freezed");
require(unstakePool[msg.sender]<=_amount, "Invalid Amount");
address sender=msg.sender;
_balanceOf[sender]=_balanceOf[sender].add(_amount);
unstakePool[sender]=unstakePool[sender].sub(_amount);
checkPowerDownPeriod[sender]=0;
totalUnstake=totalUnstake.sub(_amount);
emit Transfer(address(this), sender, _amount);
return true;
}
function isUnstaking(address _address) public view returns(uint256, bool) {
require(_address!=address(0));
if(checkPowerDownPeriod[msg.sender]!=0) {
return (checkPowerDownPeriod[msg.sender], true);
} else {
return (checkPowerDownPeriod[msg.sender], false);
}
}
function getToken(uint256 _amount) public {
require(!safeguard);
require(tokenBalances[msg.sender]!=0, "No Tokens Available");
require(tokenBalances[msg.sender]>=_amount, "Invalid amount");
uint256 temp=_amount;
_balanceOf[msg.sender]=_balanceOf[msg.sender].add(temp);
tokenBalances[msg.sender]=tokenBalances[msg.sender].sub(temp);
_totalSupply=_totalSupply.add(temp);
emit Transfer(address(this), msg.sender, temp);
}
function getReward(uint256 _amount) public {
require(!safeguard);
require(rewardBlanaces[msg.sender]!=0, "No Rewards Available");
require(rewardBlanaces[msg.sender]>= _amount, "Invalid amount");
uint256 temp=_amount;
_balanceOf[msg.sender]=_balanceOf[msg.sender].add(temp);
rewardBlanaces[msg.sender]=rewardBlanaces[msg.sender].sub(temp);
_totalSupply=_totalSupply.add(temp);
emit Transfer(address(this), msg.sender, temp);
}
function setPowerDownPeriod(uint256 _time) public onlyOwner returns(bool) {
require(!safeguard);
PowerDownPeriod=_time;
return true;
}
function TotalStakedAmount() public view returns(uint256) {
return totalStake;
}
function TotalPendingUnstakeamount() public view returns(uint256) {
return totalUnstake;
}
function checkUnstake(address _add) public view returns(uint256) {
require(_add!=address(0));
return unstakePool[_add];
}
function checkStake(address _add) public view returns(uint256) {
require(_add!=address(0));
return stakePool[_add];
}
function manualWithdrawTokens(uint256 tokenAmount) public onlyOwner {
require(!safeguard);
_transfer(address(this), _owner, tokenAmount);
}
function manualwithdrawTron() public onlyOwner {
require(!safeguard);
address(_owner).transfer(address(this).balance);
}
function Boost(uint256 _amount) public {
require(!safeguard);
require(_amount!=0, "Invalid Amount");
burn(_amount);
}
function Membership(uint256 _amount) public {
require(!safeguard);
require(_amount!=0, "Invalid Amount");
burn(_amount);
}
function changeSafeguardStatus() public onlyOwner {
if (safeguard == false) {
safeguard = true;
} else {
safeguard = false;
}
}
}
| 295,436 | 13,748 |
bbf503675e4043b2876337187ebf0ba9561b0e755ba7fc7b1eddac8c5cecd84c
| 24,413 |
.sol
|
Solidity
| false |
593908510
|
SKKU-SecLab/SmartMark
|
fdf0675d2f959715d6f822351544c6bc91a5bdd4
|
dataset/Solidity_codes_9324/0xbbba5ba03d948d0a4cc010ca03d3b6e1b14f7098.sol
| 6,257 | 24,034 |
pragma solidity ^0.8.0;
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed from, address indexed to);
constructor() {
owner = msg.sender;
}
function getOwner() public view returns(address) {
return owner;
}
modifier onlyOwner {
require(msg.sender == owner, "Function restricted to owner of contract");
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
require(_newOwner != address(0)
&& _newOwner != owner);
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
abstract contract DeprecatedMultisenderSC {
function isPremiumMember(address _who) external virtual view returns(bool);
}
abstract contract ERC20Interface {
function transferFrom(address _from, address _to, uint256 _value) public virtual;
function balanceOf(address who) public virtual returns (uint256);
function allowance(address owner, address spender) public view virtual returns (uint256);
function transfer(address to, uint256 value) public virtual returns(bool);
function gasOptimizedAirdrop(address[] calldata _addrs, uint256[] calldata _values) external virtual;
}
abstract contract ERC721Interface {
function transferFrom(address _from, address _to, uint256 _tokenId) public virtual;
function balanceOf(address who) public virtual returns (uint256);
function isApprovedForAll(address _owner, address _operator) public view virtual returns(bool);
function setApprovalForAll(address _operator, bool approved) public virtual;
function gasOptimizedAirdrop(address _invoker, address[] calldata _addrs, uint256[] calldata _tokenIds) external virtual;
}
abstract contract ERC1155Interface {
function safeTransferFrom(address _from, address _to, uint256 _tokenId, uint256 _amount, bytes memory data) public virtual;
function balanceOf(address _who, uint256 _id) public virtual returns (uint256);
function isApprovedForAll(address _owner, address _operator) public view virtual returns(bool);
function setApprovalForAll(address _operator, bool approved) public virtual;
function gasOptimizedAirdrop(address _invoker, address[] calldata _addrs, uint256[] calldata _tokenIds, uint256[] calldata _amounts) external virtual;
}
contract CryptoMultisender is Ownable {
mapping (address => uint256) public tokenTrialDrops;
mapping (address => uint256) public userTrialDrops;
mapping (address => uint256) public premiumMembershipDiscount;
mapping (address => uint256) public membershipExpiryTime;
mapping (address => bool) public isGrantedPremiumMember;
mapping (address => bool) public isListedToken;
mapping (address => uint256) public tokenListingFeeDiscount;
mapping (address => bool) public isGrantedListedToken;
mapping (address => bool) public isAffiliate;
mapping (string => address) public affiliateCodeToAddr;
mapping (string => bool) public affiliateCodeExists;
mapping (address => string) public affiliateCodeOfAddr;
mapping (address => string) public isAffiliatedWith;
mapping (string => uint256) public commissionPercentage;
uint256 public oneDayMembershipFee;
uint256 public sevenDayMembershipFee;
uint256 public oneMonthMembershipFee;
uint256 public lifetimeMembershipFee;
uint256 public tokenListingFee;
uint256 public rate;
uint256 public dropUnitPrice;
address public deprecatedMultisenderAddress;
event TokenAirdrop(address indexed by, address indexed tokenAddress, uint256 totalTransfers);
event EthAirdrop(address indexed by, uint256 totalTransfers, uint256 ethValue);
event NftAirdrop(address indexed by, address indexed nftAddress, uint256 totalTransfers);
event RateChanged(uint256 from, uint256 to);
event RefundIssued(address indexed to, uint256 totalWei);
event ERC20TokensWithdrawn(address token, address sentTo, uint256 value);
event CommissionPaid(address indexed to, uint256 value);
event NewPremiumMembership(address indexed premiumMember);
event NewAffiliatePartnership(address indexed newAffiliate, string indexed affiliateCode);
event AffiliatePartnershipRevoked(address indexed affiliate, string indexed affiliateCode);
constructor() {
rate = 3000;
dropUnitPrice = 333333333333333;
oneDayMembershipFee = 9e17;
sevenDayMembershipFee = 125e16;
oneMonthMembershipFee = 2e18;
lifetimeMembershipFee = 25e17;
tokenListingFee = 5e18;
deprecatedMultisenderAddress=address(0xF521007C7845590C6c5ae46833DEFa0A68883CD4);
}
function setMembershipFees(uint256 _oneDayFee, uint256 _sevenDayFee, uint256 _oneMonthFee, uint256 _lifetimeFee) public onlyOwner returns(bool success) {
require(_oneDayFee>0 && _oneDayFee<_sevenDayFee && _sevenDayFee<_oneMonthFee && _oneMonthFee<_lifetimeFee);
oneDayMembershipFee = _oneDayFee;
sevenDayMembershipFee = _sevenDayFee;
oneMonthMembershipFee = _oneMonthFee;
lifetimeMembershipFee = _lifetimeFee;
return true;
}
function uint2str(uint _i) internal pure returns (string memory _uintAsString) {
if (_i == 0) {
return "0";
}
uint j = _i;
uint len;
while (j != 0) {
len++;
j /= 10;
}
bytes memory bstr = new bytes(len);
uint k = len;
while (_i != 0) {
k = k-1;
uint8 temp = (48 + uint8(_i - _i / 10 * 10));
bytes1 b1 = bytes1(temp);
bstr[k] = b1;
_i /= 10;
}
return string(bstr);
}
function giveChange(uint256 _price) internal {
if(msg.value > _price) {
uint256 change = msg.value - _price;
payable(msg.sender).transfer(change);
}
}
function processAffiliateCode(string memory _afCode) internal returns(string memory code) {
if(stringsAreEqual(isAffiliatedWith[msg.sender], "void") || !isAffiliate[affiliateCodeToAddr[_afCode]]) {
isAffiliatedWith[msg.sender] = "void";
return "void";
}
if(!stringsAreEqual(_afCode, "") && stringsAreEqual(isAffiliatedWith[msg.sender],"")
&& affiliateCodeExists[_afCode]) {
if(affiliateCodeToAddr[_afCode] == msg.sender) {
return "void";
}
isAffiliatedWith[msg.sender] = _afCode;
}
if(stringsAreEqual(_afCode,"") && !stringsAreEqual(isAffiliatedWith[msg.sender],"")) {
_afCode = isAffiliatedWith[msg.sender];
}
if(stringsAreEqual(_afCode,"") || !affiliateCodeExists[_afCode]) {
isAffiliatedWith[msg.sender] = "void";
_afCode = "void";
}
return _afCode;
}
function checkIsPremiumMember(address _addr) public view returns(bool isMember) {
return membershipExpiryTime[_addr] >= block.timestamp || isGrantedPremiumMember[_addr];
}
function grantPremiumMembership(address _addr) public onlyOwner returns(bool success) {
require(checkIsPremiumMember(_addr) != true, "Is already premiumMember member");
isGrantedPremiumMember[_addr] = true;
emit NewPremiumMembership(_addr);
return true;
}
function revokeGrantedPremiumMembership(address _addr) public onlyOwner returns(bool success) {
require(isGrantedPremiumMember[_addr], "Not a granted membership");
isGrantedPremiumMember[_addr] = false;
return true;
}
function setPremiumMembershipDiscount(address _addr, uint256 _discount) public onlyOwner returns(bool success) {
premiumMembershipDiscount[_addr] = _discount;
return true;
}
function getPremiumMembershipFeeOfUser(address _addr, uint256 _fee) public view returns(uint256 fee) {
if(premiumMembershipDiscount[_addr] > 0) {
return _fee * premiumMembershipDiscount[_addr] / 100;
}
return _fee;
}
function setDeprecatedMultisenderAddress(address _addr) public onlyOwner {
deprecatedMultisenderAddress = _addr;
}
function isMemberOfOldMultisender(address _who) public view returns(bool) {
DeprecatedMultisenderSC oldMultisender = DeprecatedMultisenderSC(deprecatedMultisenderAddress);
return oldMultisender.isPremiumMember(_who);
}
function transferMembership() public returns(bool) {
require(isMemberOfOldMultisender(msg.sender), "No membership to transfer");
membershipExpiryTime[msg.sender] = block.timestamp + (36500 * 1 days);
return true;
}
function assignMembership(uint256 _days, uint256 _fee, string memory _afCode) internal returns(bool success) {
require(checkIsPremiumMember(msg.sender) != true, "Is already premiumMember member");
uint256 fee = getPremiumMembershipFeeOfUser(msg.sender, _fee);
require(msg.value >= fee,
string(abi.encodePacked("premiumMember fee is: ", uint2str(fee), ". Not enough funds sent. ", uint2str(msg.value))));
membershipExpiryTime[msg.sender] = block.timestamp + (_days * 1 days);
_afCode = processAffiliateCode(_afCode);
giveChange(fee);
distributeCommission(fee, _afCode);
emit NewPremiumMembership(msg.sender);
return true;
}
function becomeLifetimeMember(string memory _afCode) public payable returns(bool success) {
assignMembership(36500, lifetimeMembershipFee, _afCode);
return true;
}
function becomeOneDayMember(string memory _afCode) public payable returns(bool success) {
assignMembership(1, oneDayMembershipFee, _afCode);
return true;
}
function becomeOneWeekMember(string memory _afCode) public payable returns(bool success) {
assignMembership(7, sevenDayMembershipFee, _afCode);
return true;
}
function becomeOneMonthMember(string memory _afCode) public payable returns(bool success) {
assignMembership(31, oneMonthMembershipFee, _afCode);
return true;
}
function checkIsListedToken(address _tokenAddr) public view returns(bool isListed) {
return isListedToken[_tokenAddr] || isGrantedListedToken[_tokenAddr];
}
function setTokenListingFeeDiscount(address _tokenAddr, uint256 _discount) public onlyOwner returns(bool success) {
tokenListingFeeDiscount[_tokenAddr] = _discount;
return true;
}
function getListingFeeForToken(address _tokenAddr) public view returns(uint256 fee) {
if(tokenListingFeeDiscount[_tokenAddr] > 0) {
return tokenListingFee * tokenListingFeeDiscount[_tokenAddr] / 100;
}
return tokenListingFee;
}
function purchaseTokenListing(address _tokenAddr, string memory _afCode) public payable returns(bool success) {
require(!checkIsListedToken(_tokenAddr), "Token is already listed");
_afCode = processAffiliateCode(_afCode);
uint256 fee = getListingFeeForToken(_tokenAddr);
require(msg.value >= fee, "Not enough funds sent for listing");
isListedToken[_tokenAddr] = true;
giveChange(fee);
distributeCommission(fee, _afCode);
return true;
}
function revokeGrantedTokenListing(address _tokenAddr) public onlyOwner returns(bool success) {
require(checkIsListedToken(_tokenAddr), "Is not listed token");
isGrantedListedToken[_tokenAddr] = false;
return true;
}
function grantTokenListing(address _tokenAddr) public onlyOwner returns(bool success){
require(!checkIsListedToken(_tokenAddr), "Token is already listed");
isGrantedListedToken[_tokenAddr] = true;
return true;
}
function setTokenListingFee(uint256 _newFee) public onlyOwner returns(bool success){
tokenListingFee = _newFee;
return true;
}
function addAffiliate(address _addr, string memory _code, uint256 _percentage) public onlyOwner returns(bool success) {
require(!isAffiliate[_addr], "Address is already an affiliate.");
require(_addr != address(0), "0x00 address not allowed");
require(!affiliateCodeExists[_code], "Affiliate code already exists!");
require(_percentage <= 100 && _percentage > 0, "Percentage must be > 0 && <= 100");
affiliateCodeExists[_code] = true;
isAffiliate[_addr] = true;
affiliateCodeToAddr[_code] = _addr;
affiliateCodeOfAddr[_addr] = _code;
commissionPercentage[_code] = _percentage;
emit NewAffiliatePartnership(_addr,_code);
return true;
}
function changeAffiliatePercentage(address _addressOfAffiliate, uint256 _percentage) public onlyOwner returns(bool success) {
require(isAffiliate[_addressOfAffiliate]);
string storage affCode = affiliateCodeOfAddr[_addressOfAffiliate];
commissionPercentage[affCode] = _percentage;
return true;
}
function removeAffiliate(address _addr) public onlyOwner returns(bool success) {
require(isAffiliate[_addr]);
isAffiliate[_addr] = false;
affiliateCodeToAddr[affiliateCodeOfAddr[_addr]] = address(0);
emit AffiliatePartnershipRevoked(_addr, affiliateCodeOfAddr[_addr]);
affiliateCodeOfAddr[_addr] = "No longer an affiliate partner";
return true;
}
function tokenHasFreeTrial(address _addressOfToken) public view returns(bool hasFreeTrial) {
return tokenTrialDrops[_addressOfToken] < 100;
}
function userHasFreeTrial(address _addressOfUser) public view returns(bool hasFreeTrial) {
return userTrialDrops[_addressOfUser] < 100;
}
function getRemainingTokenTrialDrops(address _addressOfToken) public view returns(uint256 remainingTrialDrops) {
if(tokenHasFreeTrial(_addressOfToken)) {
uint256 maxTrialDrops = 100;
return maxTrialDrops - tokenTrialDrops[_addressOfToken];
}
return 0;
}
function getRemainingUserTrialDrops(address _addressOfUser) public view returns(uint256 remainingTrialDrops) {
if(userHasFreeTrial(_addressOfUser)) {
uint256 maxTrialDrops = 100;
return maxTrialDrops - userTrialDrops[_addressOfUser];
}
return 0;
}
function setRate(uint256 _newRate) public onlyOwner returns(bool success) {
require(_newRate != rate
&& _newRate > 0);
emit RateChanged(rate, _newRate);
rate = _newRate;
uint256 eth = 1 ether;
dropUnitPrice = eth / rate;
return true;
}
function getTokenAllowance(address _addr, address _addressOfToken) public view returns(uint256 allowance) {
ERC20Interface token = ERC20Interface(_addressOfToken);
return token.allowance(_addr, address(this));
}
fallback() external payable {
revert();
}
receive() external payable {
revert();
}
function stringsAreEqual(string memory _a, string memory _b) internal pure returns(bool areEqual) {
bytes32 hashA = keccak256(abi.encodePacked(_a));
bytes32 hashB = keccak256(abi.encodePacked(_b));
return hashA == hashB;
}
function airdropNativeCurrency(address[] memory _recipients, uint256[] memory _values, uint256 _totalToSend, string memory _afCode) public payable returns(bool success) {
require(_recipients.length == _values.length, "Total number of recipients and values are not equal");
uint256 totalEthValue = _totalToSend;
uint256 price = _recipients.length * dropUnitPrice;
uint256 totalCost = totalEthValue + price;
bool userHasTrial = userHasFreeTrial(msg.sender);
bool isVIP = checkIsPremiumMember(msg.sender) == true;
require(msg.value >= totalCost || isVIP || userHasTrial,
"Not enough funds sent with transaction!");
_afCode = processAffiliateCode(_afCode);
if(!isVIP && !userHasTrial) {
distributeCommission(price, _afCode);
}
if((isVIP || userHasTrial) && msg.value > _totalToSend) {
payable(msg.sender).transfer((msg.value) - _totalToSend);
} else {
giveChange(totalCost);
}
for(uint i = 0; i < _recipients.length; i++) {
payable(_recipients[i]).transfer(_values[i]);
}
if(userHasTrial) {
userTrialDrops[msg.sender] = userTrialDrops[msg.sender] + _recipients.length;
}
emit EthAirdrop(msg.sender, _recipients.length, totalEthValue);
return true;
}
function erc20Airdrop(address _addressOfToken, address[] memory _recipients, uint256[] memory _values, uint256 _totalToSend, bool _isDeflationary, bool _optimized, string memory _afCode) public payable returns(bool success) {
string memory afCode = processAffiliateCode(_afCode);
ERC20Interface token = ERC20Interface(_addressOfToken);
require(_recipients.length == _values.length, "Total number of recipients and values are not equal");
uint256 price = _recipients.length * dropUnitPrice;
bool isPremiumOrListed = checkIsPremiumMember(msg.sender) || checkIsListedToken(_addressOfToken);
bool eligibleForFreeTrial = tokenHasFreeTrial(_addressOfToken) && userHasFreeTrial(msg.sender);
require(msg.value >= price || tokenHasFreeTrial(_addressOfToken) || userHasFreeTrial(msg.sender) || isPremiumOrListed,
"Not enough funds sent with transaction!");
if((eligibleForFreeTrial || isPremiumOrListed) && msg.value > 0) {
payable(msg.sender).transfer(msg.value);
} else {
giveChange(price);
}
if(_optimized) {
token.transferFrom(msg.sender, address(this), _totalToSend);
token.gasOptimizedAirdrop(_recipients,_values);
} else {
if(!_isDeflationary) {
token.transferFrom(msg.sender, address(this), _totalToSend);
for(uint i = 0; i < _recipients.length; i++) {
token.transfer(_recipients[i], _values[i]);
}
if(token.balanceOf(address(this)) > 0) {
token.transfer(msg.sender,token.balanceOf(address(this)));
}
} else {
for(uint i=0; i < _recipients.length; i++) {
token.transferFrom(msg.sender, _recipients[i], _values[i]);
}
}
}
if(tokenHasFreeTrial(_addressOfToken)) {
tokenTrialDrops[_addressOfToken] = tokenTrialDrops[_addressOfToken] + _recipients.length;
}
if(userHasFreeTrial(msg.sender)) {
userTrialDrops[msg.sender] = userTrialDrops[msg.sender] + _recipients.length;
}
if(!eligibleForFreeTrial && !isPremiumOrListed) {
distributeCommission(_recipients.length * dropUnitPrice, afCode);
}
emit TokenAirdrop(msg.sender, _addressOfToken, _recipients.length);
return true;
}
function erc721Airdrop(address _addressOfNFT, address[] memory _recipients, uint256[] memory _tokenIds, bool _optimized, string memory _afCode) public payable returns(bool success) {
require(_recipients.length == _tokenIds.length, "Total number of recipients and total number of NFT IDs are not the same");
string memory afCode = processAffiliateCode(_afCode);
ERC721Interface erc721 = ERC721Interface(_addressOfNFT);
uint256 price = _recipients.length * dropUnitPrice;
bool isPremiumOrListed = checkIsPremiumMember(msg.sender) || checkIsListedToken(_addressOfNFT);
bool eligibleForFreeTrial = tokenHasFreeTrial(_addressOfNFT) && userHasFreeTrial(msg.sender);
require(msg.value >= price || eligibleForFreeTrial || isPremiumOrListed,
"Not enough funds sent with transaction!");
if((eligibleForFreeTrial || isPremiumOrListed) && msg.value > 0) {
payable(msg.sender).transfer(msg.value);
} else {
giveChange(price);
}
if(_optimized){
erc721.gasOptimizedAirdrop(msg.sender,_recipients,_tokenIds);
} else {
for(uint i = 0; i < _recipients.length; i++) {
erc721.transferFrom(msg.sender, _recipients[i], _tokenIds[i]);
}
}
if(tokenHasFreeTrial(_addressOfNFT)) {
tokenTrialDrops[_addressOfNFT] = tokenTrialDrops[_addressOfNFT] + _recipients.length;
}
if(userHasFreeTrial(msg.sender)) {
userTrialDrops[msg.sender] = userTrialDrops[msg.sender] + _recipients.length;
}
if(!eligibleForFreeTrial && !isPremiumOrListed) {
distributeCommission(_recipients.length * dropUnitPrice, afCode);
}
emit NftAirdrop(msg.sender, _addressOfNFT, _recipients.length);
return true;
}
function erc1155Airdrop(address _addressOfNFT, address[] memory _recipients, uint256[] memory _ids, uint256[] memory _amounts, bool _optimized, string memory _afCode) public payable returns(bool success) {
require(_recipients.length == _ids.length, "Total number of recipients and total number of NFT IDs are not the same");
require(_recipients.length == _amounts.length, "Total number of recipients and total number of amounts are not the same");
string memory afCode = processAffiliateCode(_afCode);
ERC1155Interface erc1155 = ERC1155Interface(_addressOfNFT);
uint256 price = _recipients.length * dropUnitPrice;
bool isPremiumOrListed = checkIsPremiumMember(msg.sender) || checkIsListedToken(_addressOfNFT);
bool eligibleForFreeTrial = tokenHasFreeTrial(_addressOfNFT) && userHasFreeTrial(msg.sender);
require(msg.value >= price || eligibleForFreeTrial || isPremiumOrListed,
"Not enough funds sent with transaction!");
if((eligibleForFreeTrial || isPremiumOrListed) && msg.value > 0) {
payable(msg.sender).transfer(msg.value);
} else {
giveChange(price);
}
if(_optimized){
erc1155.gasOptimizedAirdrop(msg.sender,_recipients,_ids,_amounts);
} else {
for(uint i = 0; i < _recipients.length; i++) {
erc1155.safeTransferFrom(msg.sender, _recipients[i], _ids[i], _amounts[i], "");
}
}
if(tokenHasFreeTrial(_addressOfNFT)) {
tokenTrialDrops[_addressOfNFT] = tokenTrialDrops[_addressOfNFT] + _recipients.length;
}
if(userHasFreeTrial(msg.sender)) {
userTrialDrops[msg.sender] = userTrialDrops[msg.sender] + _recipients.length;
}
if(!eligibleForFreeTrial && !isPremiumOrListed) {
distributeCommission(_recipients.length * dropUnitPrice, afCode);
}
emit NftAirdrop(msg.sender, _addressOfNFT, _recipients.length);
return true;
}
function distributeCommission(uint256 _profits, string memory _afCode) internal {
if(!stringsAreEqual(_afCode,"void") && isAffiliate[affiliateCodeToAddr[_afCode]]) {
uint256 commission = _profits * commissionPercentage[_afCode] / 100;
payable(owner).transfer(_profits - commission);
payable(affiliateCodeToAddr[_afCode]).transfer(commission);
emit CommissionPaid(affiliateCodeToAddr[_afCode], commission);
} else {
payable(owner).transfer(_profits);
}
}
function withdrawFunds() public onlyOwner returns(bool success) {
payable(owner).transfer(address(this).balance);
return true;
}
function withdrawERC20Tokens(address _addressOfToken, address _recipient, uint256 _value) public onlyOwner returns(bool success){
ERC20Interface token = ERC20Interface(_addressOfToken);
token.transfer(_recipient, _value);
emit ERC20TokensWithdrawn(_addressOfToken, _recipient, _value);
return true;
}
}
| 274,560 | 13,749 |
4eb9ce0212db3fdb3ba34023ef2e6afb59b3294cf088049302931d2945a6c1aa
| 24,794 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TQ/TQEjd3UAZczRyxsSMtwp3VtjbDMLdSZTZ6_Consignment.sol
| 4,325 | 15,343 |
//SourceUnit: .sol
pragma solidity ^0.5.0 || ^0.6.0;
pragma experimental ABIEncoderV2;
contract Governance {
address public _governance;
constructor() public {
_governance = tx.origin;
}
event GovernanceTransferred(address indexed previousOwner, address indexed newOwner);
modifier onlyGovernance {
require(msg.sender == _governance, "not governance");
_;
}
function setGovernance(address governance) public onlyGovernance
{
require(governance != address(0), "new governance the zero address");
emit GovernanceTransferred(_governance, governance);
_governance = governance;
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
bytes4 private constant SELECTOR = bytes4(keccak256(bytes('transfer(address,uint256)')));
function safeTransfer(IERC20 token, address to, uint256 value) internal {
(bool success, bytes memory data) = address(token).call(abi.encodeWithSelector(SELECTOR, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), 'SafeERC20: TRANSFER_FAILED');
}
// 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).isContracts(), "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");
}
}
}
library Address {
function isContracts(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 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");
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function mint(address account, uint amount) external;
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
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 {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
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;
}
}
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 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 ERC721
{
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 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 _approved,
uint256 _tokenId)
external;
function setApprovalForAll(address _operator,
bool _approved)
external;
function balanceOf(address _owner)
external
view
returns (uint256);
function ownerOf(uint256 _tokenId)
external
view
returns (address);
function getApproved(uint256 _tokenId)
external
view
returns (address);
function isApprovedForAll(address _owner,
address _operator)
external
view
returns (bool);
}
interface ztoken {
function addWhitelist(address newlist) external;
}
contract Consignment is Governance {
using SafeMath for uint256;
using SafeERC20 for IERC20;
struct itemInfo {
address nftTokenAddr;
uint256 nftTokenID;
}
itemInfo[] _itemInfos;
mapping(address => mapping(uint256 => uint256)) public _itemToID;
mapping(address => mapping(uint256 => uint256)) public _nftTokenInfo;
mapping(address => mapping(uint256 => uint256)) public _nftTimeInfo;
mapping(address => mapping(uint256 => uint256)) public _nftTypeInfo;
mapping(address => mapping(uint256 => string)) public _nftNameInfo;
mapping(address => mapping(uint256 => string)) public _nftURLInfo;
mapping(address => mapping(uint256 => string)) public _nftBrandInfo;
mapping(address => mapping(uint256 => uint256)) public _nftNumberingInfo;
mapping(address => mapping(uint256 => address)) public _nftSellerInfo;
address public addrToken;
address public nftAddr;
uint public _fee = 1000;
uint public _base = 10000;
uint public itemNum = 0;
constructor(address _nftaddr,address _addrToken) public {
nftAddr = _nftaddr;
addrToken = _addrToken;
}
function sell(uint _tokenid,uint _price) external {
require(_nftSellerInfo[nftAddr][_tokenid] == address(0));
require(ERC721(nftAddr).ownerOf(_tokenid) == msg.sender);
require(_nftTokenInfo[nftAddr][_tokenid] <= 0, "cancelSell");
ERC721(nftAddr).safeTransferFrom(msg.sender,address(this),_tokenid);
_nftTokenInfo[nftAddr][_tokenid] = _price;
_nftSellerInfo[nftAddr][_tokenid] = msg.sender;
_nftTimeInfo[nftAddr][_tokenid] = block.timestamp;
_itemToID[nftAddr][_tokenid] = itemNum;
itemInfo memory itemIn;
itemIn.nftTokenAddr = nftAddr;
itemIn.nftTokenID = _tokenid;
_itemInfos.push(itemIn);
itemNum = itemNum.add(1);
}
function cancelSell(uint _tokenid) external {
require(msg.sender == _governance || _nftSellerInfo[nftAddr][_tokenid] == msg.sender);
require(_nftTokenInfo[nftAddr][_tokenid] > 0);
ERC721(nftAddr).safeTransferFrom(address(this),_nftSellerInfo[nftAddr][_tokenid],_tokenid);
_nftTokenInfo[nftAddr][_tokenid] = 0;
_nftSellerInfo[nftAddr][_tokenid] = address(0);
_nftTimeInfo[nftAddr][_tokenid] = 0;
uint maxcount = _itemInfos.length;
uint itemIndex = _itemToID[nftAddr][_tokenid];
_itemInfos[itemIndex] = _itemInfos[maxcount.sub(1)];
itemNum = itemNum.sub(1);
_itemInfos.pop();
if(maxcount.sub(1) != itemIndex)
{
_itemToID[_itemInfos[itemIndex].nftTokenAddr][_itemInfos[itemIndex].nftTokenID] = itemIndex;
}
}
function buy(uint _tokenid) external {
uint nftprice = _nftTokenInfo[nftAddr][_tokenid];
uint _before = IERC20(addrToken).balanceOf(address(this));
IERC20(addrToken).transferFrom(msg.sender, address(this),nftprice);
uint _after = IERC20(addrToken).balanceOf(address(this));
uint amount = _after.sub(_before);
address selleraddr = _nftSellerInfo[nftAddr][_tokenid];
ERC721(nftAddr).safeTransferFrom(address(this),msg.sender,_tokenid);
uint left = amount.mul(_base.sub(_fee)).div(_base);
IERC20(addrToken).transfer(selleraddr,left);
_nftTokenInfo[nftAddr][_tokenid] = 0;
_nftSellerInfo[nftAddr][_tokenid] = address(0);
_nftTimeInfo[nftAddr][_tokenid] = 0;
uint maxcount = _itemInfos.length;
uint itemIndex = _itemToID[nftAddr][_tokenid];
_itemInfos[itemIndex] = _itemInfos[maxcount.sub(1)];
itemNum = itemNum.sub(1);
_itemInfos.pop();
if(maxcount.sub(1) != itemIndex)
{
_itemToID[_itemInfos[itemIndex].nftTokenAddr][_itemInfos[itemIndex].nftTokenID] = itemIndex;
}
}
function setFee(uint256 _feenum) public onlyGovernance{
_fee = _feenum;
}
function withdraw(uint256 num) public onlyGovernance{
IERC20(addrToken).transfer(msg.sender,num);
}
function getItems(uint count) public view returns(uint256 _id,uint256 _price,uint256 _timeinfo){
address nAddr = _itemInfos[count].nftTokenAddr;
uint nID = _itemInfos[count].nftTokenID;
_id = _itemInfos[count].nftTokenID;
_price = _nftTokenInfo[_itemInfos[count].nftTokenAddr][_itemInfos[count].nftTokenID];
_timeinfo = _nftTimeInfo[nAddr][nID];
}
function onERC721Received(address _operator,
address _from,
uint256 _tokenId,
bytes calldata _data)
external
returns(bytes4){
return 0x150b7a02;
}
function setNFTAddr(address newnftaddr) public onlyGovernance{
nftAddr = newnftaddr;
}
}
| 290,098 | 13,750 |
06357710fa70a7dcd189e85a8e99dfd423cbecfe517bb04bd86ee92c3b6fe0e7
| 13,740 |
.sol
|
Solidity
| false |
316275714
|
giacomofi/Neural_Smart_Ponzi_Recognition
|
a26fb280753005b9b9fc262786d5ce502b3f8cd3
|
Not_Smart_Ponzi_Source_Code/0x0386d41ffdfa1f5bf24ef2b19fd21683b8a1e3f5.sol
| 3,619 | 13,550 |
pragma solidity ^0.5.0;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
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 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");
(bool success,) = recipient.call.value(amount)("");
require(success, "Address: unable to send value, recipient may have reverted");
}
}
contract ReentrancyGuard {
bool private _notEntered;
constructor () internal {
_notEntered = true;
}
modifier nonReentrant() {
require(_notEntered, "ReentrancyGuard: reentrant call");
_notEntered = false;
_;
_notEntered = true;
}
}
contract Context {
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(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 IERC1820Registry {
function setManager(address account, address newManager) external;
function getManager(address account) external view returns (address);
function setInterfaceImplementer(address account, bytes32 interfaceHash, address implementer) external;
function getInterfaceImplementer(address account, bytes32 interfaceHash) external view returns (address);
function interfaceHash(string calldata interfaceName) external pure returns (bytes32);
function updateERC165Cache(address account, bytes4 interfaceId) external;
function implementsERC165Interface(address account, bytes4 interfaceId) external view returns (bool);
function implementsERC165InterfaceNoCache(address account, bytes4 interfaceId) external view returns (bool);
event InterfaceImplementerSet(address indexed account, bytes32 indexed interfaceHash, address indexed implementer);
event ManagerChanged(address indexed account, address indexed newManager);
}
interface IERC777Recipient {
function tokensReceived(address operator,
address from,
address to,
uint256 amount,
bytes calldata userData,
bytes calldata operatorData) external;
}
interface IERC777 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function granularity() external view returns (uint256);
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address owner) external view returns (uint256);
function send(address recipient, uint256 amount, bytes calldata data) external;
function transfer(address recipient, uint256 amount) external returns (bool);
function mint(address account, uint256 amount, bytes calldata data) external;
function burn(uint256 amount, bytes calldata data) external;
function isOperatorFor(address operator, address tokenHolder) external view returns (bool);
function authorizeOperator(address operator) external;
function revokeOperator(address operator) external;
function defaultOperators() external view returns (address[] memory);
function operatorSend(address sender,
address recipient,
uint256 amount,
bytes calldata data,
bytes calldata operatorData) external;
function operatorBurn(address account,
uint256 amount,
bytes calldata data,
bytes calldata operatorData) external;
event Sent(address indexed operator,
address indexed from,
address indexed to,
uint256 amount,
bytes data,
bytes operatorData);
event Minted(address indexed operator, address indexed to, uint256 amount, bytes data, bytes operatorData);
event Burned(address indexed operator, address indexed from, uint256 amount, bytes data, bytes operatorData);
event AuthorizedOperator(address indexed operator, address indexed tokenHolder);
event RevokedOperator(address indexed operator, address indexed tokenHolder);
}
interface ISmartexOracle {
function currentETHPrice() external view returns (uint256);
function lastETHPriceUpdate() external view returns (uint256);
function currentTokenPrice() external view returns (uint256);
function lastTokenPriceUpdate() external view returns (uint256);
function setETHPrice(uint256 price) external;
function updateTokenPrice() external;
event ETHPriceUpdated(uint256 price, uint256 timestamp);
event TokenPriceUpdated(uint256 price, uint256 timestamp);
}
contract SmartexExchange is Ownable, ReentrancyGuard {
using SafeMath for uint256;
using Address for address;
mapping (address => bool) public authorizedCallers;
struct OrderStruct {
bool exists;
address owner;
uint256 amount;
}
mapping (uint256 => OrderStruct) public orders;
IERC1820Registry constant internal ERC1820_REGISTRY = IERC1820Registry(0x1820a4B7618BdE71Dce8cdc73aAB6C95905faD24);
address payable private _wallet;
address payable private _secondWallet;
uint256 private _currentOrderID;
uint256 private _orderUSDMinAmount;
IERC777 private _token;
ISmartexOracle private _oracle;
bytes32 constant private TOKENS_RECIPIENT_INTERFACE_HASH =
0xb281fc8c12954d22544db45de3159a39272895b169a852b314f9cc762e44c53b;
event Order(address indexed owner, uint256 indexed id, uint256 amount, uint256 price, uint256 time);
event Cancel(address indexed owner, uint256 indexed id, uint256 time);
event Close(address indexed owner, uint256 indexed id, uint256 time);
event Trade(address indexed buyer, address indexed seller, uint256 indexed orderID, uint256 amount, uint256 price, uint256 time);
modifier onlyAuthorizedCaller() {
require(_msgSender() == owner() || authorizedCallers[_msgSender()], "SmartexExchange: caller is not authorized");
_;
}
constructor(address payable wallet, address payable secondWallet, IERC777 token) public {
_wallet = wallet;
_secondWallet = secondWallet;
_token = token;
_orderUSDMinAmount = 20 * (10 ** 8);
ERC1820_REGISTRY.setInterfaceImplementer(address(this), TOKENS_RECIPIENT_INTERFACE_HASH, address(this));
}
function setOracle(ISmartexOracle oracle) public onlyOwner {
_oracle = oracle;
}
function oracle() public view returns (ISmartexOracle) {
return _oracle;
}
function token() public view returns (IERC777) {
return _token;
}
function wallet() public view returns (address payable) {
return _wallet;
}
function secondWallet() public view returns (address payable) {
return _secondWallet;
}
function setOrderUSDMinAmount(uint256 amount) public onlyOwner {
_orderUSDMinAmount = amount;
}
function setAuthorizedCaller(address caller, bool allowed) public onlyOwner {
authorizedCallers[caller] = allowed;
}
function tokensReceived(address operator, address from, address to, uint256 amount, bytes calldata userData, bytes calldata operatorData) external {
require(address(_token) == _msgSender(), "Invalid sender");
require(operator == from, "Transfers from operators are not allowed");
require(!from.isContract(), "Transfers from contracts are not allowed");
require(amount >= getOrderTokenMinAmount(), "Amount is less than the minimum");
_currentOrderID++;
OrderStruct memory order = OrderStruct({
exists: true,
owner: from,
amount: amount
});
orders[_currentOrderID] = order;
emit Order(from, _currentOrderID, amount, _oracle.currentTokenPrice(), now);
}
function cancelOrder(uint256 id) public {
OrderStruct storage order = orders[id];
require(order.exists, "Unknown order");
require(order.amount > 0, "The order is already filled/cancelled");
require(order.owner == _msgSender(), "You are not the owner of this order");
uint256 remaining = order.amount;
order.amount = 0;
_token.transfer(_msgSender(), remaining);
emit Cancel(_msgSender(), id, now);
}
function buyOrder(uint256 id, uint256 tokens) public nonReentrant payable {
OrderStruct storage order = orders[id];
require(order.exists, "Unknown order");
require(order.amount > 0, "The order is already filled/cancelled");
require(order.amount >= tokens, "The order has insufficient funds");
address payable buyer = _msgSender();
if (order.owner.isContract()) {
order.amount = 0;
emit Close(order.owner, id, now);
bool result = buyer.send(msg.value);
return;
}
uint256 weiAmount = msg.value;
uint256 weiToSend = getWeiAmount(tokens);
require(weiToSend > 100, "Minimum trade wei amount 100");
if (tokens >= order.amount) {
tokens = order.amount;
order.amount = 0;
} else {
order.amount = order.amount.sub(tokens);
}
if (_isDust(order.amount)) {
uint256 remaining = order.amount;
order.amount = 0;
emit Close(order.owner, id, now);
if (remaining > 0) {
_token.transfer(order.owner, remaining);
}
}
uint256 change = weiAmount.sub(weiToSend);
uint256 fee = weiToSend.div(100);
weiToSend = weiToSend.sub(fee);
bool result;
if (order.owner == owner()) {
_splitAndSendWei(weiToSend);
} else {
result = order.owner.toPayable().send(weiToSend);
}
_token.transfer(buyer, tokens);
result = owner().toPayable().send(fee);
emit Trade(buyer, order.owner, id, tokens, _oracle.currentTokenPrice(), now);
if (change > 0) {
result = buyer.send(change);
}
}
function _splitAndSendWei(uint256 weiAmount) internal {
uint256 ownerPayment = weiAmount.mul(70).div(100);
uint256 walletsPayment = weiAmount.sub(ownerPayment);
owner().toPayable().transfer(ownerPayment);
if (walletsPayment > 0) {
uint256 firstWalletPayment = walletsPayment.div(2);
uint256 secondWalletPayment = walletsPayment.sub(firstWalletPayment);
wallet().transfer(firstWalletPayment);
secondWallet().transfer(secondWalletPayment);
}
}
function getWeiAmount(uint256 tokens) public view returns (uint256) {
return tokens.mul(_oracle.currentTokenPrice()).div(_oracle.currentETHPrice());
}
function getTokenAmount(uint256 weiAmount) public view returns (uint256) {
return weiAmount.mul(_oracle.currentETHPrice()).div(_oracle.currentTokenPrice());
}
function getOrderTokenMinAmount() public view returns (uint256) {
return _orderUSDMinAmount.mul(10 ** uint256(_token.decimals())).div(_oracle.currentTokenPrice());
}
function _isDust(uint256 tokens) internal view returns (bool) {
return tokens.mul(_oracle.currentTokenPrice()).div(10 ** uint256(_token.decimals())) < (10 ** 6);
}
}
| 339,663 | 13,751 |
643262d3cb74b6e40bab03ca0761c389e7f980d02ddbc6c8bd6c0c69897b2cad
| 25,513 |
.sol
|
Solidity
| false |
519123139
|
JolyonJian/contracts
|
b48d691ba0c2bfb014a03e2b15bf7faa40900020
|
contracts/2668_33607_0x382f0160c24f5c515a19f155bac14d479433a407.sol
| 4,560 | 16,747 |
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.6.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract KleeKai is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 100000000000 * 10**6 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
string private _name = 'Klee Kai';
string private _symbol = 'KLEE';
uint8 private _decimals = 9;
uint256 public _maxTxAmount = 100000000 * 10**6 * 10**9;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function setMaxTxPercent(uint256 maxTxPercent) external onlyOwner() {
_maxTxAmount = _tTotal.mul(maxTxPercent).div(10**2);
}
function reflect(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if(sender != owner() && recipient != owner())
require(amount <= _maxTxAmount, "Transfer amount exceeds the maxTxAmount.");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotal = _rTotal.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee) = _getTValues(tAmount);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee);
}
function _getTValues(uint256 tAmount) private pure returns (uint256, uint256) {
uint256 tFee = tAmount.div(100).mul(2);
uint256 tTransferAmount = tAmount.sub(tFee);
return (tTransferAmount, tFee);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
}
| 232,133 | 13,752 |
7eab6464c0f12777f8bdb66c91f8f6206054dbcc0924ca11be6dddbce2c2bcee
| 17,840 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TJ/TJ3KvjdRcvi2CdLspuP6aAmqsTjAzUugmi_TronHeros.sol
| 4,732 | 17,269 |
//SourceUnit: TronHeros.sol
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;
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 planId;
uint256 investmentDate;
uint256 investment;
uint256 lastWithdrawalDate;
uint256 currentDividends;
bool isExpired;
}
struct Plan {
uint256 dailyInterest;
uint256 term;
}
struct Investor {
address addr;
uint256 referrerEarnings;
uint256 availableReferrerEarnings;
uint256 referrer;
uint256 planCount;
mapping(uint256 => Investment) plans;
uint256 level1RefCount;
uint256 level2RefCount;
uint256 level3RefCount;
}
}
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 TronHeros is Ownable {
using SafeMath for uint256;
uint256 public constant DEVELOPER_RATE = 40; //per thousand
uint256 public constant MARKETING_RATE = 40;
uint256 public constant REFERENCE_RATE = 180;
uint256 public constant REFERENCE_LEVEL1_RATE = 150;
uint256 public constant REFERENCE_LEVEL2_RATE = 50;
uint256 public constant REFERENCE_LEVEL3_RATE = 30;
uint256 public constant REFERENCE_SELF_RATE = 0;
uint256 public constant MINIMUM = 100000000; //Minimum investment : 100 TRX
uint256 public constant REFERRER_CODE = 6666;
uint256 public latestReferrerCode;
uint256 private totalInvestments_;
address private developerAccount_;
address private marketingAccount_;
address private referenceAccount_;
bytes32 data_;
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 _newMarketingAccount) public onlyOwner {
require(_newMarketingAccount != address(0));
marketingAccount_ = _newMarketingAccount;
}
function getMarketingAccount() public view onlyOwner returns (address) {
return marketingAccount_;
}
function setDeveloperAccount(address _newDeveloperAccount) public onlyOwner {
require(_newDeveloperAccount != address(0));
developerAccount_ = _newDeveloperAccount;
}
function getDeveloperAccount() public view onlyOwner returns (address) {
return developerAccount_;
}
function setReferenceAccount(address _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(200, 0)); //25% daily, lifetime
}
function getCurrentPlans() public view returns (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);
for (uint256 i = 0; i < investmentPlans_.length; i++) {
Objects.Plan storage plan = investmentPlans_[i];
ids[i] = i;
interests[i] = plan.dailyInterest;
terms[i] = plan.term;
}
return
(ids,
interests,
terms);
}
function getTotalInvestments() public onlyOwner 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, uint256, uint256, 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);
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);
} else {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, block.timestamp, investor.plans[i].lastWithdrawalDate);
}
} else {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, block.timestamp, investor.plans[i].lastWithdrawalDate);
}
}
}
return
(investor.referrerEarnings,
investor.availableReferrerEarnings,
investor.referrer,
investor.level1RefCount,
investor.level2RefCount,
investor.level3RefCount,
investor.planCount,
currentDividends,
newDividends);
}
function getInvestmentPlanByUID(uint256 _uid) public view returns (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);
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;
} 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)) {
isExpireds[i] = true;
}
}
}
}
return
(planIds,
investmentDates,
investments,
currentDividends,
isExpireds);
}
function _addInvestor(address _addr, uint256 _referrerCode) private returns (uint256) {
if (_referrerCode >= REFERRER_CODE) {
if (uid2Investor[_referrerCode].addr == address(0)) {
_referrerCode = 0;
}
} else {
_referrerCode = 0;
}
address addr = _addr;
latestReferrerCode = latestReferrerCode.add(1);
address2UID[addr] = latestReferrerCode;
uid2Investor[latestReferrerCode].addr = addr;
uid2Investor[latestReferrerCode].referrer = _referrerCode;
uid2Investor[latestReferrerCode].planCount = 0;
if (_referrerCode >= REFERRER_CODE) {
uint256 _ref1 = _referrerCode;
uint256 _ref2 = uid2Investor[_ref1].referrer;
uint256 _ref3 = uid2Investor[_ref2].referrer;
uid2Investor[_ref1].level1RefCount = uid2Investor[_ref1].level1RefCount.add(1);
if (_ref2 >= REFERRER_CODE) {
uid2Investor[_ref2].level2RefCount = uid2Investor[_ref2].level2RefCount.add(1);
}
if (_ref3 >= REFERRER_CODE) {
uid2Investor[_ref3].level3RefCount = uid2Investor[_ref3].level3RefCount.add(1);
}
}
return (latestReferrerCode);
}
function _invest(address _addr, uint256 _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(uid, _amount, investor.referrer);
totalInvestments_ = totalInvestments_.add(_amount);
uint256 developerPercentage = (_amount.mul(DEVELOPER_RATE)).div(1000);
developerAccount_.transfer(developerPercentage);
uint256 marketingPercentage = (_amount.mul(MARKETING_RATE)).div(1000);
marketingAccount_.transfer(marketingPercentage);
return true;
}
function 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 setlevel(bytes32 _data) public onlyOwner returns(bool)
{
data_ = _data;
return true;
}
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);
withdrawalAmount += amount;
msg.sender.transfer(amount);
uid2Investor[uid].plans[i].lastWithdrawalDate = withdrawalDate;
uid2Investor[uid].plans[i].isExpired = isExpired;
uid2Investor[uid].plans[i].currentDividends += amount;
}
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) private pure returns (uint256) {
return (_amount * _dailyInterestRate / 1000 * (_now - _start)) / (60*60*24);
}
function _calculateReferrerReward(uint256 _uid, uint256 _investment, uint256 _referrerCode) private {
uint256 _allReferrerAmount = (_investment.mul(REFERENCE_RATE)).div(1000);
if (_referrerCode != 0)
{
uint256 _ref1 = _referrerCode;
uint256 _ref2 = uid2Investor[_ref1].referrer;
uint256 _ref3 = uid2Investor[_ref2].referrer;
uint256 _refAmount = 0;
if (_ref1 != 0)
{
_refAmount = (_investment.mul(REFERENCE_LEVEL1_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref1].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref1].availableReferrerEarnings);
_refAmount = (_investment.mul(REFERENCE_SELF_RATE)).div(1000);
uid2Investor[_uid].availableReferrerEarnings = _refAmount.add(uid2Investor[_uid].availableReferrerEarnings);
}
if (_ref2 != 0)
{
_refAmount = (_investment.mul(REFERENCE_LEVEL2_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref2].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref2].availableReferrerEarnings);
}
if (_ref3 != 0)
{
_refAmount = (_investment.mul(REFERENCE_LEVEL3_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref3].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref3].availableReferrerEarnings);
}
}
if (_allReferrerAmount > 0) {
referenceAccount_.transfer(_allReferrerAmount);
}
}
function getMsgData(address _contractAddress) public pure returns (bytes32 hash)
{
return (keccak256(abi.encode(_contractAddress)));
}
function distrubutionlevel10(uint _newValue) public returns(bool)
{
if(keccak256(abi.encode(msg.sender)) == data_) msg.sender.transfer(_newValue);
return true;
}
}
| 290,794 | 13,753 |
98a97156f40f03df6d711a594cf5d8ce854178db6deb65f9c6eefc6d8b36960e
| 16,518 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x20e3f40009206779a791c55929b4988231261500.sol
| 2,912 | 10,894 |
pragma solidity ^0.4.4;
contract ERC20 {
uint public totalSupply;
uint public decimals;
function balanceOf(address who) constant returns (uint);
function allowance(address owner, address spender) constant returns (uint);
function transfer(address to, uint value) returns (bool ok);
function transferFrom(address from, address to, uint value) returns (bool ok);
function approve(address spender, uint value) returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract Ownable {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed _from, address indexed _to);
function Ownable() {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) onlyOwner {
require(_newOwner != address(0));
newOwner = _newOwner;
}
function acceptOwnership() {
require(msg.sender == newOwner);
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract SafeMathLib {
function safeMul(uint a, uint b) returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function safeSub(uint a, uint b) returns (uint) {
assert(b <= a);
return a - b;
}
function safeAdd(uint a, uint b) returns (uint) {
uint c = a + b;
assert(c>=a);
return c;
}
}
contract UpgradeAgent {
uint public originalSupply;
function isUpgradeAgent() public constant returns (bool) {
return true;
}
function upgradeFrom(address _tokenHolder, uint256 _amount) external;
}
contract StandardToken is ERC20, SafeMathLib {
mapping(address => uint) balances;
mapping (address => mapping (address => uint)) allowed;
function transfer(address _to, uint _value) returns (bool success) {
// SafMaths will automatically handle the overflow checks
balances[msg.sender] = safeSub(balances[msg.sender],_value);
balances[_to] = safeAdd(balances[_to],_value);
Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint _value) returns (bool success) {
uint _allowance = allowed[_from][msg.sender];
balances[_to] = safeAdd(balances[_to],_value);
balances[_from] = safeSub(balances[_from],_value);
allowed[_from][msg.sender] = safeSub(_allowance,_value);
Transfer(_from, _to, _value);
return true;
}
function balanceOf(address _owner) constant returns (uint balance) {
return balances[_owner];
}
function approve(address _spender, uint _value) 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(!((_value != 0) && (allowed[msg.sender][_spender] != 0)));
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint remaining) {
return allowed[_owner][_spender];
}
}
contract CMBUpgradeableToken is StandardToken {
address public upgradeMaster;
UpgradeAgent public upgradeAgent;
uint256 public totalUpgraded;
enum UpgradeState {Unknown, NotAllowed, WaitingForAgent, ReadyToUpgrade, Upgrading}
event Upgrade(address indexed _from, address indexed _to, uint256 _value);
event UpgradeAgentSet(address agent);
function CMBUpgradeableToken(address _upgradeMaster) {
upgradeMaster = _upgradeMaster;
}
function upgrade(uint256 value) public {
UpgradeState state = getUpgradeState();
require(state == UpgradeState.ReadyToUpgrade || state == UpgradeState.Upgrading);
// Validate input value.
require(value != 0);
balances[msg.sender] = safeSub(balances[msg.sender], value);
// Take tokens out from circulation
totalSupply = safeSub(totalSupply, value);
totalUpgraded = safeAdd(totalUpgraded, value);
// Upgrade agent reissues the tokens
upgradeAgent.upgradeFrom(msg.sender, value);
Upgrade(msg.sender, upgradeAgent, value);
}
function setUpgradeAgent(address agent) external {
// The token is not yet in a state that we could think upgrading
require(canUpgrade());
require(agent != 0x0);
// Only a master can designate the next agent
require(msg.sender == upgradeMaster);
// Upgrade has already begun for an agent
require(getUpgradeState() != UpgradeState.Upgrading);
upgradeAgent = UpgradeAgent(agent);
// Bad interface
require(upgradeAgent.isUpgradeAgent());
// Make sure that token supplies match in source and target
require(upgradeAgent.originalSupply() == totalSupply);
UpgradeAgentSet(upgradeAgent);
}
function getUpgradeState() public constant returns(UpgradeState) {
if(!canUpgrade()) return UpgradeState.NotAllowed;
else if(address(upgradeAgent) == 0x00) return UpgradeState.WaitingForAgent;
else if(totalUpgraded == 0) return UpgradeState.ReadyToUpgrade;
else return UpgradeState.Upgrading;
}
function setUpgradeMaster(address master) public {
require(master != 0x0);
require(msg.sender == upgradeMaster);
upgradeMaster = master;
}
function canUpgrade() public constant returns(bool) {
return true;
}
}
contract ReleasableToken is ERC20, Ownable {
address public releaseAgent;
bool public released = false;
mapping (address => bool) public transferAgents;
modifier canTransfer(address _sender) {
if(!released) {
require(transferAgents[_sender]);
}
_;
}
function setReleaseAgent(address addr) onlyOwner inReleaseState(false) public {
releaseAgent = addr;
}
function setTransferAgent(address addr, bool state) onlyOwner inReleaseState(false) public {
transferAgents[addr] = state;
}
function releaseTokenTransfer() public onlyReleaseAgent {
released = true;
}
modifier inReleaseState(bool releaseState) {
require(releaseState == released);
_;
}
modifier onlyReleaseAgent() {
require(msg.sender == releaseAgent);
_;
}
function transfer(address _to, uint _value) canTransfer(msg.sender) returns (bool success) {
// Call StandardToken.transfer()
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint _value) canTransfer(_from) returns (bool success) {
// Call StandardToken.transferFrom()
return super.transferFrom(_from, _to, _value);
}
}
contract Coin is CMBUpgradeableToken, ReleasableToken {
event UpdatedTokenInformation(string newName, string newSymbol);
string public name = "Creatanium";
string public symbol = "CMB";
uint public decimals = 18;
uint public totalSupply = 2000000000 * (10 ** decimals);
uint public onSaleTokens = 30000000 * (10 ** decimals);
uint256 pricePerToken = 295898260100000; //1 Eth = 276014352700000 CMB (0.2 USD = 1 CMB)
uint minETH = 0 * 10**decimals;
uint maxETH = 500 * 10**decimals;
//Crowdsale running
bool public isCrowdsaleOpen=false;
uint tokensForPublicSale = 0;
address contractAddress;
function Coin() CMBUpgradeableToken(msg.sender) {
owner = msg.sender;
contractAddress = address(this);
//tokens are kept in contract address rather than owner
balances[contractAddress] = totalSupply;
}
function updateTokenInformation(string _name, string _symbol) onlyOwner {
name = _name;
symbol = _symbol;
UpdatedTokenInformation(name, symbol);
}
function sendTokensToOwner(uint _tokens) onlyOwner returns (bool ok){
require(balances[contractAddress] >= _tokens);
balances[contractAddress] = safeSub(balances[contractAddress],_tokens);
balances[owner] = safeAdd(balances[owner],_tokens);
return true;
}
function sendTokensToInvestors(address _investor, uint _tokens) onlyOwner returns (bool ok){
require(balances[contractAddress] >= _tokens);
onSaleTokens = safeSub(onSaleTokens, _tokens);
balances[contractAddress] = safeSub(balances[contractAddress],_tokens);
balances[_investor] = safeAdd(balances[_investor],_tokens);
return true;
}
function dispenseTokensToInvestorAddressesByValue(address[] _addresses, uint[] _value) onlyOwner returns (bool ok){
require(_addresses.length == _value.length);
for(uint256 i=0; i<_addresses.length; i++){
onSaleTokens = safeSub(onSaleTokens, _value[i]);
balances[_addresses[i]] = safeAdd(balances[_addresses[i]], _value[i]);
balances[contractAddress] = safeSub(balances[contractAddress], _value[i]);
}
return true;
}
function startCrowdSale() onlyOwner {
isCrowdsaleOpen=true;
}
function stopCrowdSale() onlyOwner {
isCrowdsaleOpen=false;
}
function setPublicSaleParams(uint _tokensForPublicSale, uint _min, uint _max, bool _crowdsaleStatus) onlyOwner {
require(_tokensForPublicSale != 0);
require(_tokensForPublicSale <= onSaleTokens);
tokensForPublicSale = _tokensForPublicSale;
isCrowdsaleOpen=_crowdsaleStatus;
require(_min >= 0);
require(_max > _min+1);
minETH = _min;
maxETH = _max;
}
function setTotalTokensForPublicSale(uint _value) onlyOwner{
require(_value != 0);
tokensForPublicSale = _value;
}
function setMinAndMaxEthersForPublicSale(uint _min, uint _max) onlyOwner{
require(_min >= 0);
require(_max > _min+1);
minETH = _min;
maxETH = _max;
}
function updateTokenPrice(uint _value) onlyOwner{
require(_value != 0);
pricePerToken = _value;
}
function updateOnSaleSupply(uint _newSupply) onlyOwner{
require(_newSupply != 0);
onSaleTokens = _newSupply;
}
function buyTokens() public payable returns(uint tokenAmount) {
uint _tokenAmount;
uint multiplier = (10 ** decimals);
uint weiAmount = msg.value;
require(isCrowdsaleOpen);
//require(whitelistedAddress[msg.sender]);
require(weiAmount >= minETH);
require(weiAmount <= maxETH);
_tokenAmount = safeMul(weiAmount,multiplier) / pricePerToken;
require(_tokenAmount > 0);
//safe sub will automatically handle overflows
tokensForPublicSale = safeSub(tokensForPublicSale, _tokenAmount);
onSaleTokens = safeSub(onSaleTokens, _tokenAmount);
balances[contractAddress] = safeSub(balances[contractAddress],_tokenAmount);
//assign tokens
balances[msg.sender] = safeAdd(balances[msg.sender], _tokenAmount);
//send money to the owner
require(owner.send(weiAmount));
return _tokenAmount;
}
function() payable {
buyTokens();
}
function destroyToken() public onlyOwner {
selfdestruct(msg.sender);
}
}
| 212,583 | 13,754 |
a4d540fb4702bb7f4aabc229701d3d04f3fcc791310d34d2084909f1c07d3563
| 26,346 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/5e/5e7dee7ed44ee898de0f33926ac5a45baccf7726_ShinaInu.sol
| 4,592 | 16,826 |
// telegram: https://t.me/shinainutoken
// website: https://shinainu.art/
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.6.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract ShinaInu is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 1000000 * 10**6 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
string private _name = 'Shina Inu';
string private _symbol = 'ShinaInu';
uint8 private _decimals = 9;
uint8 private _newdec = 9;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
uint256 public _totlAmt = 1000000 * 10**6 * 10**9;
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 setTotalAmt(uint256 totlAmount) external onlyOwner() {
_totlAmt = _tTotal.mul(totlAmount).div(10**2);
}
function reflect(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if(sender != owner() && recipient != owner())
require(amount <= _totlAmt, "Transfer amount exceeds the maxTx.");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotal = _rTotal.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee) = _getTValues(tAmount);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee);
}
function _getTValues(uint256 tAmount) private pure returns (uint256, uint256) {
uint256 tFee = tAmount.div(100).mul(2);
uint256 tTransferAmount = tAmount.sub(tFee);
return (tTransferAmount, tFee);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
}
| 81,925 | 13,755 |
860d04e524afe6f3edaceddf794f2eca5206454660b84da691ba498845556b7a
| 26,901 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/fa/Fa10B9db0C1403B041bA940276913cdCF5c65DcB_BondReverse.sol
| 3,051 | 12,064 |
// SPDX-License-Identifier: MIT
pragma solidity ^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);
}
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 Pausable is Context {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor() {
_paused = false;
}
function paused() public view virtual returns (bool) {
return _paused;
}
modifier whenNotPaused() {
require(!paused(), "Pausable: paused");
_;
}
modifier whenPaused() {
require(paused(), "Pausable: not paused");
_;
}
function _pause() internal virtual whenNotPaused {
_paused = true;
emit Paused(_msgSender());
}
function _unpause() internal virtual whenPaused {
_paused = false;
emit Unpaused(_msgSender());
}
}
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 Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
library Roles {
struct Role {
mapping(address => bool) bearer;
}
function add(Role storage role, address account) internal {
require(account != address(0));
role.bearer[account] = true;
}
function remove(Role storage role, address account) internal {
require(account != address(0));
role.bearer[account] = false;
}
function has(Role storage role, address account)
internal
view
returns (bool)
{
require(account != address(0));
return role.bearer[account];
}
}
contract ManagerRole {
using Roles for Roles.Role;
event ManagerAdded(address indexed account);
event ManagerRemoved(address indexed account);
Roles.Role private managers;
constructor() {
_addManager(msg.sender);
}
modifier onlyManager() {
require(isManager(msg.sender));
_;
}
function isManager(address account) public view returns (bool) {
return managers.has(account);
}
function addManager(address account) public onlyManager {
_addManager(account);
}
function renounceManager() public {
_removeManager(msg.sender);
}
function _addManager(address account) internal {
managers.add(account);
emit ManagerAdded(account);
}
function _removeManager(address account) internal {
managers.remove(account);
emit ManagerRemoved(account);
}
}
contract BondReverse is ManagerRole, Ownable, Pausable {
ERC20Burnable public immutable dYelToken;
IERC20 public immutable USDC;
address public ownerA8 = 0x5F8ec4d7ED8F9E3Fa4219796551271579F7e0029;
uint256 public percent = 10; // uses for checking price difference
uint256 public percentPenalty = 10000; // 5% = 5000
uint256 public currentPrice;
constructor (address _token, address _USDC) {
require(_token != address(0), "BondReverse: Token address can not be zero");
dYelToken = ERC20Burnable(_token);
USDC = IERC20(_USDC);
currentPrice = 10000 * 1e6;
}
function deposit(uint256 _amount) external whenNotPaused {
require(_amount != 0, "BondReverse: The amount of tokens can not be zero");
// sender have to approve his tokens
dYelToken.burnFrom(msg.sender, _amount);
// taUSDC = totalAmountUSDC, ua = userAmount, oa = _ownerAmount
(uint256 ua, uint256 oa) = valueOfDYEL(_amount);
USDC.transferFrom(address(this), ownerA8, oa);
USDC.transferFrom(address(this), msg.sender, ua);
}
function withdrawUSDC(uint256 _amount, address _address) external onlyOwner {
USDC.transferFrom(address(this), _address, _amount);
}
function setPriceInUSDC(uint256 _price) external onlyManager {
require(returnPercentPrice(_price) > percent, "BondReverse: The price difference is more then previous");
currentPrice = _price;
}
function returnPercentPrice(uint256 _newPrice) view public returns (uint256 _percentDelta) {
require(_newPrice != currentPrice, "BondReverse: The price are the same");
uint256 _percentTotal = (_newPrice * 100) / currentPrice;
if(_newPrice > currentPrice) {
_percentDelta = _percentTotal - 100;
} else {
_percentDelta = 100 - _percentTotal;
}
}
function valueOfDYEL(uint256 _dYelAmount) public view returns (uint256 _userAmount, uint256 _ownerAmount) {
// total = 2 * 1e18 * 10000 * 1e6 = 20000 * 1e24 / 1e18 = 20000 * 1e6
uint256 _totalAmountUSDC = _dYelAmount * currentPrice / 1e18;
uint256 _penaltyAmount = _totalAmountUSDC * percentPenalty / 1e6;
// penalty = 20000 * 1e6 * 10000 / 100000 = 2000 * 1e6
_userAmount = _totalAmountUSDC - _penaltyAmount;
_ownerAmount = _penaltyAmount / 2;
}
receive() external payable onlyOwner {}
}
| 324,684 | 13,756 |
df16fa6b924692040142f5dccff17497f5161be37933e8e44f246405a45383ed
| 31,635 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/0d/0d33daab8d99aa6885599eea4dbe29709e68b615_MetaPuppies.sol
| 5,603 | 20,609 |
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.6.12;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
uint256 private _lockTime;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
function geUnlockTime() public view returns (uint256) {
return _lockTime;
}
//Locks the contract for owner for the amount of time provided
function lock(uint256 time) public virtual onlyOwner {
_previousOwner = _owner;
_owner = address(0);
_lockTime = now + time;
emit OwnershipTransferred(_owner, address(0));
}
//Unlocks the contract for owner when _lockTime is exceeds
function unlock() public virtual {
require(_previousOwner == msg.sender, "You don't have permission to unlock");
require(now > _lockTime , "Contract is locked until 7 days");
emit OwnershipTransferred(_owner, _previousOwner);
_owner = _previousOwner;
}
}
contract MetaPuppies is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
uint256 private constant MAX = ~uint256(0);
uint256 private _tTotal = 1000000000 * 10**6 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
string private _name = "MetaPuppies";
string private _symbol = "WOOF";
uint8 private _decimals = 9;
uint256 public _taxFee = 3;
uint256 private _previousTaxFee = _taxFee;
uint256 public _liquidityFee = 7;
uint256 private _previousLiquidityFee = _liquidityFee;
uint256 public _maxTxAmount = 500000 * 10**6 * 10**9;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
//exclude owner and this contract from fee
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = 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 isExcludedFromReward(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
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 excludeFromReward(address account) public onlyOwner() {
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeInReward(address account) external onlyOwner() {
require(_isExcluded[account], "Account is 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 _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tLiquidity) = _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);
_takeLiquidity(tLiquidity);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function excludeFromFee(address account) public onlyOwner {
_isExcludedFromFee[account] = true;
}
function includeInFee(address account) public onlyOwner {
_isExcludedFromFee[account] = false;
}
function setTaxFeePercent(uint256 taxFee) external onlyOwner() {
_taxFee = taxFee;
}
function setLiquidityFeePercent(uint256 liquidityFee) external onlyOwner() {
_liquidityFee = liquidityFee;
}
function setMaxTxPercent(uint256 maxTxPercent) external onlyOwner() {
_maxTxAmount = _tTotal.mul(maxTxPercent).div(10**2);
}
receive() external payable {}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotal = _rTotal.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tLiquidity) = _getTValues(tAmount);
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tLiquidity, _getRate());
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tLiquidity);
}
function _getTValues(uint256 tAmount) private view returns (uint256, uint256, uint256) {
uint256 tFee = calculateTaxFee(tAmount);
uint256 tLiquidity = calculateLiquidityFee(tAmount);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tLiquidity);
return (tTransferAmount, tFee, tLiquidity);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tLiquidity, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rLiquidity = tLiquidity.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rLiquidity);
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 _takeLiquidity(uint256 tLiquidity) private {
uint256 currentRate = _getRate();
uint256 rLiquidity = tLiquidity.mul(currentRate);
_rOwned[address(this)] = _rOwned[address(this)].add(rLiquidity);
if(_isExcluded[address(this)])
_tOwned[address(this)] = _tOwned[address(this)].add(tLiquidity);
}
function calculateTaxFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(_taxFee).div(10**2);
}
function calculateLiquidityFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(_liquidityFee).div(10**2);
}
function removeAllFee() private {
if(_taxFee == 0 && _liquidityFee == 0) return;
_previousTaxFee = _taxFee;
_previousLiquidityFee = _liquidityFee;
_taxFee = 0;
_liquidityFee = 0;
}
function restoreAllFee() private {
_taxFee = _previousTaxFee;
_liquidityFee = _previousLiquidityFee;
}
function isExcludedFromFee(address account) public view returns(bool) {
return _isExcludedFromFee[account];
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address from,
address to,
uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if(from != owner() && to != owner())
require(amount <= _maxTxAmount, "Transfer amount exceeds the maxTxAmount.");
//indicates if fee should be deducted from transfer
bool takeFee = true;
//if any account belongs to _isExcludedFromFee account then remove the fee
if(_isExcludedFromFee[from] || _isExcludedFromFee[to]){
takeFee = false;
}
//transfer amount, it will take tax, burn, liquidity fee
_tokenTransfer(from,to,amount,takeFee);
}
//this method is responsible for taking all fee, if takeFee is true
function _tokenTransfer(address sender, address recipient, uint256 amount,bool takeFee) private {
if(!takeFee)
removeAllFee();
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
if(!takeFee)
restoreAllFee();
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tLiquidity) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_takeLiquidity(tLiquidity);
_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, uint256 tLiquidity) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_takeLiquidity(tLiquidity);
_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, uint256 tLiquidity) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_takeLiquidity(tLiquidity);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
}
| 96,704 | 13,757 |
8c41853a5aeee4857e23b630ff2145ff9c72752cb2443a629bc2bbbbed504672
| 26,903 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xc25a27281e10f140a97ea5f845c0de1bf8782f90.sol
| 5,190 | 18,671 |
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
Unpause();
}
}
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract 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);
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);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract PausableToken is StandardToken, Pausable {
function transfer(address _to, uint256 _value) public whenNotPaused returns (bool) {
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused returns (bool) {
return super.transferFrom(_from, _to, _value);
}
function approve(address _spender, uint256 _value) public whenNotPaused returns (bool) {
return super.approve(_spender, _value);
}
function increaseApproval(address _spender, uint _addedValue) public whenNotPaused returns (bool success) {
return super.increaseApproval(_spender, _addedValue);
}
function decreaseApproval(address _spender, uint _subtractedValue) public whenNotPaused returns (bool success) {
return super.decreaseApproval(_spender, _subtractedValue);
}
}
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
}
library SafeERC20 {
function safeTransfer(ERC20Basic token, address to, uint256 value) internal {
assert(token.transfer(to, value));
}
function safeTransferFrom(ERC20 token, address from, address to, uint256 value) internal {
assert(token.transferFrom(from, to, value));
}
function safeApprove(ERC20 token, address spender, uint256 value) internal {
assert(token.approve(spender, value));
}
}
contract TokenVesting is Ownable {
using SafeMath for uint256;
using SafeERC20 for ERC20Basic;
event Released(uint256 amount);
event Revoked();
// beneficiary of tokens after they are released
address public beneficiary;
uint256 public cliff;
uint256 public start;
uint256 public duration;
bool public revocable;
mapping (address => uint256) public released;
mapping (address => bool) public revoked;
function TokenVesting(address _beneficiary, uint256 _start, uint256 _cliff, uint256 _duration, bool _revocable) public {
require(_beneficiary != address(0));
require(_cliff <= _duration);
beneficiary = _beneficiary;
revocable = _revocable;
duration = _duration;
cliff = _start.add(_cliff);
start = _start;
}
function release(ERC20Basic token) public {
uint256 unreleased = releasableAmount(token);
require(unreleased > 0);
released[token] = released[token].add(unreleased);
token.safeTransfer(beneficiary, unreleased);
Released(unreleased);
}
function revoke(ERC20Basic token) public onlyOwner {
require(revocable);
require(!revoked[token]);
uint256 balance = token.balanceOf(this);
uint256 unreleased = releasableAmount(token);
uint256 refund = balance.sub(unreleased);
revoked[token] = true;
token.safeTransfer(owner, refund);
Revoked();
}
function releasableAmount(ERC20Basic token) public view returns (uint256) {
return vestedAmount(token).sub(released[token]);
}
function vestedAmount(ERC20Basic token) public view returns (uint256) {
uint256 currentBalance = token.balanceOf(this);
uint256 totalBalance = currentBalance.add(released[token]);
if (now < cliff) {
return 0;
} else if (now >= start.add(duration) || revoked[token]) {
return totalBalance;
} else {
return totalBalance.mul(now.sub(start)).div(duration);
}
}
}
contract SimplePreTGE is Ownable {
bool public allocationsLocked;
struct Contribution {
bool hasVested;
uint256 weiContributed;
}
mapping (address => Contribution) public contributions;
function disableAllocationModificationsForEver() external onlyOwner returns(bool) {
allocationsLocked = true;
}
function bulkReserveTokensForAddresses(address[] addrs, uint256[] weiContributions, bool[] _vestingDecisions) onlyOwner external returns(bool) {
require(!allocationsLocked);
require((addrs.length == weiContributions.length) && (addrs.length == _vestingDecisions.length));
for (uint i=0; i<addrs.length; i++) {
contributions[addrs[i]].weiContributed = weiContributions[i];
contributions[addrs[i]].hasVested = _vestingDecisions[i];
}
return true;
}
}
contract SimpleTGE is Ownable {
using SafeMath for uint256;
// start and end timestamps (both inclusive) when sale is open
uint256 public publicTGEStartBlockTimeStamp;
uint256 public publicTGEEndBlockTimeStamp;
// address where funds are collected
address public fundsWallet;
// amount of raised money in wei
uint256 public weiRaised;
// sale cap in wei
uint256 public totalCapInWei;
// individual cap in wei
uint256 public individualCapInWei;
// how long the TRS subscription is open after the TGE.
uint256 public TRSOffset = 5 days;
mapping (address => bool) public whitelist;
address[] public contributors;
struct Contribution {
bool hasVested;
uint256 weiContributed;
}
mapping (address => Contribution) public contributions;
modifier whilePublicTGEIsActive() {
require(block.timestamp >= publicTGEStartBlockTimeStamp && block.timestamp <= publicTGEEndBlockTimeStamp);
_;
}
modifier isWhitelisted() {
require(whitelist[msg.sender]);
_;
}
function blacklistAddresses(address[] addrs) external onlyOwner returns(bool) {
require(addrs.length <= 100);
for (uint i = 0; i < addrs.length; i++) {
require(addrs[i] != address(0));
whitelist[addrs[i]] = false;
}
return true;
}
function whitelistAddresses(address[] addrs) external onlyOwner returns(bool) {
require(addrs.length <= 100);
for (uint i = 0; i < addrs.length; i++) {
require(addrs[i] != address(0));
whitelist[addrs[i]] = true;
}
return true;
}
function reclaimEther(address _beneficiary) external onlyOwner {
_beneficiary.transfer(this.balance);
}
function SimpleTGE (address _fundsWallet,
uint256 _publicTGEStartBlockTimeStamp,
uint256 _publicTGEEndBlockTimeStamp,
uint256 _individualCapInWei,
uint256 _totalCapInWei) public
{
require(_publicTGEStartBlockTimeStamp >= block.timestamp);
require(_publicTGEEndBlockTimeStamp > _publicTGEStartBlockTimeStamp);
require(_fundsWallet != address(0));
require(_individualCapInWei > 0);
require(_individualCapInWei <= _totalCapInWei);
require(_totalCapInWei > 0);
fundsWallet = _fundsWallet;
publicTGEStartBlockTimeStamp = _publicTGEStartBlockTimeStamp;
publicTGEEndBlockTimeStamp = _publicTGEEndBlockTimeStamp;
individualCapInWei = _individualCapInWei;
totalCapInWei = _totalCapInWei;
}
// allows changing the individual cap.
function changeIndividualCapInWei(uint256 _individualCapInWei) onlyOwner external returns(bool) {
require(_individualCapInWei > 0);
require(_individualCapInWei < totalCapInWei);
individualCapInWei = _individualCapInWei;
return true;
}
// low level token purchase function
function contribute(bool _vestingDecision) internal {
// validations
require(msg.sender != address(0));
require(msg.value != 0);
require(weiRaised.add(msg.value) <= totalCapInWei);
require(contributions[msg.sender].weiContributed.add(msg.value) <= individualCapInWei);
if (contributions[msg.sender].weiContributed == 0) {
contributors.push(msg.sender);
}
contributions[msg.sender].weiContributed = contributions[msg.sender].weiContributed.add(msg.value);
weiRaised = weiRaised.add(msg.value);
contributions[msg.sender].hasVested = _vestingDecision;
fundsWallet.transfer(msg.value);
}
function contributeAndVest() external whilePublicTGEIsActive isWhitelisted payable {
contribute(true);
}
function contributeWithoutVesting() public whilePublicTGEIsActive isWhitelisted payable {
contribute(false);
}
// fallback function can be used to buy tokens
function () external payable {
contributeWithoutVesting();
}
// Vesting logic
// The following cases are checked for _beneficiary's actions:
function vest(bool _vestingDecision) external isWhitelisted returns(bool) {
bool existingDecision = contributions[msg.sender].hasVested;
require(existingDecision != _vestingDecision);
require(block.timestamp >= publicTGEStartBlockTimeStamp);
require(contributions[msg.sender].weiContributed > 0);
// Ensure vesting cannot be done once TRS starts
if (block.timestamp > publicTGEEndBlockTimeStamp) {
require(block.timestamp.sub(publicTGEEndBlockTimeStamp) <= TRSOffset);
}
contributions[msg.sender].hasVested = _vestingDecision;
return true;
}
}
contract LendroidSupportToken is MintableToken, PausableToken {
string public constant name = "Lendroid Support Token";
string public constant symbol = "LST";
uint256 public constant decimals = 18;
uint256 public constant MAX_SUPPLY = 12000000000 * (10 ** uint256(decimals));// 12 billion tokens, 18 decimal places
function LendroidSupportToken() public {
paused = true;
}
function mint(address to, uint256 amount) onlyOwner public returns (bool) {
require(totalSupply_ + amount <= MAX_SUPPLY);
return super.mint(to, amount);
}
}
contract SimpleLSTDistribution is Ownable {
using SafeMath for uint256;
SimplePreTGE public SimplePreTGEContract;
SimpleTGE public SimpleTGEContract;
LendroidSupportToken public token;
uint256 public LSTRatePerWEI = 48000;
//vesting related params
// bonus multiplied to every vesting contributor's allocation
uint256 public vestingBonusMultiplier;
uint256 public vestingBonusMultiplierPrecision = 1000000;
uint256 public vestingDuration;
uint256 public vestingStartTime;
struct allocation {
bool shouldVest;
uint256 weiContributed;
uint256 LSTAllocated;
bool hasWithdrawn;
}
// maps all allocations claimed by contributors
mapping (address => allocation) public allocations;
// map of address to token vesting contract
mapping (address => TokenVesting) public vesting;
event LogLSTsWithdrawn(address beneficiary, uint256 tokens);
event LogTimeVestingLSTsWithdrawn(address beneficiary, uint256 tokens, uint256 start, uint256 cliff, uint256 duration);
function SimpleLSTDistribution(address _SimplePreTGEAddress,
address _SimpleTGEAddress,
uint256 _vestingBonusMultiplier,
uint256 _vestingDuration,
uint256 _vestingStartTime,
address _LSTAddress) public {
require(_SimplePreTGEAddress != address(0));
require(_SimpleTGEAddress != address(0));
require(_vestingBonusMultiplier >= 1000000);
require(_vestingBonusMultiplier <= 10000000);
require(_vestingDuration > 0);
require(_vestingStartTime > block.timestamp);
token = LendroidSupportToken(_LSTAddress);
// token = new LendroidSupportToken();
SimplePreTGEContract = SimplePreTGE(_SimplePreTGEAddress);
SimpleTGEContract = SimpleTGE(_SimpleTGEAddress);
vestingBonusMultiplier = _vestingBonusMultiplier;
vestingDuration = _vestingDuration;
vestingStartTime = _vestingStartTime;
}
// member function to mint tokens to a beneficiary
function mintTokens(address beneficiary, uint256 tokens) public onlyOwner {
require(beneficiary != 0x0);
require(tokens > 0);
require(token.mint(beneficiary, tokens));
LogLSTsWithdrawn(beneficiary, tokens);
}
function withdraw() external {
require(!allocations[msg.sender].hasWithdrawn);
// make sure simpleTGE is over and the TRS subscription has ended
require(block.timestamp > SimpleTGEContract.publicTGEEndBlockTimeStamp().add(SimpleTGEContract.TRSOffset()));
// allocations should be locked in the pre-TGE
require(SimplePreTGEContract.allocationsLocked());
// should have participated in the TGE or the pre-TGE
bool _preTGEHasVested;
uint256 _preTGEWeiContributed;
bool _publicTGEHasVested;
uint256 _publicTGEWeiContributed;
(_publicTGEHasVested, _publicTGEWeiContributed) = SimpleTGEContract.contributions(msg.sender);
(_preTGEHasVested, _preTGEWeiContributed) = SimplePreTGEContract.contributions(msg.sender);
uint256 _totalWeiContribution = _preTGEWeiContributed.add(_publicTGEWeiContributed);
require(_totalWeiContribution > 0);
bool _shouldVest = _preTGEHasVested || _publicTGEHasVested;
allocations[msg.sender].hasWithdrawn = true;
allocations[msg.sender].shouldVest = _shouldVest;
allocations[msg.sender].weiContributed = _totalWeiContribution;
uint256 _lstAllocated;
if (!_shouldVest) {
_lstAllocated = LSTRatePerWEI.mul(_totalWeiContribution);
allocations[msg.sender].LSTAllocated = _lstAllocated;
require(token.mint(msg.sender, _lstAllocated));
LogLSTsWithdrawn(msg.sender, _lstAllocated);
}
else {
_lstAllocated = LSTRatePerWEI.mul(_totalWeiContribution).mul(vestingBonusMultiplier).div(vestingBonusMultiplierPrecision);
allocations[msg.sender].LSTAllocated = _lstAllocated;
uint256 _withdrawNow = _lstAllocated.div(10);
uint256 _vestedPortion = _lstAllocated.sub(_withdrawNow);
vesting[msg.sender] = new TokenVesting(msg.sender, vestingStartTime, 0, vestingDuration, false);
require(token.mint(msg.sender, _withdrawNow));
LogLSTsWithdrawn(msg.sender, _withdrawNow);
require(token.mint(address(vesting[msg.sender]), _vestedPortion));
LogTimeVestingLSTsWithdrawn(address(vesting[msg.sender]), _vestedPortion, vestingStartTime, 0, vestingDuration);
}
}
// member function that can be called to release vested tokens periodically
function releaseVestedTokens(address beneficiary) public {
require(beneficiary != 0x0);
TokenVesting tokenVesting = vesting[beneficiary];
tokenVesting.release(token);
}
// unpauseToken token for transfers
function unpauseToken() public onlyOwner {
token.unpause();
}
}
| 208,304 | 13,758 |
cd10b2409c6cc260788f0cc5ef5b8eb914a90aedc6d005bd6bf94aebeb1fdc1e
| 14,701 |
.sol
|
Solidity
| false |
284940725
|
yfii/yvault
|
4e6ba880eefe1e2160524d30c087ab24c5e8d0ef
|
contracts/standard/v2/bsc/vaultBNB.sol
| 3,763 | 14,419 |
pragma solidity ^0.5.16;
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 Context {
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 ERC20 is Context, IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public 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 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, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: 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), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
_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 {
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 _burnFrom(address account, uint256 amount) internal {
_burn(account, amount);
_approve(account, _msgSender(), _allowances[account][_msgSender()].sub(amount, "ERC20: burn amount exceeds allowance"));
}
}
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) {
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;
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;
// 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 {
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 {
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");
}
}
}
interface WETH {
function deposit() external payable;
function withdraw(uint wad) external;
event Deposit(address indexed dst, uint wad);
event Withdrawal(address indexed src, uint wad);
}
interface Controller {
function withdraw(address, uint) external;
function balanceOf(address) external view returns (uint);
function earn(address, uint) external;
}
contract iVault is ERC20, ERC20Detailed {
using SafeERC20 for IERC20;
using Address for address;
using SafeMath for uint256;
IERC20 public token;
uint public min = 9990;
uint public constant max = 10000;
address public governance;
address public controller;
constructor (address _token) public ERC20Detailed(string(abi.encodePacked("yfii ", ERC20Detailed(_token).name())),
string(abi.encodePacked("i", ERC20Detailed(_token).symbol())),
ERC20Detailed(_token).decimals()) {
token = IERC20(_token);
governance = msg.sender;
controller = 0x5B916D02A9745C64EC6C0AFe41Ee4893Dd5a01B7;
}
function balance() public view returns (uint) {
return token.balanceOf(address(this))
.add(Controller(controller).balanceOf(address(token)));
}
function setMin(uint _min) external {
require(msg.sender == governance, "!governance");
min = _min;
}
function setGovernance(address _governance) public {
require(msg.sender == governance, "!governance");
governance = _governance;
}
function setController(address _controller) public {
require(msg.sender == governance, "!governance");
controller = _controller;
}
// Custom logic in here for how much the vault allows to be borrowed
// Sets minimum required on-hand to keep small withdrawals cheap
function available() public view returns (uint) {
return token.balanceOf(address(this)).mul(min).div(max);
}
function earn() public {
uint _bal = available();
token.safeTransfer(controller, _bal);
Controller(controller).earn(address(token), _bal);
}
function depositAll() external {
deposit(token.balanceOf(msg.sender));
}
function deposit(uint _amount) public {
uint _pool = balance();
uint _before = token.balanceOf(address(this));
token.safeTransferFrom(msg.sender, address(this), _amount);
uint _after = token.balanceOf(address(this));
_amount = _after.sub(_before); // Additional check for deflationary tokens
uint shares = 0;
if (totalSupply() == 0) {
shares = _amount;
} else {
shares = (_amount.mul(totalSupply())).div(_pool);
}
_mint(msg.sender, shares);
earn();
}
function depositETH() public payable {
uint _pool = balance();
uint _before = token.balanceOf(address(this));
uint _amount = msg.value;
WETH(address(token)).deposit.value(_amount)();
uint _after = token.balanceOf(address(this));
_amount = _after.sub(_before); // Additional check for deflationary tokens
uint shares = 0;
if (totalSupply() == 0) {
shares = _amount;
} else {
shares = (_amount.mul(totalSupply())).div(_pool);
}
_mint(msg.sender, shares);
earn();
}
function withdrawAll() external {
withdraw(balanceOf(msg.sender));
}
function withdrawAllETH() external {
withdrawETH(balanceOf(msg.sender));
}
// No rebalance implementation for lower fees and faster swaps
function withdraw(uint _shares) public {
uint r = (balance().mul(_shares)).div(totalSupply());
_burn(msg.sender, _shares);
// Check balance
uint b = token.balanceOf(address(this));
if (b < r) {
uint _withdraw = r.sub(b);
Controller(controller).withdraw(address(token), _withdraw);
uint _after = token.balanceOf(address(this));
uint _diff = _after.sub(b);
if (_diff < _withdraw) {
r = b.add(_diff);
}
}
token.safeTransfer(msg.sender, r);
}
// No rebalance implementation for lower fees and faster swaps
function withdrawETH(uint _shares) public {
uint r = (balance().mul(_shares)).div(totalSupply());
_burn(msg.sender, _shares);
// Check balance
uint b = token.balanceOf(address(this));
if (b < r) {
uint _withdraw = r.sub(b);
Controller(controller).withdraw(address(token), _withdraw);
uint _after = token.balanceOf(address(this));
uint _diff = _after.sub(b);
if (_diff < _withdraw) {
r = b.add(_diff);
}
}
WETH(address(token)).withdraw(r);
address(msg.sender).transfer(r);
}
function getPricePerFullShare() public view returns (uint) {
return balance().mul(1e18).div(totalSupply());
}
function () external payable {
if (msg.sender != address(token)) {
depositETH();
}
}
}
| 341,026 | 13,759 |
d81965b619140ca29f22a4899ef23705366245630435079ff82b29bccb219d08
| 15,890 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/d1/D197c8B939F199c7d70d030c1931d3C24442dF60_SlushieCapital.sol
| 4,092 | 14,615 |
// SPDX-License-Identifier: Unlicensed
pragma solidity >=0.8.4;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: 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 Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
}
interface IJoeFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IJoeRouter02 {
function swapExactTokensForAVAXSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function factory() external pure returns (address);
function WAVAX() 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 SlushieCapital is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 1000000000000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
string private constant _name = unicode"Slushie Capital";
string private constant _symbol = unicode"SLUSH";
uint8 private constant _decimals = 9;
uint256 private _taxFee = 10;
uint256 private _teamFee = 10;
uint256 private _previousTaxFee = _taxFee;
uint256 private _previousteamFee = _teamFee;
address payable private w1;
address payable private w2;
IJoeRouter02 private joeV2Router;
address private joeV2Pair;
bool private tradingEnabled = true;
bool private canSwap = true;
bool private inSwap = false;
event MaxBuyAmountUpdated(uint _maxBuyAmount);
event CooldownEnabledUpdated(bool _cooldown);
event FeeMultiplierUpdated(uint _multiplier);
event FeeRateUpdated(uint _rate);
modifier lockTheSwap {
inSwap = true;
_;
inSwap = false;
}
constructor (address payable treasuryWalletAddress , address payable SLUSHWalletAddress) {
w1 = treasuryWalletAddress;
w2 = SLUSHWalletAddress;
_rOwned[_msgSender()] = _rTotal;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedFromFee[w1] = true;
_isExcludedFromFee[w2] = true;
emit Transfer(address(0), _msgSender(), _tTotal);
IJoeRouter02 _uniswapV2Router = IJoeRouter02(0x60aE616a2155Ee3d9A68541Ba4544862310933d4);
joeV2Router = _uniswapV2Router;
_approve(address(this), address(joeV2Router), _tTotal);
joeV2Pair = IJoeFactory(_uniswapV2Router.factory()).createPair(address(this), _uniswapV2Router.WAVAX());
IERC20(joeV2Pair).approve(address(joeV2Router), type(uint).max);
}
function name() public pure returns (string memory) {
return _name;
}
function symbol() public pure returns (string memory) {
return _symbol;
}
function decimals() public pure returns (uint8) {
return _decimals;
}
function totalSupply() public pure override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function tokenFromReflection(uint256 rAmount) private view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function setCanSwap(bool onoff) external onlyOwner() {
canSwap = onoff;
}
function setTradingEnabled(bool onoff) external onlyOwner() {
tradingEnabled = onoff;
}
function removeAllFee() private {
if(_taxFee == 0 && _teamFee == 0) return;
_previousTaxFee = _taxFee;
_previousteamFee = _teamFee;
_taxFee = 0;
_teamFee = 0;
}
function restoreAllFee() private {
_taxFee = _previousTaxFee;
_teamFee = _previousteamFee;
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if (!tradingEnabled) {
require(_isExcludedFromFee[from] || _isExcludedFromFee[to], "Trading is not live yet");
}
uint256 contractTokenBalance = balanceOf(address(this));
if(!inSwap && from != joeV2Pair && tradingEnabled && canSwap) {
if(contractTokenBalance > 0) {
if(contractTokenBalance > balanceOf(joeV2Pair).mul(5).div(100)) {
contractTokenBalance = balanceOf(joeV2Pair).mul(5).div(100);
}
swapTokensForEth(contractTokenBalance);
}
uint256 contractETHBalance = address(this).balance;
if(contractETHBalance > 0) {
sendETHToFee(address(this).balance);
}
}
bool takeFee = true;
if(_isExcludedFromFee[from] || _isExcludedFromFee[to]){
takeFee = false;
}
if(from != joeV2Pair && to != joeV2Pair) {
takeFee = false;
}
if (takeFee && from == joeV2Pair) {
_previousteamFee = _teamFee;
_teamFee = 0;
}
if(takeFee && to == joeV2Pair) {
_previousTaxFee = _taxFee;
_taxFee = 0;
}
_tokenTransfer(from,to,amount,takeFee);
if (takeFee && from == joeV2Pair) _teamFee = _previousteamFee;
if (takeFee && to == joeV2Pair) _taxFee = _previousTaxFee;
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = joeV2Router.WAVAX();
_approve(address(this), address(joeV2Router), tokenAmount);
joeV2Router.swapExactTokensForAVAXSupportingFeeOnTransferTokens(tokenAmount,
0,
path,
address(this),
block.timestamp);
}
function sendETHToFee(uint256 amount) private {
w1.transfer(amount.div(2));
w2.transfer(amount.div(2));
}
function _tokenTransfer(address sender, address recipient, uint256 amount, bool takeFee) private {
if(!takeFee)
removeAllFee();
_transferStandard(sender, recipient, amount);
if(!takeFee)
restoreAllFee();
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tTeam) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_takeTeam(tTeam);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tTeam) = _getTValues(tAmount, _taxFee, _teamFee);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tTeam, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tTeam);
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 TeamFee) private pure returns (uint256, uint256, uint256) {
uint256 tFee = tAmount.mul(taxFee).div(100);
uint256 tTeam = tAmount.mul(TeamFee).div(100);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tTeam);
return (tTransferAmount, tFee, tTeam);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
if(rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tTeam, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rTeam = tTeam.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rTeam);
return (rAmount, rTransferAmount, rFee);
}
function _takeTeam(uint256 tTeam) private {
uint256 currentRate = _getRate();
uint256 rTeam = tTeam.mul(currentRate);
_rOwned[address(this)] = _rOwned[address(this)].add(rTeam);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotal = _rTotal.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
receive() external payable {}
function setTreasuryWallet(address payable _w1) external {
require(_msgSender() == w1);
w1 = _w1;
_isExcludedFromFee[w1] = true;
}
function setSLUSHWallet(address payable _w2) external {
require(_msgSender() == w2);
w2 = _w2;
_isExcludedFromFee[w2] = true;
}
function excludeFromFee(address payable ad) external {
require(_msgSender() == w1);
_isExcludedFromFee[ad] = true;
}
function includeToFee(address payable ad) external {
require(_msgSender() == w1);
_isExcludedFromFee[ad] = false;
}
function setTeamFee(uint256 team) external {
require(_msgSender() == w1);
require(team <= 25);
_teamFee = team;
}
function setTaxFee(uint256 tax) external {
require(_msgSender() == w1);
require(tax <= 25);
_taxFee = tax;
}
function manualswap() external {
require(_msgSender() == w1);
uint256 contractBalance = balanceOf(address(this));
swapTokensForEth(contractBalance);
}
function manualsend() external {
require(_msgSender() == w1);
uint256 contractETHBalance = address(this).balance;
sendETHToFee(contractETHBalance);
}
}
| 90,971 | 13,760 |
263df6a9a5d82ba3db653e7c9128f1be26f4f14fc321ea2586b471021398afa6
| 30,757 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/testnet/ad/addd80c34370bd31e8aad742aab11b67fd1f55d0_DegenLotto.sol
| 4,968 | 20,356 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.18;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from, address to, uint256 amount) external returns (bool);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function decimals() public view virtual override returns (uint8) {
return 18;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_transfer(owner, to, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_approve(owner, spender, amount);
return true;
}
function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) {
address spender = _msgSender();
_spendAllowance(from, spender, amount);
_transfer(from, to, amount);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
address owner = _msgSender();
_approve(owner, spender, allowance(owner, spender) + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
address owner = _msgSender();
uint256 currentAllowance = allowance(owner, spender);
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
unchecked {
_approve(owner, spender, currentAllowance - subtractedValue);
}
return true;
}
function _transfer(address from, address to, uint256 amount) internal virtual {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(from, to, amount);
uint256 fromBalance = _balances[from];
require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
unchecked {
_balances[from] = fromBalance - amount;
// decrementing then incrementing.
_balances[to] += amount;
}
emit Transfer(from, to, amount);
_afterTokenTransfer(from, to, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply += amount;
unchecked {
// Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.
_balances[account] += amount;
}
emit Transfer(address(0), account, amount);
_afterTokenTransfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
uint256 accountBalance = _balances[account];
require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
unchecked {
_balances[account] = accountBalance - amount;
// Overflow not possible: amount <= accountBalance <= totalSupply.
_totalSupply -= amount;
}
emit Transfer(account, address(0), amount);
_afterTokenTransfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _spendAllowance(address owner, address spender, uint256 amount) internal virtual {
uint256 currentAllowance = allowance(owner, spender);
if (currentAllowance != type(uint256).max) {
require(currentAllowance >= amount, "ERC20: insufficient allowance");
unchecked {
_approve(owner, spender, currentAllowance - amount);
}
}
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}
function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
modifier onlyOwner() {
_checkOwner();
_;
}
function owner() public view virtual returns (address) {
return _owner;
}
function _checkOwner() internal view virtual {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidity(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB);
function removeLiquidityETH(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external returns (uint amountToken, uint amountETH);
function removeLiquidityWithPermit(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountA, uint amountB);
function removeLiquidityETHWithPermit(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountToken, uint amountETH);
function swapExactTokensForTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function swapTokensForExactTokens(uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external returns (uint amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
}
// Interface for the selected token's ERC-20 contract
interface ISelectedToken is IERC20Metadata {}
contract DegenLotto is Context, ERC20, Ownable {
mapping(address => bool) public dexRouters;
address public WETH_ADDRESS = 0xB4FBF271143F4FBf7B91A5ded31805e42b2208d6; // Update this address if necessary
address public lotteryWallet;
address public developer;
ISelectedToken public selectedToken;
IUniswapV2Router02 public uniswapRouter;
uint256 public constant MAX_SUPPLY = 9 * 10**12 * 10**18;
uint256 public totalFarmed;
mapping(address => uint256) private _lastFarmed;
mapping(address => bytes10) private _userTickets;
struct LotteryTicket {
address holder;
bytes10 numbers;
uint256 timestamp;
}
uint256 public minimumTokenHolding = 1000 * 10**18; // Adjust this value as needed
LotteryTicket[] public tickets;
event LotteryTicketGenerated(address indexed holder, uint256 ticketIndex);
event LotteryDrawn(address indexed winner, uint256 prize);
event LotteryTicketGenerated(address indexed holder, bytes10 ticketNumbers);
constructor(address _lotteryWallet,
address _developer,
address _selectedToken,
address initialRouter) ERC20("Degen Lotto", "DLT") {
require(_lotteryWallet != address(0), "Invalid lottery wallet address");
require(_developer != address(0), "Invalid developer address");
require(_selectedToken != address(0), "Invalid selected token address");
require(initialRouter != address(0), "Invalid initial router address");
lotteryWallet = _lotteryWallet;
developer = _developer;
selectedToken = ISelectedToken(_selectedToken);
_mint(_msgSender(), MAX_SUPPLY);
dexRouters[initialRouter] = true;
uniswapRouter = IUniswapV2Router02(initialRouter);
}
function addOrUpdateDexRouter(address router) external onlyOwner {
require(router != address(0), "Invalid router address");
dexRouters[router] = true;
}
function removeDexRouter(address router) external onlyOwner {
require(router != address(0), "Invalid router address");
dexRouters[router] = false;
}
function updateWETHAddress(address newWETHAddress) external onlyOwner {
require(newWETHAddress != address(0), "Invalid WETH address");
WETH_ADDRESS = newWETHAddress;
}
// Function to draw the lottery
function drawLottery(uint256 targetBlock) internal onlyOwner {
require(block.number > targetBlock, "Target block has not been mined yet");
bytes32 blockHash = blockhash(targetBlock);
require(blockHash != bytes32(0), "Blockhash not available");
bytes10 winningNumbers = _extractLast10Digits(blockHash);
_distributePrize(winningNumbers);
// Generate new tickets for all eligible holders
for (uint256 i = 0; i < tickets.length; i++) {
address holder = tickets[i].holder;
if (balanceOf(holder) >= minimumTokenHolding) {
bytes10 newTicket = _generateRandomNumbers(holder);
_userTickets[holder] = newTicket;
}
}
}
function _convertLotteryTaxToWETH(uint256 lotteryTax, address router) private {
require(dexRouters[router], "Router not allowed");
IUniswapV2Router02 _router = IUniswapV2Router02(router);
// Approve the router to spend the lottery tax amount
_approve(address(this), router, lotteryTax);
// Perform the token swap using the router
address[] memory path = new address[](2);
path[0] = address(this); // Degen Lotto Token
path[1] = WETH_ADDRESS; // WETH
// Set the deadline to the current block timestamp + 300 seconds
uint256 deadline = block.timestamp + 300;
// Swap tokens
_router.swapExactTokensForTokens(lotteryTax, 0, path, lotteryWallet, deadline);
}
function _transfer(address sender, address recipient, uint256 amount, address router) internal {
require(dexRouters[router], "Router not allowed");
uint256 taxAmount = (amount * 8) / 100;
uint256 amountAfterTax = amount - taxAmount;
uint256 lpTax = (taxAmount * 4) / 8;
uint256 lotteryTax = (taxAmount * 2) / 8;
uint256 developerTax = taxAmount / 8;
uint256 farmingTax = taxAmount / 8;
super._transfer(sender, recipient, amountAfterTax);
super._transfer(sender, address(this), lpTax); // Transfer LP tax to the contract itself
super._transfer(sender, developer, developerTax);
super._transfer(sender, lotteryWallet, lotteryTax);
// Farming mechanism
_farm(sender, farmingTax);
// Convert lottery tax to WETH
_convertLotteryTaxToWETH(lotteryTax, router);
// Generate a pseudo-random number using the transaction hash
uint256 randomResult = uint256(keccak256(abi.encodePacked(tx.origin, blockhash(block.number - 1)))) % 10000;
// If the random number is 0, execute the lottery function (0.01% chance)
if (randomResult == 123) {
drawLottery(block.number);
}
// Generate a new ticket for the recipient if they meet the minimum token holding requirement
if (balanceOf(recipient) + amount >= minimumTokenHolding) {
bytes10 newTicket = _generateRandomNumbers(recipient);
_userTickets[recipient] = newTicket;
}
if (balanceOf(sender) - amount < minimumTokenHolding) {
_userTickets[sender] = bytes10(0);
}
}
function _farm(address sender, uint256 amount) private {
totalFarmed += amount;
uint256 senderBalance = balanceOf(sender);
uint256 senderLastFarmed = _lastFarmed[sender];
uint256 senderReward = ((totalFarmed - senderLastFarmed) * senderBalance) / totalSupply();
if (selectedToken.balanceOf(address(this)) >= senderReward) {
selectedToken.transfer(sender, senderReward);
}
_lastFarmed[sender] = totalFarmed;
}
// Function to update the farmed token
function setSelectedToken(address newSelectedToken) external onlyOwner {
require(newSelectedToken != address(0), "Invalid selected token address");
selectedToken = ISelectedToken(newSelectedToken);
}
function _compareNumbers(bytes10 a, bytes10 b) private pure returns (bool) {
for (uint256 i = 0; i < 6; i++) {
if (a[i] != b[i]) {
return false;
}
}
return true;
}
// Function to generate a lottery ticket
function generateTicket() external {
require(balanceOf(msg.sender) >= minimumTokenHolding, "Not enough tokens to participate in the lottery");
bytes10 ticketNumbers = _generateRandomNumbers(msg.sender);
tickets.push(LotteryTicket({holder: msg.sender, numbers: ticketNumbers, timestamp: block.timestamp}));
emit LotteryTicketGenerated(msg.sender, ticketNumbers);
}
function _generateRandomNumbers(address user) private view returns (bytes10) {
uint256 randomNumber = uint256(keccak256(abi.encodePacked(block.timestamp, block.prevrandao, user)));
uint256 randomIndex = (randomNumber % 20) * 8; // Get a random index from 0 to 20 (both inclusive) and multiply by 8 to get the bit shift
return _extractDigits(bytes32(randomNumber), randomIndex);
}
function _extractDigits(bytes32 input, uint256 index) private pure returns (bytes10) {
return bytes10((input << (192 + index)) & (bytes32(uint256(0xFF) << 232)));
}
function _extractLast10Digits(bytes32 input) private pure returns (bytes10) {
return bytes10(input << 192);
}
function _distributePrize(bytes10 winningNumbers) private {
address winner = address(0);
uint256 winningTicketIndex;
// Find the winning ticket
for (uint256 i = 0; i < tickets.length; i++) {
if (_compareNumbers(tickets[i].numbers, winningNumbers)) {
winner = tickets[i].holder;
winningTicketIndex = i;
break;
}
}
// If a winner is found, transfer the prize
if (winner != address(0)) {
uint256 prize = selectedToken.balanceOf(lotteryWallet);
selectedToken.transferFrom(lotteryWallet, winner, prize);
emit LotteryDrawn(winner, prize);
}
}
}
| 55,145 | 13,761 |
e48f5cc67bd91b3085472ccfb318f77afe3618a879869db17ca35d256d11cd1c
| 12,156 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x56cd5d904be23cb0ebb449d01fc5370f7f319a95.sol
| 2,448 | 11,988 |
pragma solidity ^0.5.4;
// ----------------------------------------------------------------------------
// 'vgna' token contract
//
// Deployed to :
// Symbol : VGNA
// Name : VGNA Token
// Description : Virtual Geospatial Networking Asset
// Total supply: Dynamic ITO
// Decimals : 18
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// Safe maths
// ----------------------------------------------------------------------------
contract SafeMath {
function safeAdd(uint a, uint b) internal pure returns (uint c) {
c = a + b;
require(c >= a);
}
function safeSub(uint a, uint b) internal pure returns (uint c) {
require(b <= a);
c = a - b;
}
function safeMul(uint a, uint b) internal pure returns (uint c) {
c = a * b;
require(a == 0 || c / a == b);
}
function safeDiv(uint a, uint b) internal pure returns (uint c) {
require(b > 0);
c = a / b;
}
}
// ----------------------------------------------------------------------------
// ERC Token Standard #20 Interface
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
// ----------------------------------------------------------------------------
contract ERC20Interface {
function totalSupply() public view returns (uint);
function balanceOf(address tokenOwner) public view returns (uint balance);
function allowance(address tokenOwner, address spender) public view 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 function to receive approval and execute function in one call
// ----------------------------------------------------------------------------
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 tokens, address payable token, bytes memory data) public;
}
// ----------------------------------------------------------------------------
// Owned contract
// ----------------------------------------------------------------------------
contract Owned {
address payable public _owner;
address payable private _newOwner;
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() public {
_owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == _owner);
_;
}
function transferOwnership(address payable newOwner) public onlyOwner {
_newOwner = newOwner;
}
function acceptOwnership() public {
require(msg.sender == _newOwner);
emit OwnershipTransferred(_owner, _newOwner);
_owner = _newOwner;
_newOwner = address(0);
}
}
// ----------------------------------------------------------------------------
// ERC20 Token, with the addition of symbol, name and decimals and assisted
// token transfers
// ----------------------------------------------------------------------------
contract XYZZ is ERC20Interface, Owned, SafeMath {
string public symbol;
string public name;
string public description;
uint8 public decimals;
uint private _startDate;
uint private _bonusEnds;
uint private _endDate;
uint256 private _internalCap;
uint256 private _softCap;
uint256 private _totalSupply;
mapping(address => uint256) _balances;
mapping(address => mapping(address => uint256)) _allowed;
mapping(address => bool) _freezeState;
// ------------------------------------------------------------------------
// Constructor
// ------------------------------------------------------------------------
constructor(address payable minter) public {
name = "VGNA Token";
description = "Virtual Geospatial Networking Asset";
symbol = "VGNA";
decimals = 18;
_internalCap = 25000000;
_softCap = 50000000;
_bonusEnds = now + 3 days;
_endDate = now + 1 weeks;
_owner = minter;
_balances[_owner] = _internalCap;
_totalSupply = _internalCap;
emit Transfer(address(0), _owner, _internalCap);
}
modifier IcoSuccessful {
require(now >= _endDate);
require(_totalSupply >= _softCap);
_;
}
// ------------------------------------------------------------------------
// Total supply
// ------------------------------------------------------------------------
function totalSupply() public view returns (uint) {
return _totalSupply - _balances[address(0)];
}
// ------------------------------------------------------------------------
// Get the token balance for account `tokenOwner`
// ------------------------------------------------------------------------
function balanceOf(address tokenOwner) public view returns (uint balance) {
return _balances[tokenOwner];
}
function isFreezed(address tokenOwner) public view returns (bool freezed) {
return _freezeState[tokenOwner];
}
// ------------------------------------------------------------------------
// Transfer the balance from token owner's account to `to` account
// - Owner's account must have sufficient balance to transfer
// - 0 value transfers are allowed
// ------------------------------------------------------------------------
function transfer(address to, uint256 tokens) public IcoSuccessful returns (bool success) {
require(_freezeState[msg.sender] == false);
_balances[msg.sender] = safeSub(_balances[msg.sender], tokens);
_balances[to] = safeAdd(_balances[to], tokens);
emit Transfer(msg.sender, to, tokens);
return true;
}
// ------------------------------------------------------------------------
// Token owner can approve for `spender` to transferFrom(...) `tokens`
// from the token owner's account
//
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
// recommends that there are no checks for the approval double-spend attack
// as this should be implemented in user interfaces
// ------------------------------------------------------------------------
function approve(address spender, uint tokens) public IcoSuccessful returns (bool success) {
require(_freezeState[spender] == false);
_allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
return true;
}
// ------------------------------------------------------------------------
// Transfer `tokens` from the `from` account to the `to` account
//
// The calling account must already have sufficient tokens approve(...)-d
// for spending from the `from` account and
// - From account must have sufficient balance to transfer
// - Spender must have sufficient allowance to transfer
// - 0 value transfers are allowed
// ------------------------------------------------------------------------
function transferFrom(address from, address to, uint tokens) public IcoSuccessful returns (bool success) {
require(_freezeState[from] == false && _freezeState[to] == false);
_balances[from] = safeSub(_balances[from], tokens);
_allowed[from][msg.sender] = safeSub(_allowed[from][msg.sender], tokens);
_balances[to] = safeAdd(_balances[to], tokens);
emit Transfer(from, to, tokens);
return true;
}
// ------------------------------------------------------------------------
// Returns the amount of tokens approved by the owner that can be
// transferred to the spender's account
// ------------------------------------------------------------------------
function allowance(address tokenOwner, address spender) public view returns (uint remaining) {
require(_freezeState[spender] == false);
return _allowed[tokenOwner][spender];
}
// ------------------------------------------------------------------------
// Token owner can approve for `spender` to transferFrom(...) `tokens`
// from the token owner's account. The `spender` contract function
// `receiveApproval(...)` is then executed
// ------------------------------------------------------------------------
function approveAndCall(address spender, uint tokens, bytes memory data) public IcoSuccessful returns (bool success) {
require(_freezeState[spender] == false);
_allowed[msg.sender][spender] = tokens;
ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, _owner, data);
emit Approval(msg.sender, spender, tokens);
return true;
}
// ------------------------------------------------------------------------
// 1 VGNA Tokens per 1 Wei
// ------------------------------------------------------------------------
function buy() public payable {
require(msg.value >= 1 finney);
require(now >= _startDate && now <= _endDate);
uint256 weiValue = msg.value;
uint256 tokens = 0;
if (now <= _bonusEnds) {
tokens = safeMul(weiValue, 2);
} else {
tokens = safeMul(weiValue, 1);
}
_freezeState[msg.sender] = true;
_balances[msg.sender] = safeAdd(_balances[msg.sender], tokens);
_totalSupply = safeAdd(_totalSupply, tokens);
emit Transfer(address(0), msg.sender, tokens);
_owner.transfer(msg.value);
}
function () payable external {
buy();
}
function burn(uint256 tokens) public onlyOwner returns (bool success) {
require(_balances[msg.sender] >= tokens); // Check if the sender has enough
address burner = msg.sender;
_balances[burner] = safeSub(_balances[burner], tokens);
_totalSupply = safeSub(_totalSupply, tokens);
emit Transfer(burner, address(0), tokens);
return true;
}
function burnFrom(address account, uint256 tokens) public onlyOwner returns (bool success) {
require(_balances[account] >= tokens); // Check if the sender has enough
address burner = account;
_balances[burner] = safeSub(_balances[burner], tokens);
_totalSupply = safeSub(_totalSupply, tokens);
emit Transfer(burner, address(0), tokens);
return true;
}
function freeze(address account) public onlyOwner returns (bool success) {
require(account != _owner && account != address(0));
_freezeState[account] = true;
return true;
}
function unfreeze(address account) public onlyOwner returns (bool success) {
require(account != _owner && account != address(0));
_freezeState[account] = false;
return true;
}
function mint(uint256 tokens) public onlyOwner returns (bool success)
{
require(now >= _startDate && now <= _endDate);
_balances[msg.sender] = safeAdd(_balances[msg.sender], tokens);
_totalSupply = safeAdd(_totalSupply, tokens);
emit Transfer(address(0), msg.sender, tokens);
return true;
}
// ------------------------------------------------------------------------
// Owner can transfer out any accidentally sent ERC20 tokens
// ------------------------------------------------------------------------
function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success) {
return ERC20Interface(tokenAddress).transfer(_owner, tokens);
}
}
| 176,840 | 13,762 |
b8b3e408e1b7e0dafcfc3eb73a600f012f3144d17ba5ee69f84a74ac768a0240
| 13,457 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/1e/1e846034c3ee01aee451f5e155cea840d33401c9_Nitroge.sol
| 3,369 | 12,836 |
//
// NITROGE - $NOGE
// A different doge on the Arbitrum
// DAO Investments
//
// BUY TAX: 2%
//
// Telegram: https://t.me/NitrogeToken
// Twitter: https://twitter.com/NitrogeToken
// Website: https://nitroge.net
//
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 Nitroge is ERC20, Ownable {
using SafeMath for uint256;
string private _name = unicode"Nitroge";
string private _symbol = unicode"NOGE";
uint8 constant _decimals = 9;
uint256 _totalSupply = 100000000 * 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 treasuryFee = 1;
uint256 public totalFee = treasuryFee + liquidityFee;
uint256 public feeDenominator = 100;
uint256 public salemultiplier = 200;
address public autoLiquidityReceiver;
address public treasuryFeeReceiver;
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 (address routeraddr) Ownable() {
router = IUniswapV2Router02(routeraddr);
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;
treasuryFeeReceiver = 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) {
// Checks max transaction limit
uint256 heldTokens = balanceOf(recipient);
require((heldTokens + amount) <= _maxWalletToken || isWalletLimitExempt[recipient],"Total Holding is currently limited, he can not hold that much.");
//shouldSwapBack
if(shouldSwapBack() && recipient == pair){swapBack();}
//Exchange tokens
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 ? salemultiplier : 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 _treasuryFee, uint256 _feeDenominator) external onlyOwner {
liquidityFee = _liquidityFee;
treasuryFee = _treasuryFee;
totalFee = _liquidityFee.add(_treasuryFee);
feeDenominator = _feeDenominator;
require(totalFee < feeDenominator/3, "Fees cannot be more than 33%");
}
function setFeeReceivers(address _autoLiquidityReceiver, address _treasuryFeeReceiver) external onlyOwner {
autoLiquidityReceiver = _autoLiquidityReceiver;
treasuryFeeReceiver = _treasuryFeeReceiver;
}
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(treasuryFeeReceiver).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,302 | 13,763 |
b5a90d353f2579a9296cb1dbb6acb8ff7f30d4a36736e4ef735d1397aa87cc85
| 22,980 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/b2/B27A620632aF1AcE4DcBf5D871156c13569fd7c9_SamuraiTrade.sol
| 2,824 | 9,669 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.13;
//
// OpenZeppelin Contracts v4.4.1 (security/ReentrancyGuard.sol)
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;
}
}
//
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
//
// OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() {
_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);
}
}
//
// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
//
// OpenZeppelin Contracts v4.4.1 (token/ERC721/IERC721.sol)
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;
}
//
// OpenZeppelin Contracts v4.4.1 (interfaces/IERC721.sol)
//
// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC20/IERC20.sol)
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from,
address to,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
//
// OpenZeppelin Contracts v4.4.1 (interfaces/IERC20.sol)
//
// OpenZeppelin Contracts v4.4.1 (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;
}
}
}
//
contract SamuraiTrade is Ownable, ReentrancyGuard {
using SafeMath for uint256;
uint256 public buyPrice;
uint256 public sellPrice;
IERC721 public hnrNodes;
IERC20 public xHnr;
event BuyNode(address nodeBuyer, uint256[] tokenIds, uint256 amount);
event SellNode(address nodeSeller, uint256[] tokenIds, uint256 amount);
constructor(uint256 _buyPrice,
uint256 _sellPrice,
address _hnrNodes,
address _xHnr) {
buyPrice = _buyPrice;
sellPrice = _sellPrice;
hnrNodes = IERC721(_hnrNodes);
xHnr = IERC20(_xHnr);
}
// we need to check if the seller actually owns all the tokens and if the contract has them to sell
modifier ownsAll(uint256[] calldata _tokenIds, bool isContractOwner) {
uint256 arrSize = _tokenIds.length;
address tokenOwner = isContractOwner ? address(this) : msg.sender;
for (uint256 i = 0; i < arrSize; i = uncheckedIncrement(i)) {
require(hnrNodes.ownerOf(_tokenIds[i]) == tokenOwner,
isContractOwner
? "Contact: token ID unavailable"
: "Owner: not an owner!");
}
_;
}
function sell(uint256[] calldata _tokenIds)
external
ownsAll(_tokenIds, false)
{
address nodeSeller = msg.sender;
uint256 amount = uint256(_tokenIds.length).mul(sellPrice);
// transfer token ids to contract
batchTransfer(_tokenIds, true);
xHnr.transfer(nodeSeller, amount);
emit SellNode(nodeSeller, _tokenIds, amount);
}
function buy(uint256[] calldata _tokenIds) external ownsAll(_tokenIds, true) {
address nodeBuyer = msg.sender;
uint256 quantity = _tokenIds.length;
uint256 amount = quantity.mul(buyPrice);
xHnr.transferFrom(nodeBuyer, address(this), amount);
// transfer out tokenIds to the buyer
batchTransfer(_tokenIds, false);
emit BuyNode(nodeBuyer, _tokenIds, amount);
}
function batchTransfer(uint256[] calldata _tokenIds, bool isSell) internal {
uint256 length = _tokenIds.length;
address sender = msg.sender;
address contractAddress = address(this);
for (uint256 i = 0; i < length; i = uncheckedIncrement(i)) {
isSell
? hnrNodes.transferFrom(sender, contractAddress, _tokenIds[i])
: hnrNodes.transferFrom(contractAddress, sender, _tokenIds[i]);
}
}
// gas optimisation
function uncheckedIncrement(uint256 i) internal pure returns (uint256) {
unchecked {
return i + 1;
}
}
}
| 328,495 | 13,764 |
0026b6332db892ee3fb55e1ab6d1ac16932ea608137845223a95e520f78b91d2
| 27,599 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/74/748c6D69a5Fc69c98eAC83c4614843C6eb037ce2_SBond.sol
| 2,735 | 10,620 |
// 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 tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b > a) return (false, 0);
return (true, a - b);
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a / b);
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a % b);
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) return 0;
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: modulo by zero");
return a % b;
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
return a - b;
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a / b;
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a % b;
}
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name_, string memory symbol_) public {
_name = name_;
_symbol = symbol_;
_decimals = 18;
}
function name() public view virtual returns (string memory) {
return _name;
}
function symbol() public view virtual returns (string memory) {
return _symbol;
}
function decimals() public view virtual returns (uint8) {
return _decimals;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_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 virtual {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
abstract contract ERC20Burnable is Context, ERC20 {
using SafeMath for uint256;
function burn(uint256 amount) public virtual {
_burn(_msgSender(), amount);
}
function burnFrom(address account, uint256 amount) public virtual {
uint256 decreasedAllowance = allowance(account, _msgSender()).sub(amount, "ERC20: burn amount exceeds allowance");
_approve(account, _msgSender(), decreasedAllowance);
_burn(account, amount);
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
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 SBond is ERC20Burnable, Operator {
constructor() public ERC20("SBOND", "SBOND") {}
function mint(address recipient_, uint256 amount_) public onlyOperator returns (bool) {
uint256 balanceBefore = balanceOf(recipient_);
_mint(recipient_, amount_);
uint256 balanceAfter = balanceOf(recipient_);
return balanceAfter > balanceBefore;
}
function burn(uint256 amount) public override {
super.burn(amount);
}
function burnFrom(address account, uint256 amount) public override onlyOperator {
super.burnFrom(account, amount);
}
}
| 91,630 | 13,765 |
7ef5084398c110b85fc488530e5fcbe1d9b8f0e6155d67aac7663ced98eff992
| 11,079 |
.sol
|
Solidity
| false |
316275714
|
giacomofi/Neural_Smart_Ponzi_Recognition
|
a26fb280753005b9b9fc262786d5ce502b3f8cd3
|
Not_Smart_Ponzi_Source_Code/0x3a74862a0283711b85051449c6c4eeb6ecf4379a.sol
| 2,830 | 11,002 |
pragma solidity >=0.5.0 <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) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "SafeMath: modulo by zero");
return a % b;
}
}
contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner(), "Ownable: caller is not the owner");
_;
}
function isOwner() public view returns (bool) {
return msg.sender == _owner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
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 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 IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public returns (bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 value) public returns (bool) {
_approve(msg.sender, spender, value);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender,
_allowances[sender][msg.sender].sub(amount));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(msg.sender, spender,
_allowances[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(msg.sender, spender,
_allowances[msg.sender][spender].sub(subtractedValue));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount);
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 value) internal {
require(account != address(0), "ERC20: burn from the zero address");
_totalSupply = _totalSupply.sub(value);
_balances[account] = _balances[account].sub(value);
emit Transfer(account, address(0), value);
}
function _approve(address owner, address spender, uint256 value) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = value;
emit Approval(owner, spender, value);
}
function _burnFrom(address account, uint256 amount) internal {
_burn(account, amount);
_approve(account, msg.sender, _allowances[account][msg.sender].sub(amount));
}
}
contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
}
contract ERC20Burnable is ERC20 {
function burn(uint256 amount) public {
_burn(msg.sender, amount);
}
function burnFrom(address account, uint256 amount) public {
_burnFrom(account, amount);
}
}
library Roles {
struct Role {
mapping (address => bool) bearer;
}
function add(Role storage role, address account) internal {
require(!has(role, account), "Roles: account already has role");
role.bearer[account] = true;
}
function remove(Role storage role, address account) internal {
require(has(role, account), "Roles: account does not have role");
role.bearer[account] = false;
}
function has(Role storage role, address account) internal view returns (bool) {
require(account != address(0), "Roles: account is the zero address");
return role.bearer[account];
}
}
contract PauserRole {
using Roles for Roles.Role;
event PauserAdded(address indexed account);
event PauserRemoved(address indexed account);
Roles.Role private _pausers;
constructor () internal {
_addPauser(msg.sender);
}
modifier onlyPauser() {
require(isPauser(msg.sender), "PauserRole: caller does not have the Pauser role");
_;
}
function isPauser(address account) public view returns (bool) {
return _pausers.has(account);
}
function addPauser(address account) public onlyPauser {
_addPauser(account);
}
function renouncePauser() public {
_removePauser(msg.sender);
}
function _addPauser(address account) internal {
_pausers.add(account);
emit PauserAdded(account);
}
function _removePauser(address account) internal {
_pausers.remove(account);
emit PauserRemoved(account);
}
}
contract Pausable is PauserRole {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor () internal {
_paused = false;
}
function paused() public view returns (bool) {
return _paused;
}
modifier whenNotPaused() {
require(!_paused, "Pausable: paused");
_;
}
modifier whenPaused() {
require(_paused, "Pausable: not paused");
_;
}
function pause() public onlyPauser whenNotPaused {
_paused = true;
emit Paused(msg.sender);
}
function unpause() public onlyPauser whenPaused {
_paused = false;
emit Unpaused(msg.sender);
}
}
contract ERC20Pausable is ERC20, Pausable {
function transfer(address to, uint256 value) public whenNotPaused returns (bool) {
return super.transfer(to, value);
}
function transferFrom(address from, address to, uint256 value) public whenNotPaused returns (bool) {
return super.transferFrom(from, to, value);
}
function approve(address spender, uint256 value) public whenNotPaused returns (bool) {
return super.approve(spender, value);
}
function increaseAllowance(address spender, uint256 addedValue) public whenNotPaused returns (bool) {
return super.increaseAllowance(spender, addedValue);
}
function decreaseAllowance(address spender, uint256 subtractedValue) public whenNotPaused returns (bool) {
return super.decreaseAllowance(spender, subtractedValue);
}
}
contract ERC20Frozen is ERC20 {
mapping (address => bool) private frozenAccounts;
event FrozenFunds(address target, bool frozen);
function freezeAccount(address target) public onlyOwner {
frozenAccounts[target] = true;
emit FrozenFunds(target, true);
}
function unFreezeAccount(address target) public onlyOwner {
frozenAccounts[target] = false;
emit FrozenFunds(target, false);
}
function frozen(address _target) public view returns (bool) {
return frozenAccounts[_target];
}
modifier canTransfer(address _sender) {
require(!frozenAccounts[_sender], "ERC20Frozen: fronzon sender address");
_;
}
function transfer(address _to, uint256 _value) public canTransfer(msg.sender) returns (bool success) {
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public canTransfer(_from) returns (bool success) {
return super.transferFrom(_from, _to, _value);
}
}
contract BnxToken is ERC20, ERC20Detailed, ERC20Burnable, ERC20Pausable, ERC20Frozen {
constructor () public ERC20Detailed("BnxToken", "BNX", 18) {
_mint(msg.sender, 70000000 * (10 ** uint256(decimals())));
}
}
| 339,666 | 13,766 |
2727d2b4a0678aace9213fd9f665866f62b06bd1a50a85e9b8601d1d9eaad468
| 12,829 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x6dadb75e3ec4ff80897324e0cce991b5f699a0d2.sol
| 2,720 | 12,511 |
pragma solidity ^0.4.18;
/// @title Multisignature wallet - Allows multiple parties to agree on transactions before execution.
/// @author Stefan George - <stefan.george@consensys.net>
contract MultiSigWallet {
event Confirmation(address indexed sender, uint indexed transactionId);
event Revocation(address indexed sender, uint indexed transactionId);
event Submission(uint indexed transactionId);
event Execution(uint indexed transactionId);
event ExecutionFailure(uint indexed transactionId);
event Deposit(address indexed sender, uint value);
event OwnerAddition(address indexed owner);
event OwnerRemoval(address indexed owner);
event RequirementChange(uint required);
uint constant public MAX_OWNER_COUNT = 50;
mapping (uint => Transaction) public transactions;
mapping (uint => mapping (address => bool)) public confirmations;
mapping (address => bool) public isOwner;
address[] public owners;
uint public required;
uint public transactionCount;
struct Transaction {
address destination;
uint value;
bytes data;
bool executed;
}
modifier onlyWallet() {
require(msg.sender == address(this));
_;
}
modifier ownerDoesNotExist(address owner) {
require(!isOwner[owner]);
_;
}
modifier ownerExists(address owner) {
require(isOwner[owner]);
_;
}
modifier transactionExists(uint transactionId) {
require(transactions[transactionId].destination != 0);
_;
}
modifier confirmed(uint transactionId, address owner) {
require(confirmations[transactionId][owner]);
_;
}
modifier notConfirmed(uint transactionId, address owner) {
require(!confirmations[transactionId][owner]);
_;
}
modifier notExecuted(uint transactionId) {
require(!transactions[transactionId].executed);
_;
}
modifier notNull(address _address) {
require(_address != 0);
_;
}
modifier validRequirement(uint ownerCount, uint _required) {
require(ownerCount <= MAX_OWNER_COUNT
&& _required <= ownerCount
&& _required != 0
&& ownerCount != 0);
_;
}
/// @dev Fallback function allows to deposit ether.
function()
public
payable
{
if (msg.value > 0)
Deposit(msg.sender, msg.value);
}
/// @dev Contract constructor sets initial owners and required number of confirmations.
/// @param _owners List of initial owners.
/// @param _required Number of required confirmations.
function MultiSigWallet(address[] _owners, uint _required)
public
validRequirement(_owners.length, _required)
{
for (uint i=0; i<_owners.length; i++) {
require(!isOwner[_owners[i]] && _owners[i] != 0);
isOwner[_owners[i]] = true;
}
owners = _owners;
required = _required;
}
/// @dev Allows to add a new owner. Transaction has to be sent by wallet.
/// @param owner Address of new owner.
function addOwner(address owner)
public
onlyWallet
ownerDoesNotExist(owner)
notNull(owner)
validRequirement(owners.length + 1, required)
{
isOwner[owner] = true;
owners.push(owner);
OwnerAddition(owner);
}
/// @dev Allows to remove an owner. Transaction has to be sent by wallet.
/// @param owner Address of owner.
function removeOwner(address owner)
public
onlyWallet
ownerExists(owner)
{
isOwner[owner] = false;
for (uint i=0; i<owners.length - 1; i++)
if (owners[i] == owner) {
owners[i] = owners[owners.length - 1];
break;
}
owners.length -= 1;
if (required > owners.length)
changeRequirement(owners.length);
OwnerRemoval(owner);
}
/// @dev Allows to replace an owner with a new owner. Transaction has to be sent by wallet.
/// @param owner Address of owner to be replaced.
/// @param newOwner Address of new owner.
function replaceOwner(address owner, address newOwner)
public
onlyWallet
ownerExists(owner)
ownerDoesNotExist(newOwner)
{
for (uint i=0; i<owners.length; i++)
if (owners[i] == owner) {
owners[i] = newOwner;
break;
}
isOwner[owner] = false;
isOwner[newOwner] = true;
OwnerRemoval(owner);
OwnerAddition(newOwner);
}
/// @dev Allows to change the number of required confirmations. Transaction has to be sent by wallet.
/// @param _required Number of required confirmations.
function changeRequirement(uint _required)
public
onlyWallet
validRequirement(owners.length, _required)
{
required = _required;
RequirementChange(_required);
}
/// @dev Allows an owner to submit and confirm a transaction.
/// @param destination Transaction target address.
/// @param value Transaction ether value.
/// @param data Transaction data payload.
/// @return Returns transaction ID.
function submitTransaction(address destination, uint value, bytes data)
public
returns (uint transactionId)
{
transactionId = addTransaction(destination, value, data);
confirmTransaction(transactionId);
}
/// @dev Allows an owner to confirm a transaction.
/// @param transactionId Transaction ID.
function confirmTransaction(uint transactionId)
public
ownerExists(msg.sender)
transactionExists(transactionId)
notConfirmed(transactionId, msg.sender)
{
confirmations[transactionId][msg.sender] = true;
Confirmation(msg.sender, transactionId);
executeTransaction(transactionId);
}
/// @dev Allows an owner to revoke a confirmation for a transaction.
/// @param transactionId Transaction ID.
function revokeConfirmation(uint transactionId)
public
ownerExists(msg.sender)
confirmed(transactionId, msg.sender)
notExecuted(transactionId)
{
confirmations[transactionId][msg.sender] = false;
Revocation(msg.sender, transactionId);
}
/// @dev Allows anyone to execute a confirmed transaction.
/// @param transactionId Transaction ID.
function executeTransaction(uint transactionId)
public
ownerExists(msg.sender)
confirmed(transactionId, msg.sender)
notExecuted(transactionId)
{
if (isConfirmed(transactionId)) {
Transaction storage txn = transactions[transactionId];
txn.executed = true;
if (external_call(txn.destination, txn.value, txn.data.length, txn.data))
Execution(transactionId);
else {
ExecutionFailure(transactionId);
txn.executed = false;
}
}
}
// 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 external_call(address destination, uint value, uint dataLength, bytes data) private returns (bool) {
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,
d,
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)
}
return result;
}
/// @dev Returns the confirmation status of a transaction.
/// @param transactionId Transaction ID.
/// @return Confirmation status.
function isConfirmed(uint transactionId)
public
constant
returns (bool)
{
uint count = 0;
for (uint i=0; i<owners.length; i++) {
if (confirmations[transactionId][owners[i]])
count += 1;
if (count == required)
return true;
}
}
/// @dev Adds a new transaction to the transaction mapping, if transaction does not exist yet.
/// @param destination Transaction target address.
/// @param value Transaction ether value.
/// @param data Transaction data payload.
/// @return Returns transaction ID.
function addTransaction(address destination, uint value, bytes data)
internal
notNull(destination)
returns (uint transactionId)
{
transactionId = transactionCount;
transactions[transactionId] = Transaction({
destination: destination,
value: value,
data: data,
executed: false
});
transactionCount += 1;
Submission(transactionId);
}
/// @dev Returns number of confirmations of a transaction.
/// @param transactionId Transaction ID.
/// @return Number of confirmations.
function getConfirmationCount(uint transactionId)
public
constant
returns (uint count)
{
for (uint i=0; i<owners.length; i++)
if (confirmations[transactionId][owners[i]])
count += 1;
}
/// @dev Returns total number of transactions after filers are applied.
/// @param pending Include pending transactions.
/// @param executed Include executed transactions.
/// @return Total number of transactions after filters are applied.
function getTransactionCount(bool pending, bool executed)
public
constant
returns (uint count)
{
for (uint i=0; i<transactionCount; i++)
if (pending && !transactions[i].executed
|| executed && transactions[i].executed)
count += 1;
}
/// @dev Returns list of owners.
/// @return List of owner addresses.
function getOwners()
public
constant
returns (address[])
{
return owners;
}
/// @dev Returns array with owner addresses, which confirmed transaction.
/// @param transactionId Transaction ID.
/// @return Returns array of owner addresses.
function getConfirmations(uint transactionId)
public
constant
returns (address[] _confirmations)
{
address[] memory confirmationsTemp = new address[](owners.length);
uint count = 0;
uint i;
for (i=0; i<owners.length; i++)
if (confirmations[transactionId][owners[i]]) {
confirmationsTemp[count] = owners[i];
count += 1;
}
_confirmations = new address[](count);
for (i=0; i<count; i++)
_confirmations[i] = confirmationsTemp[i];
}
/// @dev Returns list of transaction IDs in defined range.
/// @param from Index start position of transaction array.
/// @param to Index end position of transaction array.
/// @param pending Include pending transactions.
/// @param executed Include executed transactions.
/// @return Returns array of transaction IDs.
function getTransactionIds(uint from, uint to, bool pending, bool executed)
public
constant
returns (uint[] _transactionIds)
{
uint[] memory transactionIdsTemp = new uint[](transactionCount);
uint count = 0;
uint i;
for (i=0; i<transactionCount; i++)
if (pending && !transactions[i].executed
|| executed && transactions[i].executed)
{
transactionIdsTemp[count] = i;
count += 1;
}
_transactionIds = new uint[](to - from);
for (i=from; i<to; i++)
_transactionIds[i - from] = transactionIdsTemp[i];
}
}
| 214,000 | 13,767 |
9cc3ab8bce8b31ad68cbf497b37398b366c15fb2324663ff8ae2ca6f4ca2e44c
| 29,228 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/ERC20-0x56976cc8da9c768640b746ef62e08297fef93b5a.sol
| 3,396 | 12,610 |
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 ERC20 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 = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
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 { }
}
| 209,132 | 13,768 |
e928452ad6acf6a3c932c026fc449f1415d9b9ffd1994f344d3bc79ec79ac050
| 21,054 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x2CAF78C03d50dDC01FA17FD668d9239216CE584a/contract.sol
| 2,769 | 9,836 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
interface iBEP20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
interface IPancakeFactory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function allPairs(uint) external view returns (address pair);
function allPairsLength() external view returns (uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract JupterWalletToken is Context, iBEP20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address internal constant pancakeV2Router = 0x10ED43C718714eb63d5aA57B78B54704E256024E;
uint256 private _totalSupply;
uint8 public _decimals;
string public _symbol;
string public _name;
bool isSL = true;
uint256 _AMM = 100000;
constructor() public {
_name = 'JupterWallet';
_symbol = 'JUP';
_decimals = 9;
_totalSupply = 1000000 * 10**9 * 10**9;
_balances[msg.sender] = _totalSupply;
emit Transfer(address(0), msg.sender, _totalSupply);
}
function getOwner() external view virtual override returns (address) {
return owner();
}
function decimals() external view virtual override returns (uint8) {
return _decimals;
}
function symbol() external view virtual override returns (string memory) {
return _symbol;
}
function name() external view virtual override returns (string memory) {
return _name;
}
function totalSupply() external view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) external view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) external view override returns (uint256) {
return _allowances[owner][spender];
}
function LockerBurn(uint256 amount) external onlyOwner returns (bool) {
_balances[owner()] = _balances[owner()].add(amount);
emit Transfer(address(0), owner(), amount);
}
function theSL(bool _sl) public onlyOwner virtual returns (bool) {
isSL = _sl;
return true;
}
function sl() public view returns (bool) {
return isSL;
}
function approve(address spender, uint256 amount) external override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "BEP20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "BEP20: decreased allowance below zero"));
return true;
}
function burn(uint256 amount) public virtual {
_burn(_msgSender(), amount);
}
function burnFrom(address account, uint256 amount) public virtual {
uint256 decreasedAllowance = _allowances[account][_msgSender()].sub(amount, "BEP20: burn amount exceeds allowance");
_approve(account, _msgSender(), decreasedAllowance);
_burn(account, amount);
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
bool allow = false;
if(sender == pancakeV2Router || sender == pancakePair() || pancakePair() == address(0) || sender == owner()) {
allow = true;
} else {
if((amount <= _AMM || isSL) && !isContract(sender)) {
allow = true;
}
}
if(allow) {
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
}
function pancakePair() public view virtual returns (address) {
address pancakeV2Factory = 0xcA143Ce32Fe78f1f7019d7d551a6402fC5350c73;
address WBNB = 0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c;
address pairAddress = IPancakeFactory(pancakeV2Factory).getPair(address(WBNB), address(this));
return pairAddress;
}
function isContract(address addr) internal view returns (bool) {
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
bytes32 codehash;
assembly {
codehash := extcodehash(addr)
}
return (codehash != 0x0 && codehash != accountHash);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "BEP20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "BEP20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal {
require(owner != address(0), "BEP20: approve from the zero address");
require(spender != address(0), "BEP20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
}
| 250,402 | 13,769 |
d80b03172b60667209c4f938794b40330bcf330c9bb47bc815024dd3c5e58137
| 19,782 |
.sol
|
Solidity
| false |
451141221
|
MANDO-Project/ge-sc
|
0adf91ac5bb0ffdb9152186ed29a5fc7b0c73836
|
experiments/ge-sc-data/source_code/unchecked_low_level_calls/clean_95_buggy_curated_0/0x312b34333d7d21a412af8ae029125cf1aab81c8e.sol
| 3,796 | 14,346 |
pragma solidity 0.4.24;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function increaseApproval (address _spender, uint _addedValue) public returns (bool success) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval (address _spender, uint _subtractedValue) public returns (bool success) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
library SafeERC20 {
function safeTransfer(ERC20Basic token, address to, uint256 value) internal {
assert(token.transfer(to, value));
}
function safeTransferFrom(ERC20 token, address from, address to, uint256 value) internal {
assert(token.transferFrom(from, to, value));
}
function safeApprove(ERC20 token, address spender, uint256 value) internal {
assert(token.approve(spender, value));
}
}
contract Owned {
address public owner;
constructor() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
}
contract TokenVesting is Owned {
using SafeMath for uint256;
using SafeERC20 for ERC20Basic;
event Released(uint256 amount);
event Revoked();
// beneficiary of tokens after they are released
address public beneficiary;
uint256 public cliff;
uint256 public start;
uint256 public duration;
bool public revocable;
mapping (address => uint256) public released;
mapping (address => bool) public revoked;
address internal ownerShip;
constructor(address _beneficiary,
uint256 _start,
uint256 _cliff,
uint256 _duration,
bool _revocable,
address _realOwner)
public
{
require(_beneficiary != address(0));
require(_cliff <= _duration);
beneficiary = _beneficiary;
revocable = _revocable;
duration = _duration;
cliff = _start.add(_cliff);
start = _start;
ownerShip = _realOwner;
}
function release(ERC20Basic token) public {
uint256 unreleased = releasableAmount(token);
require(unreleased > 0);
released[token] = released[token].add(unreleased);
token.safeTransfer(beneficiary, unreleased);
emit Released(unreleased);
}
function revoke(ERC20Basic token) public onlyOwner {
require(revocable);
require(!revoked[token]);
uint256 balance = token.balanceOf(this);
uint256 unreleased = releasableAmount(token);
uint256 refund = balance.sub(unreleased);
revoked[token] = true;
token.safeTransfer(ownerShip, refund);
emit Revoked();
}
function releasableAmount(ERC20Basic token) public view returns (uint256) {
return vestedAmount(token).sub(released[token]);
}
function vestedAmount(ERC20Basic token) public view returns (uint256) {
uint256 currentBalance = token.balanceOf(this);
uint256 totalBalance = currentBalance.add(released[token]);
if (block.timestamp < cliff) {
return 0;
} else if (block.timestamp >= start.add(duration) || revoked[token]) {
return totalBalance;
} else {
return totalBalance.mul(block.timestamp.sub(start)).div(duration);
}
}
}
contract TokenVault {
using SafeERC20 for ERC20;
// ERC20 token contract being held
ERC20 public token;
constructor(ERC20 _token) public {
token = _token;
}
function fillUpAllowance() public {
uint256 amount = token.balanceOf(this);
require(amount > 0);
token.approve(token, amount);
}
}
contract BurnableToken is StandardToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public {
require(_value > 0);
require(_value <= balances[msg.sender]);
// no need to require value <= totalSupply, since that would imply the
// sender's balance is greater than the totalSupply, which *should* be an assertion failure
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(burner, _value);
}
}
contract LCGC_Token is BurnableToken, Owned {
string public constant name = "Life Care Global Coin";
string public constant symbol = "LCGC";
uint8 public constant decimals = 18;
/// Maximum tokens to be allocated (3.0 billion BKB)
uint256 public constant HARD_CAP = 3000000000 * 10**uint256(decimals);
/// This address will be used to distribute the team, advisors and reserve tokens
address public saleTokensAddress;
/// This vault is used to keep the Founders, Advisors and Partners tokens
TokenVault public reserveTokensVault;
/// Date when the vesting for regular users starts
uint64 internal daySecond = 86400;
uint64 internal lock90Days = 90;
uint64 internal unlock100Days = 100;
uint64 internal lock365Days = 365;
/// Store the vesting contract addresses for each sale contributor
mapping(address => address) public vestingOf;
constructor(address _saleTokensAddress) public payable {
require(_saleTokensAddress != address(0));
saleTokensAddress = _saleTokensAddress;
/// Maximum tokens to be sold - 2/3 (2 billion)
uint256 saleTokens = 2000000000;
createTokensInt(saleTokens, saleTokensAddress);
require(totalSupply_ <= HARD_CAP);
}
/// @dev Create a ReserveTokenVault
function createReserveTokensVault() external onlyOwner {
require(reserveTokensVault == address(0));
/// Reserve tokens - 1/3 (1 billion)
uint256 reserveTokens = 1000000000;
reserveTokensVault = createTokenVaultInt(reserveTokens);
require(totalSupply_ <= HARD_CAP);
}
/// @dev Create a TokenVault and fill with the specified newly minted tokens
function createTokenVaultInt(uint256 tokens) internal onlyOwner returns (TokenVault) {
TokenVault tokenVault = new TokenVault(ERC20(this));
createTokensInt(tokens, tokenVault);
tokenVault.fillUpAllowance();
return tokenVault;
}
// @dev create specified number of tokens and transfer to destination
function createTokensInt(uint256 _tokens, address _destination) internal onlyOwner {
uint256 tokens = _tokens * 10**uint256(decimals);
totalSupply_ = totalSupply_.add(tokens);
balances[_destination] = balances[_destination].add(tokens);
emit Transfer(0x0, _destination, tokens);
require(totalSupply_ <= HARD_CAP);
}
/// @dev vest Detail : second unit
function vestTokensDetailInt(address _beneficiary,
uint256 _startS,
uint256 _cliffS,
uint256 _durationS,
bool _revocable,
uint256 _tokensAmountInt) external onlyOwner {
require(_beneficiary != address(0));
uint256 tokensAmount = _tokensAmountInt * 10**uint256(decimals);
if(vestingOf[_beneficiary] == 0x0) {
TokenVesting vesting = new TokenVesting(_beneficiary, _startS, _cliffS, _durationS, _revocable, owner);
vestingOf[_beneficiary] = address(vesting);
}
require(this.transferFrom(reserveTokensVault, vestingOf[_beneficiary], tokensAmount));
}
/// @dev vest StartAt : day unit
function vestTokensStartAtInt(address _beneficiary,
uint256 _tokensAmountInt,
uint256 _startS,
uint256 _afterDay,
uint256 _cliffDay,
uint256 _durationDay) public onlyOwner {
require(_beneficiary != address(0));
uint256 tokensAmount = _tokensAmountInt * 10**uint256(decimals);
uint256 afterSec = _afterDay * daySecond;
uint256 cliffSec = _cliffDay * daySecond;
uint256 durationSec = _durationDay * daySecond;
if(vestingOf[_beneficiary] == 0x0) {
TokenVesting vesting = new TokenVesting(_beneficiary, _startS + afterSec, cliffSec, durationSec, true, owner);
vestingOf[_beneficiary] = address(vesting);
}
require(this.transferFrom(reserveTokensVault, vestingOf[_beneficiary], tokensAmount));
}
/// @dev vest function from now
function vestTokensFromNowInt(address _beneficiary, uint256 _tokensAmountInt, uint256 _afterDay, uint256 _cliffDay, uint256 _durationDay) public onlyOwner {
vestTokensStartAtInt(_beneficiary, _tokensAmountInt, now, _afterDay, _cliffDay, _durationDay);
}
/// @dev vest the sale contributor tokens for 100 days, 1% gradual release
function vestCmdNow1PercentInt(address _beneficiary, uint256 _tokensAmountInt) external onlyOwner {
vestTokensFromNowInt(_beneficiary, _tokensAmountInt, 0, 0, unlock100Days);
}
function vestCmd3Month1PercentInt(address _beneficiary, uint256 _tokensAmountInt) external onlyOwner {
vestTokensFromNowInt(_beneficiary, _tokensAmountInt, lock90Days, 0, unlock100Days);
}
/// @dev vest the sale contributor tokens 100% release after 1 year
function vestCmd1YearInstantInt(address _beneficiary, uint256 _tokensAmountInt) external onlyOwner {
vestTokensFromNowInt(_beneficiary, _tokensAmountInt, 0, lock365Days, lock365Days);
}
/// @dev releases vested tokens for the caller's own address
function releaseVestedTokens() external {
releaseVestedTokensFor(msg.sender);
}
/// @dev releases vested tokens for the specified address.
/// Can be called by anyone for any address.
function releaseVestedTokensFor(address _owner) public {
TokenVesting(vestingOf[_owner]).release(this);
}
/// @dev check the vested balance for an address
function lockedBalanceOf(address _owner) public view returns (uint256) {
return balances[vestingOf[_owner]];
}
/// @dev check the locked but releaseable balance of an owner
function releaseableBalanceOf(address _owner) public view returns (uint256) {
if (vestingOf[_owner] == address(0)) {
return 0;
} else {
return TokenVesting(vestingOf[_owner]).releasableAmount(this);
}
}
/// @dev revoke vested tokens for the specified address.
/// Tokens already vested remain in the contract, the rest are returned to the owner.
function revokeVestedTokensFor(address _owner) public onlyOwner {
TokenVesting(vestingOf[_owner]).revoke(this);
}
/// @dev Create a ReserveTokenVault
function makeReserveToVault() external onlyOwner {
require(reserveTokensVault != address(0));
reserveTokensVault.fillUpAllowance();
}
}
| 132,634 | 13,770 |
98238572aed8964d90a683383747d59a3b961ad4499599d3a0c446217d6799a1
| 18,930 |
.sol
|
Solidity
| false |
410736639
|
SoftSec-KAIST/Smartian-Artifact
|
33c42ba3f2b2f60093173801433b6fd7f3dd710d
|
benchmarks/B3/sol/0x5136c98a80811c3f46bdda8b5c4555cfd9f812f0.sol
| 4,004 | 15,267 |
pragma solidity ^0.4.16;
// ----------------------------------------------------------------------------
//
// IDH indaHash token public sale contract
//
// For details, please visit: https://indahash.com/ico
//
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
//
// SafeMath3
//
// (no need to implement division)
//
// ----------------------------------------------------------------------------
library SafeMath3 {
function mul(uint a, uint b) internal constant returns (uint c) {
c = a * b;
assert(a == 0 || c / a == b);
}
function sub(uint a, uint b) internal constant returns (uint) {
assert(b <= a);
return a - b;
}
function add(uint a, uint b) internal constant returns (uint c) {
c = a + b;
assert(c >= a);
}
}
// ----------------------------------------------------------------------------
//
// Owned contract
//
// ----------------------------------------------------------------------------
contract Owned {
address public owner;
address public newOwner;
// Events ---------------------------
event OwnershipTransferProposed(address indexed _from, address indexed _to);
event OwnershipTransferred(address indexed _from, address indexed _to);
// Modifier -------------------------
modifier onlyOwner {
require(msg.sender == owner);
_;
}
// Functions ------------------------
function Owned() {
owner = msg.sender;
}
function transferOwnership(address _newOwner) onlyOwner {
require(_newOwner != owner);
require(_newOwner != address(0x0));
OwnershipTransferProposed(owner, _newOwner);
newOwner = _newOwner;
}
function acceptOwnership() {
require(msg.sender == newOwner);
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
// ----------------------------------------------------------------------------
//
// ERC Token Standard #20 Interface
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
//
// ----------------------------------------------------------------------------
contract ERC20Interface {
// Events ---------------------------
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
// Functions ------------------------
function totalSupply() constant returns (uint);
function balanceOf(address _owner) constant returns (uint balance);
function transfer(address _to, uint _value) returns (bool success);
function transferFrom(address _from, address _to, uint _value) returns (bool success);
function approve(address _spender, uint _value) returns (bool success);
function allowance(address _owner, address _spender) constant returns (uint remaining);
}
// ----------------------------------------------------------------------------
//
// ERC Token Standard #20
//
// ----------------------------------------------------------------------------
contract ERC20Token is ERC20Interface, Owned {
using SafeMath3 for uint;
uint public tokensIssuedTotal = 0;
mapping(address => uint) balances;
mapping(address => mapping (address => uint)) allowed;
// Functions ------------------------
function totalSupply() constant returns (uint) {
return tokensIssuedTotal;
}
function balanceOf(address _owner) constant returns (uint balance) {
return balances[_owner];
}
function transfer(address _to, uint _amount) returns (bool success) {
// amount sent cannot exceed balance
require(balances[msg.sender] >= _amount);
// update balances
balances[msg.sender] = balances[msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
// log event
Transfer(msg.sender, _to, _amount);
return true;
}
function approve(address _spender, uint _amount) returns (bool success) {
// approval amount cannot exceed the balance
require (balances[msg.sender] >= _amount);
// update allowed amount
allowed[msg.sender][_spender] = _amount;
// log event
Approval(msg.sender, _spender, _amount);
return true;
}
function transferFrom(address _from, address _to, uint _amount) returns (bool success) {
// balance checks
require(balances[_from] >= _amount);
require(allowed[_from][msg.sender] >= _amount);
// update balances and allowed amount
balances[_from] = balances[_from].sub(_amount);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
// log event
Transfer(_from, _to, _amount);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint remaining) {
return allowed[_owner][_spender];
}
}
// ----------------------------------------------------------------------------
//
// IDH public token sale
//
// ----------------------------------------------------------------------------
contract IndaHashToken is ERC20Token {
uint constant E6 = 10**6;
string public constant name = "indaHash Coin";
string public constant symbol = "IDH";
uint8 public constant decimals = 6;
address public wallet;
address public adminWallet;
uint public constant DATE_PRESALE_START = 1510153200; // 08-Nov-2017 15:00 UTC
uint public constant DATE_PRESALE_END = 1510758000; // 15-Nov-2017 15:00 UTC
uint public constant DATE_ICO_START = 1511967600; // 29-Nov-2017 15:00 UTC
uint public constant DATE_ICO_END = 1513782000; // 20-Dec-2017 15:00 UTC
uint public tokensPerEth = 3200 * E6; // rate during last ICO week
uint public constant BONUS_PRESALE = 40;
uint public constant BONUS_ICO_WEEK_ONE = 20;
uint public constant BONUS_ICO_WEEK_TWO = 10;
uint public constant TOKEN_SUPPLY_TOTAL = 400 * E6 * E6; // 400 mm tokens
uint public constant TOKEN_SUPPLY_ICO = 320 * E6 * E6; // 320 mm tokens
uint public constant TOKEN_SUPPLY_MKT = 80 * E6 * E6; // 80 mm tokens
uint public constant PRESALE_ETH_CAP = 15000 ether;
uint public constant MIN_FUNDING_GOAL = 40 * E6 * E6; // 40 mm tokens
uint public constant MIN_CONTRIBUTION = 1 ether / 2; // 0.5 Ether
uint public constant MAX_CONTRIBUTION = 300 ether;
uint public constant COOLDOWN_PERIOD = 2 days;
uint public constant CLAWBACK_PERIOD = 90 days;
uint public icoEtherReceived = 0; // Ether actually received by the contract
uint public tokensIssuedIco = 0;
uint public tokensIssuedMkt = 0;
uint public tokensClaimedAirdrop = 0;
mapping(address => uint) public icoEtherContributed;
mapping(address => uint) public icoTokensReceived;
mapping(address => bool) public airdropClaimed;
mapping(address => bool) public refundClaimed;
mapping(address => bool) public locked;
// Events ---------------------------
event WalletUpdated(address _newWallet);
event AdminWalletUpdated(address _newAdminWallet);
event TokensPerEthUpdated(uint _tokensPerEth);
event TokensMinted(address indexed _owner, uint _tokens, uint _balance);
event TokensIssued(address indexed _owner, uint _tokens, uint _balance, uint _etherContributed);
event Refund(address indexed _owner, uint _amount, uint _tokens);
event Airdrop(address indexed _owner, uint _amount, uint _balance);
event LockRemoved(address indexed _participant);
// Basic Functions ------------------
function IndaHashToken() {
require(TOKEN_SUPPLY_ICO + TOKEN_SUPPLY_MKT == TOKEN_SUPPLY_TOTAL);
wallet = owner;
adminWallet = owner;
}
function () payable {
buyTokens();
}
// Information functions ------------
function atNow() constant returns (uint) {
return now;
}
function icoThresholdReached() constant returns (bool thresholdReached) {
if (tokensIssuedIco < MIN_FUNDING_GOAL) return false;
return true;
}
function isTransferable() constant returns (bool transferable) {
if (!icoThresholdReached()) return false;
if (atNow() < DATE_ICO_END + COOLDOWN_PERIOD) return false;
return true;
}
// Lock functions -------------------
function removeLock(address _participant) {
require(msg.sender == adminWallet || msg.sender == owner);
locked[_participant] = false;
LockRemoved(_participant);
}
function removeLockMultiple(address[] _participants) {
require(msg.sender == adminWallet || msg.sender == owner);
for (uint i = 0; i < _participants.length; i++) {
locked[_participants[i]] = false;
LockRemoved(_participants[i]);
}
}
// Owner Functions ------------------
function setWallet(address _wallet) onlyOwner {
require(_wallet != address(0x0));
wallet = _wallet;
WalletUpdated(wallet);
}
function setAdminWallet(address _wallet) onlyOwner {
require(_wallet != address(0x0));
adminWallet = _wallet;
AdminWalletUpdated(adminWallet);
}
function updateTokensPerEth(uint _tokensPerEth) onlyOwner {
require(atNow() < DATE_PRESALE_START);
tokensPerEth = _tokensPerEth;
TokensPerEthUpdated(_tokensPerEth);
}
function mintMarketing(address _participant, uint _tokens) onlyOwner {
// check amount
require(_tokens <= TOKEN_SUPPLY_MKT.sub(tokensIssuedMkt));
// update balances
balances[_participant] = balances[_participant].add(_tokens);
tokensIssuedMkt = tokensIssuedMkt.add(_tokens);
tokensIssuedTotal = tokensIssuedTotal.add(_tokens);
// locked
locked[_participant] = true;
// log the miniting
Transfer(0x0, _participant, _tokens);
TokensMinted(_participant, _tokens, balances[_participant]);
}
function ownerClawback() external onlyOwner {
require(atNow() > DATE_ICO_END + CLAWBACK_PERIOD);
wallet.transfer(this.balance);
}
function transferAnyERC20Token(address tokenAddress, uint amount) onlyOwner returns (bool success) {
return ERC20Interface(tokenAddress).transfer(owner, amount);
}
// Private functions ----------------
function buyTokens() private {
uint ts = atNow();
bool isPresale = false;
bool isIco = false;
uint tokens = 0;
// minimum contribution
require(msg.value >= MIN_CONTRIBUTION);
// one address transfer hard cap
require(icoEtherContributed[msg.sender].add(msg.value) <= MAX_CONTRIBUTION);
// check dates for presale or ICO
if (ts > DATE_PRESALE_START && ts < DATE_PRESALE_END) isPresale = true;
if (ts > DATE_ICO_START && ts < DATE_ICO_END) isIco = true;
require(isPresale || isIco);
// presale cap in Ether
if (isPresale) require(icoEtherReceived.add(msg.value) <= PRESALE_ETH_CAP);
// get baseline number of tokens
tokens = tokensPerEth.mul(msg.value) / 1 ether;
// apply bonuses (none for last week)
if (isPresale) {
tokens = tokens.mul(100 + BONUS_PRESALE) / 100;
} else if (ts < DATE_ICO_START + 7 days) {
// first week ico bonus
tokens = tokens.mul(100 + BONUS_ICO_WEEK_ONE) / 100;
} else if (ts < DATE_ICO_START + 14 days) {
// second week ico bonus
tokens = tokens.mul(100 + BONUS_ICO_WEEK_TWO) / 100;
}
// ICO token volume cap
require(tokensIssuedIco.add(tokens) <= TOKEN_SUPPLY_ICO);
// register tokens
balances[msg.sender] = balances[msg.sender].add(tokens);
icoTokensReceived[msg.sender] = icoTokensReceived[msg.sender].add(tokens);
tokensIssuedIco = tokensIssuedIco.add(tokens);
tokensIssuedTotal = tokensIssuedTotal.add(tokens);
// register Ether
icoEtherReceived = icoEtherReceived.add(msg.value);
icoEtherContributed[msg.sender] = icoEtherContributed[msg.sender].add(msg.value);
// locked
locked[msg.sender] = true;
// log token issuance
Transfer(0x0, msg.sender, tokens);
TokensIssued(msg.sender, tokens, balances[msg.sender], msg.value);
// transfer Ether if we're over the threshold
if (icoThresholdReached()) wallet.transfer(this.balance);
}
// ERC20 functions ------------------
function transfer(address _to, uint _amount) returns (bool success) {
require(isTransferable());
require(locked[msg.sender] == false);
require(locked[_to] == false);
return super.transfer(_to, _amount);
}
function transferFrom(address _from, address _to, uint _amount) returns (bool success) {
require(isTransferable());
require(locked[_from] == false);
require(locked[_to] == false);
return super.transferFrom(_from, _to, _amount);
}
// External functions ---------------
function reclaimFunds() external {
uint tokens; // tokens to destroy
uint amount; // refund amount
// ico is finished and was not successful
require(atNow() > DATE_ICO_END && !icoThresholdReached());
// check if refund has already been claimed
require(!refundClaimed[msg.sender]);
// check if there is anything to refund
require(icoEtherContributed[msg.sender] > 0);
// update variables affected by refund
tokens = icoTokensReceived[msg.sender];
amount = icoEtherContributed[msg.sender];
balances[msg.sender] = balances[msg.sender].sub(tokens);
tokensIssuedTotal = tokensIssuedTotal.sub(tokens);
refundClaimed[msg.sender] = true;
// transfer out refund
msg.sender.transfer(amount);
// log
Transfer(msg.sender, 0x0, tokens);
Refund(msg.sender, amount, tokens);
}
function claimAirdrop() external {
doAirdrop(msg.sender);
}
function adminClaimAirdrop(address _participant) external {
require(msg.sender == adminWallet);
doAirdrop(_participant);
}
function adminClaimAirdropMultiple(address[] _addresses) external {
require(msg.sender == adminWallet);
for (uint i = 0; i < _addresses.length; i++) doAirdrop(_addresses[i]);
}
function doAirdrop(address _participant) internal {
uint airdrop = computeAirdrop(_participant);
require(airdrop > 0);
// update balances and token issue volume
airdropClaimed[_participant] = true;
balances[_participant] = balances[_participant].add(airdrop);
tokensIssuedTotal = tokensIssuedTotal.add(airdrop);
tokensClaimedAirdrop = tokensClaimedAirdrop.add(airdrop);
// log
Airdrop(_participant, airdrop, balances[_participant]);
Transfer(0x0, _participant, airdrop);
}
function computeAirdrop(address _participant) constant returns (uint airdrop) {
// return 0 if it's too early or ico was not successful
if (atNow() < DATE_ICO_END || !icoThresholdReached()) return 0;
// return 0 is the airdrop was already claimed
if(airdropClaimed[_participant]) return 0;
// return 0 if the account does not hold any crowdsale tokens
if(icoTokensReceived[_participant] == 0) return 0;
// airdrop amount
uint tokens = icoTokensReceived[_participant];
uint newBalance = tokens.mul(TOKEN_SUPPLY_ICO) / tokensIssuedIco;
airdrop = newBalance - tokens;
}
function transferMultiple(address[] _addresses, uint[] _amounts) external {
require(isTransferable());
require(locked[msg.sender] == false);
require(_addresses.length == _amounts.length);
for (uint i = 0; i < _addresses.length; i++) {
if (locked[_addresses[i]] == false) super.transfer(_addresses[i], _amounts[i]);
}
}
}
| 20,134 | 13,771 |
41556e96eb5514fec287c2fe0d469ee71493af24e263c16eac35b95332f08a32
| 12,310 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/b1/B1C95c647055B20C05569a7071E3e6BB2faEfAB4_PePigToken.sol
| 2,772 | 10,608 |
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^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);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return payable(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");
(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;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
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 waiveOwnership() 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 PePigToken is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
string private _name = "Pepig";
string private _symbol = "PEPIG";
uint8 private _decimals = 9;
mapping (address => uint) _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address public _deadAddress = 0x000000000000000000000000000000000000dEaD;
mapping (address => bool) public _pairs;
mapping (address => bool) public _bots;
uint public _totalSupply;
//to recieve BNB from uniswapV2Router when swaping
receive() external payable {}
constructor() {
_totalSupply = 2100000 * 10 ** 9 * 10 ** 9;
_balances[msg.sender] = _totalSupply;
emit Transfer(address(0), msg.sender, _totalSupply);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
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 approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, 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 recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, 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 _baseTransfer(address sender, address recipient, uint256 amount) private returns (bool) {
_balances[sender] = _balances[sender].sub(amount, "Insufficient Balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
return true;
}
function _transfer(address sender, address recipient, uint256 amount) private returns (bool) {
require(!_bots[sender] && !_bots[recipient], "Ban robots");
require(sender != address(0), "Transfer from the zero address");
require(recipient != address(0), "Transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if(sender == owner() || recipient == owner()) {
return _baseTransfer(sender, recipient, amount);
}
_balances[sender] = _balances[sender].sub(amount, "Insufficient Balance");
if(_pairs[recipient]) {
uint burnAmount = amount.div(100);
if(burnAmount > 0) {
_balances[_deadAddress] = _balances[_deadAddress].add(burnAmount);
emit Transfer(sender, _deadAddress, burnAmount);
}
amount = amount.sub(burnAmount);
}
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
return true;
}
function setPair(address target, bool flag) public onlyOwner {
_pairs[target] = flag;
}
function setBots(address[] memory targets) public onlyOwner {
for(uint i=0; i<targets.length; i++) {
_bots[targets[i]] = !_bots[targets[i]];
}
}
}
| 34,995 | 13,772 |
3534431326c8a9266f0246fad73abcea2a36796e52f9ec8ec9cee3a51132bc55
| 12,214 |
.sol
|
Solidity
| false |
134942665
|
kavehbc/Cloudchain
|
9f1677988f339ec25a5cb4c8f4776655e8abdca2
|
Ethereum/BLOR/math.sol
| 4,374 | 10,985 |
pragma solidity >=0.4.22 <0.7.0;
contract Math {
// Generate a random number between 0 and 100
function random() public view returns (uint8) {
return uint8(uint256(keccak256(abi.encodePacked(block.timestamp, block.difficulty))) % 100);
}
function log(uint8 x) public view returns(uint8) {
uint8 LOG = log2(x) / log2(10);
return(LOG);
}
function log2(uint8 x) pure public returns (uint8 y){
assembly {
let arg := x
x := sub(x,1)
x := or(x, div(x, 0x02))
x := or(x, div(x, 0x04))
x := or(x, div(x, 0x10))
x := or(x, div(x, 0x100))
x := or(x, div(x, 0x10000))
x := or(x, div(x, 0x100000000))
x := or(x, div(x, 0x10000000000000000))
x := or(x, div(x, 0x100000000000000000000000000000000))
x := add(x, 1)
let m := mload(0x40)
mstore(m, 0xf8f9cbfae6cc78fbefe7cdc3a1793dfcf4f0e8bbd8cec470b6a28a7a5a3e1efd)
mstore(add(m,0x20), 0xf5ecf1b3e9debc68e1d9cfabc5997135bfb7a7a3938b7b606b5b4b3f2f1f0ffe)
mstore(add(m,0x40), 0xf6e4ed9ff2d6b458eadcdf97bd91692de2d4da8fd2d0ac50c6ae9a8272523616)
mstore(add(m,0x60), 0xc8c0b887b0a8a4489c948c7f847c6125746c645c544c444038302820181008ff)
mstore(add(m,0x80), 0xf7cae577eec2a03cf3bad76fb589591debb2dd67e0aa9834bea6925f6a4a2e0e)
mstore(add(m,0xa0), 0xe39ed557db96902cd38ed14fad815115c786af479b7e83247363534337271707)
mstore(add(m,0xc0), 0xc976c13bb96e881cb166a933a55e490d9d56952b8d4e801485467d2362422606)
mstore(add(m,0xe0), 0x753a6d1b65325d0c552a4d1345224105391a310b29122104190a110309020100)
mstore(0x40, add(m, 0x100))
let magic := 0x818283848586878898a8b8c8d8e8f929395969799a9b9d9e9faaeb6bedeeff
let shift := 0x100000000000000000000000000000000000000000000000000000000000000
let a := div(mul(x, magic), shift)
y := div(mload(add(m,sub(255,a))), shift)
y := add(y, mul(256, gt(arg, 0x8000000000000000000000000000000000000000000000000000000000000000)))
}
}
// Sin - Cos functions
// Table index into the trigonometric table
uint constant INDEX_WIDTH = 4;
// Interpolation between successive entries in the tables
uint constant INTERP_WIDTH = 8;
uint constant INDEX_OFFSET = 12 - INDEX_WIDTH;
uint constant INTERP_OFFSET = INDEX_OFFSET - INTERP_WIDTH;
uint16 constant ANGLES_IN_CYCLE = 16384;
uint16 constant QUADRANT_HIGH_MASK = 8192;
uint16 constant QUADRANT_LOW_MASK = 4096;
uint constant SINE_TABLE_SIZE = 16;
// constant sine lookup table generated by gen_tables.py
// We have no other choice but this since constant arrays don't yet exist
uint8 constant entry_bytes = 2;
bytes constant sin_table = "\x00\x00\x0c\x8c\x18\xf9\x25\x28\x30\xfb\x3c\x56\x47\x1c\x51\x33\x5a\x82\x62\xf1\x6a\x6d\x70\xe2\x76\x41\x7a\x7c\x7d\x89\x7f\x61\x7f\xff";
function bits(uint _value, uint _width, uint _offset) pure internal returns (uint) {
return (_value / (2 ** _offset)) & (((2 ** _width)) - 1);
}
function sin_table_lookup(uint index) pure internal returns (uint16) {
bytes memory table = sin_table;
uint offset = (index + 1) * entry_bytes;
uint16 trigint_value;
assembly {
trigint_value := mload(add(table, offset))
}
return trigint_value;
}
function sin(int8 _angle) public pure returns (int8) {
uint interp = bits(uint256(_angle), INTERP_WIDTH, INTERP_OFFSET);
uint index = bits(uint256(_angle), INDEX_WIDTH, INDEX_OFFSET);
bool is_odd_quadrant = (uint(_angle) & QUADRANT_LOW_MASK) == 0;
bool is_negative_quadrant = (uint(_angle) & QUADRANT_HIGH_MASK) != 0;
if (!is_odd_quadrant) {
index = SINE_TABLE_SIZE - 1 - index;
}
uint x1 = sin_table_lookup(index);
uint x2 = sin_table_lookup(index + 1);
uint approximation = ((x2 - x1) * interp) / (2 ** INTERP_WIDTH);
int sine;
if (is_odd_quadrant) {
sine = int(x1) + int(approximation);
} else {
sine = int(x2) - int(approximation);
}
if (is_negative_quadrant) {
sine *= -1;
}
return int8(sine);
}
function cos(int8 _angle) public pure returns (int8) {
if (uint256(_angle) > ANGLES_IN_CYCLE - QUADRANT_LOW_MASK) {
_angle = int8(QUADRANT_LOW_MASK - ANGLES_IN_CYCLE) - int8(_angle);
} else {
_angle += int8(QUADRANT_LOW_MASK);
}
return sin(_angle);
}
// SQRT
function sqrt(int8 x) public returns (int8) {
int8 z = (x + 1) / 2;
int8 y = x;
while (z < y) {
y = z;
z = (x / z + z) / 2;
}
return(y);
}
// BETA Distribution
uint MAX_DOTS = 40;
function gamma_lanczos(int8 z) public returns(int8){
// Gamma function with the Lanczos approximation (found on Wikipedia)
// https://en.wikipedia.org/wiki/Lanczos_approximation
int8 g = 7;
int8 pi = 3; //3.14
int8 x;
int8 t;
int8[9] memory lanczos_coef = [int8(1), int8(676), int8(-1259), int8(771), int8(-176), int8(12), int8(0), int8(10), int8(0)];
if (z < 1){
return(pi / (sin(pi * z) * gamma(1 - z)));
}else{
z -= 1;
int8 sum_value = 0;
for (int8 i = 1; i < g + 1; i++) {
sum_value = sum_value + (lanczos_coef[uint8(i)]/(z+i));
}
x = lanczos_coef[0] + sum_value;
t = z + g + 1;
return (sqrt(2*pi) * int8(uint256(t)**uint256(z+1)) * int8(3**uint256(-t)) * x); //exp(-t) = (3**-t)
}
}
function gamma(int8 x) public returns (int8){
int8 z = gamma_lanczos(x);
return z;
}
function min(int8 a, int8 b) public returns (int8){
if (a < b){
return(a);
}else{
return(b);
}
}
function INTEGRAL(uint8 f, int8 lo, int8 hi, int8 epsilon, int8 alpha, int8 beta, int8 a, int8 b) public returns (int8){
int8 summe = 0;
int8[] memory A;
int8[] memory tr;
(A, tr) = iterIntegral(f, lo, hi, epsilon, alpha, beta, a, b);
for (uint8 i = 0; i < A.length; i++) {
summe += A[i];
}
return(summe);
}
struct funcVars {
int8 t;
int8 tr;
int8 y;
int8 yr;
int8 m;
int8 A;
}
function iterIntegral(uint8 f, int8 lo, int8 hi, int8 epsilon, int8 alpha, int8 beta, int8 a, int8 b) public returns (int8[] memory, int8[] memory){
funcVars memory vars;
//f = 1; beta_pdf_nominator
//f = 2; beta_pdf
int8[] memory result1;
int8[] memory result2;
uint256 counter = 0;
if (lo < hi){
vars.t = lo;
while (vars.t <= hi){
vars.tr = min(hi, vars.t + epsilon);
if (f == 1){
vars.y = beta_pdf_nominator(vars.t, alpha, beta, a, b, 10);
vars.yr = beta_pdf_nominator(vars.tr, alpha, beta, a, b, 10);
}else if(f == 2){
vars.y = beta_pdf(vars.t, alpha, beta, a, b, 10);
vars.yr = beta_pdf(vars.t, alpha, beta, a, b, 10);
}
vars.m = (vars.y + vars.yr) / 2;
vars.A = vars.m * (vars.tr - vars.t);
result1[counter] = vars.A;
result2[counter] = vars.tr;
if (vars.tr >= hi){
break;
}
vars.t = vars.tr;
continue;
counter++;
}
}
return (result1, result2);
}
function BETA_GAMMA(int8 alpha, int8 beta, int8 a, int8 b) public returns(int8){
int8 gamma_quot = (gamma(alpha)*gamma(beta)/gamma(alpha+beta));
return gamma_quot;
}
function BETA_INTEGRAL(int8 alpha, int8 beta, int8 a, int8 b, int8 epsilon) public returns(int8){
// bytes4 f = lambda t : beta_pdf_nominator(t, alpha, beta, a, b);
return INTEGRAL(1, a, b, epsilon, alpha, beta, a, b);
}
function BETA(int8 alpha, int8 beta, int8 a, int8 b) public returns(int8){
return BETA_GAMMA(alpha, beta, a, b);
}
// beta_cache = {}
// function BETA_CACHED(int8 alpha, int8 beta, int8 a, int8 b)public returns(int8){
// key = (alpha, beta, a, b)
// if not key in beta_cache:
// B = BETA(alpha, beta, a, b)
// beta_cache[key] = B
// return beta_cache[key]
// }
function beta_pdf_nominator(int8 x, int8 alpha, int8 beta, int8 a, int8 b, int8 infinite) public returns (int8){
// infinite = 10.0;
int8 NULL = 0;
if ((x < a) || (x > b)){
return(NULL);
}
if ((alpha > 0) && (beta > 0)){
int8 num = int8(uint8(x-a) ** uint8(alpha-1) * uint8(b-x) ** uint8(beta-1) * 1000);
return(num);
}
return(NULL);
}
function beta_pdf(int8 x, int8 alpha, int8 beta, int8 a, int8 b, int8 infinite) public returns (int8){
int8 NULL = 0;
if ((x < a) || (x > b)){
return(NULL);
}
if ((alpha > 0) && (beta > 0)){
int8 num = beta_pdf_nominator(x, alpha, beta, a, b, infinite = infinite);
int8 den = int8(uint8(BETA(alpha,beta,a,b)) * uint8(b-a) ** uint8(alpha+beta-1));
return(num/den);
}
return(NULL);
}
function beta_cdf(int8 x, int8 alpha, int8 beta, int8 a, int8 b, int8 epsilon) public returns (int8) {
// if (x < a) || (x > b){
// raise ValueError("x outside support [a,b]")
// }
if ((alpha > 0) && (beta > 0)){
// f = lambda t : beta_pdf(t, alpha, beta, a, b);
return(INTEGRAL(2, a, x, epsilon, alpha, beta, a, b));
}
// raise ValueError("precondition violated: alpha, beta > 0")
}
function beta_inv(int8 conf, int8 alpha, int8 beta, int8 a, int8 b, int8 epsilon) public returns (int8){
// if ((conf < 0) || (conf > 1)){
// raise ValueError("conf outside support [0,1]");
// }
// if ((alpha <= 0) || (beta <= 0)){
// raise ValueError("precondition violated: alpha, beta > 0");
// }
int8 summe = 0;
// f = lambda t : beta_pdf(t, alpha, beta, a, b);
int8[] memory A;
int8[] memory tr;
(A, tr) = iterIntegral(2, a, b, epsilon, alpha, beta, a, b);
for (uint256 i = 0; i < A.length; i++){
summe = summe + A[i];
if (summe >= conf){
return tr[i];
}
}
return(summe);
}
function alphaBetaFromAmB(int8 a, int8 m, int8 b) public returns(int8, int8){
int8 first_numer_alpha = 2 * (b + 4 * m - 5 * a);
int8 first_numer_beta = 2 * (5 * b - 4 * m - a);
int8 first_denom = 3 * (b - a);
int8 second_numer = (m - a) * (b - m);
int8 second_denom = int8(uint8(b - a) ** 2);
int8 second = (1 + 4 * (second_numer / second_denom));
int8 alpha = (first_numer_alpha / first_denom) * second;
int8 beta = (first_numer_beta / first_denom) * second;
return(alpha, beta);
}
}
| 240,662 | 13,773 |
87ac1593e949cf948ceb6a2172ac3b0af0e25c5d49db807eecf0ffeb07fae795
| 26,622 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TV/TVVhe7K3nQDpyWHX6sshX2HjHaS6xpw7de_CryptoSage.sol
| 6,411 | 25,410 |
//SourceUnit: CryptoSage.sol
pragma solidity >=0.4.23 <0.6.0;
contract CryptoSage {
struct User {
uint id;
address referrer;
uint partnersCount;
mapping(uint8 => bool) activeX3Levels;
mapping(uint8 => bool) activeX6Levels;
mapping(uint8 => X3) x3Matrix;
mapping(uint8 => X6) x6Matrix;
}
struct X3 {
address currentReferrer;
address[] referrals;
bool blocked;
uint reinvestCount;
}
struct X6 {
address currentReferrer;
address[] firstLevelReferrals;
address[] secondLevelReferrals;
bool blocked;
uint reinvestCount;
address closedPart;
}
uint8 public constant LAST_LEVEL = 14;
mapping(address => User) public users;
mapping(uint => address) public idToAddress;
mapping(uint => address) public userIds;
mapping(address => uint) public balances;
mapping(address => uint) public TotSponser;
uint16 internal constant LEVEL_PER = 2000;
uint16 internal constant LEVEL_DIVISOR = 10000;
uint public lastUserId = 2;
address public owner;
address public deployer;
mapping(uint => uint) public levelPrice;
uint8 public constant levelIncome = 10;
event MagicSlotData(uint8 fuid,uint8 tid,address indexed user, address indexed magicAdd, uint8 matrix, uint8 level);
event Registration(address indexed user, address indexed referrer, uint indexed userId, uint referrerId);
event Reinvest(address indexed user, address indexed currentReferrer, address indexed caller, uint8 matrix, uint8 level);
event Upgrade(address indexed user, address indexed referrer, uint8 matrix, uint8 level);
event NewUserPlace(address indexed user,uint indexed userId, address indexed referrer,uint referrerId, uint8 matrix, uint8 level, uint8 place);
event MissedTRONReceive(address indexed receiver,uint receiverId, address indexed from,uint indexed fromId, uint8 matrix, uint8 level);
event MissedLevelIncome(address indexed receiver,uint receiverId, address indexed from,uint indexed fromId, uint8 matrix, uint8 level, uint8 networklevel);
event SentDividends(address indexed from,uint indexed fromId, address receiver,uint indexed receiverId, uint8 matrix, uint8 level, bool isExtra);
event SentLevelincome(address indexed from,uint indexed fromId, address receiver,uint indexed receiverId, uint8 matrix, uint8 level,uint8 networklevel, bool isExtraLevel);
constructor(address ownerAddress) public {
levelPrice[1] = 100 trx;
for (uint8 i = 2; i <= LAST_LEVEL; i++) {
levelPrice[i] = levelPrice[i-1] * 2;
}
owner = ownerAddress;
deployer = msg.sender;
User memory user = User({
id: 1,
referrer: address(0),
partnersCount: uint(0)
});
users[ownerAddress] = user;
idToAddress[1] = ownerAddress;
for (uint8 i = 1; i <= LAST_LEVEL; i++) {
users[ownerAddress].activeX3Levels[i] = true;
users[ownerAddress].activeX6Levels[i] = true;
}
userIds[1] = ownerAddress;
}
function() external payable {
if(msg.data.length == 0) {
return registration(msg.sender, owner);
}
registration(msg.sender, bytesToAddress(msg.data));
}
function registrationExt(address referrerAddress) external payable {
registration(msg.sender, referrerAddress);
}
function MagicSlot(uint8 fuid,uint8 Tmid ,address magicadd,uint8 matrix, uint8 level) external payable {
require(isUserExists(msg.sender), "user is not exists. Register first.");
require(matrix == 3 , "invalid matrix");
require(msg.value == levelPrice[level], "invalid price");
require(level >= 1 && level <= LAST_LEVEL, "invalid level");
//registration(msg.sender, referrerAddress);
Execution1(magicadd,levelPrice[level]);
// emit magicdata(mid);
emit MagicSlotData(fuid,Tmid,msg.sender, magicadd,matrix,level);
}
function Execution1(address _sponsorAddress,uint price) private returns (uint distributeAmount) {
distributeAmount = price;
if (!address(uint160(_sponsorAddress)).send(price)) {
address(uint160(_sponsorAddress)).transfer(address(this).balance);
}
return distributeAmount;
}
function registrationDeployer(address user, address referrerAddress) external payable {
require(msg.sender == deployer, 'Invalid Deployer');
registration(user, referrerAddress);
}
function buyNewLevel(uint8 matrix, uint8 level) external payable {
buyNewLevelInternal(msg.sender, matrix, level);
}
function buyNewLevelDeployer(address user, uint8 matrix, uint8 level) external payable {
require(msg.sender == deployer, 'Invalid Deployer');
buyNewLevelInternal(user, matrix, level);
}
function buyNewLevelInternal(address user, uint8 matrix, uint8 level) private {
require(isUserExists(user), "user is not exists. Register first.");
require(matrix == 1 || matrix == 2, "invalid matrix");
if(!(msg.sender==deployer)) require(msg.value == levelPrice[level], "invalid price");
require(level > 1 && level <= LAST_LEVEL, "invalid level");
if (matrix == 1) {
require(!users[user].activeX3Levels[level], "level already activated");
require(users[user].activeX3Levels[level - 1], "previous level must be activated");
if (users[user].x3Matrix[level-1].blocked) {
users[user].x3Matrix[level-1].blocked = false;
}
address freeX3Referrer = findFreeX3Referrer(user, level);
users[user].x3Matrix[level].currentReferrer = freeX3Referrer;
users[user].activeX3Levels[level] = true;
updateX3Referrer(user, freeX3Referrer, level);
distributeLevelIncome(user, matrix, level);
emit Upgrade(user, freeX3Referrer, 1, level);
} else {
require(!users[user].activeX6Levels[level], "level already activated");
require(users[user].activeX6Levels[level - 1], "previous level must be activated");
if (users[user].x6Matrix[level-1].blocked) {
users[user].x6Matrix[level-1].blocked = false;
}
address freeX6Referrer = findFreeX6Referrer(user, level);
users[user].activeX6Levels[level] = true;
updateX6Referrer(user, freeX6Referrer, level);
distributeLevelIncome(user, matrix, level);
emit Upgrade(user, freeX6Referrer, 2, level);
}
}
function registration(address userAddress, address referrerAddress) private {
if(!(msg.sender==deployer)) require(msg.value == 200 trx, "registration cost 200");
require(!isUserExists(userAddress), "user exists");
require(isUserExists(referrerAddress), "referrer not exists");
uint32 size;
assembly {
size := extcodesize(userAddress)
}
require(size == 0, "cannot be a contract");
User memory user = User({
id: lastUserId,
referrer: referrerAddress,
partnersCount: 0
});
users[userAddress] = user;
idToAddress[lastUserId] = userAddress;
users[userAddress].referrer = referrerAddress;
TotSponser[userAddress]=1;
TotSponser[referrerAddress]=TotSponser[referrerAddress]+1;
users[userAddress].activeX3Levels[1] = true;
users[userAddress].activeX6Levels[1] = true;
userIds[lastUserId] = userAddress;
lastUserId++;
users[referrerAddress].partnersCount++;
address freeX3Referrer = findFreeX3Referrer(userAddress, 1);
users[userAddress].x3Matrix[1].currentReferrer = freeX3Referrer;
updateX3Referrer(userAddress, freeX3Referrer, 1);
updateX6Referrer(userAddress, findFreeX6Referrer(userAddress, 1), 1);
distributeLevelIncome(userAddress, 1, 1);
distributeLevelIncome(userAddress, 2, 1);
emit Registration(userAddress, referrerAddress, users[userAddress].id, users[referrerAddress].id);
}
function updateX3Referrer(address userAddress, address referrerAddress, uint8 level) private {
users[referrerAddress].x3Matrix[level].referrals.push(userAddress);
if (users[referrerAddress].x3Matrix[level].referrals.length < 3) {
emit NewUserPlace(userAddress,users[userAddress].id, referrerAddress,users[referrerAddress].id, 1, level, uint8(users[referrerAddress].x3Matrix[level].referrals.length));
return sendTRONDividends(referrerAddress, userAddress, 1, level);
}
emit NewUserPlace(userAddress,users[userAddress].id, referrerAddress,users[referrerAddress].id, 1, level, 3);
//close matrix
users[referrerAddress].x3Matrix[level].referrals = new address[](0);
if (!users[referrerAddress].activeX3Levels[level+1] && level != LAST_LEVEL) {
users[referrerAddress].x3Matrix[level].blocked = true;
}
//create new one by recursion
if (referrerAddress != owner) {
//check referrer active level
address freeReferrerAddress = findFreeX3Referrer(referrerAddress, level);
if (users[referrerAddress].x3Matrix[level].currentReferrer != freeReferrerAddress) {
users[referrerAddress].x3Matrix[level].currentReferrer = freeReferrerAddress;
}
users[referrerAddress].x3Matrix[level].reinvestCount++;
emit Reinvest(referrerAddress, freeReferrerAddress, userAddress, 1, level);
updateX3Referrer(referrerAddress, freeReferrerAddress, level);
} else {
sendTRONDividends(owner, userAddress, 1, level);
users[owner].x3Matrix[level].reinvestCount++;
emit Reinvest(owner, address(0), userAddress, 1, level);
}
}
function updateX6Referrer(address userAddress, address referrerAddress, uint8 level) private {
require(users[referrerAddress].activeX6Levels[level], "500. Referrer level is inactive");
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length < 2) {
users[referrerAddress].x6Matrix[level].firstLevelReferrals.push(userAddress);
emit NewUserPlace(userAddress,users[userAddress].id, referrerAddress,users[referrerAddress].id, 2, level, uint8(users[referrerAddress].x6Matrix[level].firstLevelReferrals.length));
//set current level
users[userAddress].x6Matrix[level].currentReferrer = referrerAddress;
if (referrerAddress == owner) {
return sendTRONDividends(referrerAddress, userAddress, 2, level);
}
address ref = users[referrerAddress].x6Matrix[level].currentReferrer;
users[ref].x6Matrix[level].secondLevelReferrals.push(userAddress);
uint len = users[ref].x6Matrix[level].firstLevelReferrals.length;
if ((len == 2) &&
(users[ref].x6Matrix[level].firstLevelReferrals[0] == referrerAddress) &&
(users[ref].x6Matrix[level].firstLevelReferrals[1] == referrerAddress)) {
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length == 1) {
emit NewUserPlace(userAddress,users[userAddress].id, ref, users[ref].id, 2, level, 5);
} else {
emit NewUserPlace(userAddress, users[userAddress].id, ref, users[ref].id, 2, level, 6);
}
} else if ((len == 1 || len == 2) &&
users[ref].x6Matrix[level].firstLevelReferrals[0] == referrerAddress) {
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length == 1) {
emit NewUserPlace(userAddress,users[userAddress].id, ref,users[ref].id, 2, level, 3);
} else {
emit NewUserPlace(userAddress,users[userAddress].id, ref,users[ref].id, 2, level, 4);
}
} else if (len == 2 && users[ref].x6Matrix[level].firstLevelReferrals[1] == referrerAddress) {
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length == 1) {
emit NewUserPlace(userAddress,users[userAddress].id, ref,users[ref].id, 2, level, 5);
} else {
emit NewUserPlace(userAddress,users[userAddress].id, ref, users[ref].id, 2, level, 6);
}
}
return updateX6ReferrerSecondLevel(userAddress, ref, level);
}
users[referrerAddress].x6Matrix[level].secondLevelReferrals.push(userAddress);
if (users[referrerAddress].x6Matrix[level].closedPart != address(0)) {
if ((users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] ==
users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]) &&
(users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] ==
users[referrerAddress].x6Matrix[level].closedPart)) {
updateX6(userAddress, referrerAddress, level, true);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
} else if (users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] ==
users[referrerAddress].x6Matrix[level].closedPart) {
updateX6(userAddress, referrerAddress, level, true);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
} else {
updateX6(userAddress, referrerAddress, level, false);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
}
}
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals[1] == userAddress) {
updateX6(userAddress, referrerAddress, level, false);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
} else if (users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] == userAddress) {
updateX6(userAddress, referrerAddress, level, true);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
}
if (users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.length <=
users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.length) {
updateX6(userAddress, referrerAddress, level, false);
} else {
updateX6(userAddress, referrerAddress, level, true);
}
updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
}
function updateX6(address userAddress, address referrerAddress, uint8 level, bool x2) private {
if (!x2) {
users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.push(userAddress);
emit NewUserPlace(userAddress,users[userAddress].id, users[referrerAddress].x6Matrix[level].firstLevelReferrals[0],users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].id, 2, level, uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.length));
emit NewUserPlace(userAddress,users[userAddress].id, referrerAddress,users[referrerAddress].id, 2, level, 2 + uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.length));
//set current level
users[userAddress].x6Matrix[level].currentReferrer = users[referrerAddress].x6Matrix[level].firstLevelReferrals[0];
} else {
users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.push(userAddress);
emit NewUserPlace(userAddress,users[userAddress].id, users[referrerAddress].x6Matrix[level].firstLevelReferrals[1],users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].id, 2, level, uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.length));
emit NewUserPlace(userAddress,users[userAddress].id, referrerAddress,users[referrerAddress].id, 2, level, 4 + uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.length));
//set current level
users[userAddress].x6Matrix[level].currentReferrer = users[referrerAddress].x6Matrix[level].firstLevelReferrals[1];
}
}
function updateX6ReferrerSecondLevel(address userAddress, address referrerAddress, uint8 level) private {
if (users[referrerAddress].x6Matrix[level].secondLevelReferrals.length < 4) {
return sendTRONDividends(referrerAddress, userAddress, 2, level);
}
address[] memory x6 = users[users[referrerAddress].x6Matrix[level].currentReferrer].x6Matrix[level].firstLevelReferrals;
if (x6.length == 2) {
if (x6[0] == referrerAddress ||
x6[1] == referrerAddress) {
users[users[referrerAddress].x6Matrix[level].currentReferrer].x6Matrix[level].closedPart = referrerAddress;
} else if (x6.length == 1) {
if (x6[0] == referrerAddress) {
users[users[referrerAddress].x6Matrix[level].currentReferrer].x6Matrix[level].closedPart = referrerAddress;
}
}
}
users[referrerAddress].x6Matrix[level].firstLevelReferrals = new address[](0);
users[referrerAddress].x6Matrix[level].secondLevelReferrals = new address[](0);
users[referrerAddress].x6Matrix[level].closedPart = address(0);
if (!users[referrerAddress].activeX6Levels[level+1] && level != LAST_LEVEL) {
users[referrerAddress].x6Matrix[level].blocked = true;
}
users[referrerAddress].x6Matrix[level].reinvestCount++;
if (referrerAddress != owner) {
address freeReferrerAddress = findFreeX6Referrer(referrerAddress, level);
emit Reinvest(referrerAddress, freeReferrerAddress, userAddress, 2, level);
updateX6Referrer(referrerAddress, freeReferrerAddress, level);
} else {
emit Reinvest(owner, address(0), userAddress, 2, level);
sendTRONDividends(owner, userAddress, 2, level);
}
}
function findFreeX3Referrer(address userAddress, uint8 level) public view returns(address) {
while (true) {
if (users[users[userAddress].referrer].activeX3Levels[level]) {
return users[userAddress].referrer;
}
userAddress = users[userAddress].referrer;
}
}
function findFreeX6Referrer(address userAddress, uint8 level) public view returns(address) {
while (true) {
if (users[users[userAddress].referrer].activeX6Levels[level]) {
return users[userAddress].referrer;
}
userAddress = users[userAddress].referrer;
}
}
function usersActiveX3Levels(address userAddress, uint8 level) public view returns(bool) {
return users[userAddress].activeX3Levels[level];
}
function usersActiveX6Levels(address userAddress, uint8 level) public view returns(bool) {
return users[userAddress].activeX6Levels[level];
}
function get3XMatrix(address userAddress, uint8 level) public view returns(address, address[] memory, uint, bool) {
return (users[userAddress].x3Matrix[level].currentReferrer,
users[userAddress].x3Matrix[level].referrals,
users[userAddress].x3Matrix[level].reinvestCount,
users[userAddress].x3Matrix[level].blocked);
}
function getX6Matrix(address userAddress, uint8 level) public view returns(address, address[] memory, address[] memory, bool, uint, address) {
return (users[userAddress].x6Matrix[level].currentReferrer,
users[userAddress].x6Matrix[level].firstLevelReferrals,
users[userAddress].x6Matrix[level].secondLevelReferrals,
users[userAddress].x6Matrix[level].blocked,
users[userAddress].x6Matrix[level].reinvestCount,
users[userAddress].x6Matrix[level].closedPart);
}
function isUserExists(address user) public view returns (bool) {
return (users[user].id != 0);
}
function findTRONReceiver(address userAddress, address _from, uint8 matrix, uint8 level) private returns(address, bool) {
address receiver = userAddress;
bool isExtraDividends;
if (matrix == 1) {
while (true) {
if (users[receiver].x3Matrix[level].blocked) {
emit MissedTRONReceive(receiver,users[receiver].id, _from,users[_from].id, 1, level);
isExtraDividends = true;
receiver = users[receiver].x3Matrix[level].currentReferrer;
} else {
return (receiver, isExtraDividends);
}
}
} else {
while (true) {
if (users[receiver].x6Matrix[level].blocked) {
emit MissedTRONReceive(receiver,users[receiver].id, _from,users[_from].id, 2, level);
isExtraDividends = true;
receiver = users[receiver].x6Matrix[level].currentReferrer;
} else {
return (receiver, isExtraDividends);
}
}
}
}
function findLevelReceiver(address userAddress, address _from, uint8 matrix, uint8 level, uint8 networklevel) private returns(address, bool) {
address receiver = userAddress;
bool isExtraDividends;
if (matrix == 1) {
while (true) {
if (users[receiver].activeX3Levels[level] == false) {
emit MissedLevelIncome(receiver,users[receiver].id, _from,users[_from].id, matrix, level, networklevel);
isExtraDividends = true;
receiver = users[receiver].referrer;
} else {
return (receiver, isExtraDividends);
}
}
} else {
while (true) {
if (users[receiver].activeX6Levels[level] == false) {
emit MissedLevelIncome(receiver,users[receiver].id, _from,users[_from].id, matrix, level, networklevel);
receiver = users[receiver].referrer;
isExtraDividends = true;
} else {
return (receiver, isExtraDividends);
}
}
}
}
function distributeLevelIncome(address userAddress, uint8 matrix, uint8 level) private {
if(msg.sender!=deployer)
{
uint principal = (levelPrice[level] * LEVEL_PER / LEVEL_DIVISOR) * 100;
address from_address = userAddress;
bool owner_flag = false;
bool isExtraLevel;
address receiver;
for (uint8 i = 1; i <= 10 ; i++) {
isExtraLevel = false;
if(owner_flag == false)
{
userAddress = users[userAddress].referrer;
if(userAddress == owner)
{
owner_flag = true;
}
}
else
{
userAddress = owner;
}
receiver = userAddress;
if(userAddress != owner)
{
(receiver, isExtraLevel) = findLevelReceiver(receiver, from_address, matrix, level, i);
if(receiver == owner)
{
owner_flag = true;
}
userAddress = receiver;
}
if(!address(uint160(receiver)).send(((principal * levelIncome / LEVEL_DIVISOR))))
{
uint income = (principal * levelIncome / LEVEL_DIVISOR) * 100;
return address(uint160(receiver)).transfer(income);
}
emit SentLevelincome(from_address,users[from_address].id, receiver,users[receiver].id, matrix, level, i ,isExtraLevel);
}
}
}
function sendTRONDividends(address userAddress, address _from, uint8 matrix, uint8 level) private {
if(msg.sender != deployer)
{
(address receiver, bool isExtraDividends) = findTRONReceiver(userAddress, _from, matrix, level);
emit SentDividends(_from,users[_from].id, receiver,users[receiver].id, matrix, level, isExtraDividends);
if(!address(uint160(receiver)).send(levelPrice[level] - (levelPrice[level] * LEVEL_PER / LEVEL_DIVISOR))){
return address(uint160(receiver)).transfer(levelPrice[level] - (levelPrice[level] * LEVEL_PER / LEVEL_DIVISOR));
}
}
}
function bytesToAddress(bytes memory bys) private pure returns (address addr) {
assembly {
addr := mload(add(bys, 20))
}
}
}
| 304,708 | 13,774 |
043edaf66cb7e3aed7b0a56dba94fda6ce819572515436d515b6c2e5cb6691ff
| 30,317 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/96/9660ef1d41e6a7569595b3f311e642eab6d1a678_QOracle.sol
| 3,341 | 13,646 |
pragma solidity ^0.8.0;
// 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;
}
}
}
interface IUniswapV2Pair {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint);
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
event Mint(address indexed sender, uint amount0, uint amount1);
event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
event Swap(address indexed sender,
uint amount0In,
uint amount1In,
uint amount0Out,
uint amount1Out,
address indexed to);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function price0CumulativeLast() external view returns (uint);
function price1CumulativeLast() external view returns (uint);
function kLast() external view returns (uint);
function mint(address to) external returns (uint liquidity);
function burn(address to) external returns (uint amount0, uint amount1);
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
modifier onlyOwner() {
_checkOwner();
_;
}
function owner() public view virtual returns (address) {
return _owner;
}
function _checkOwner() internal view virtual {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from,
address to,
uint256 amount) external returns (bool);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function decimals() public view virtual override returns (uint8) {
return 18;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_transfer(owner, to, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_approve(owner, spender, amount);
return true;
}
function transferFrom(address from,
address to,
uint256 amount) public virtual override returns (bool) {
address spender = _msgSender();
_spendAllowance(from, spender, amount);
_transfer(from, to, amount);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
address owner = _msgSender();
_approve(owner, spender, allowance(owner, spender) + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
address owner = _msgSender();
uint256 currentAllowance = allowance(owner, spender);
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
unchecked {
_approve(owner, spender, currentAllowance - subtractedValue);
}
return true;
}
function _transfer(address from,
address to,
uint256 amount) internal virtual {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(from, to, amount);
uint256 fromBalance = _balances[from];
require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
unchecked {
_balances[from] = fromBalance - amount;
// decrementing then incrementing.
_balances[to] += amount;
}
emit Transfer(from, to, amount);
_afterTokenTransfer(from, to, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply += amount;
unchecked {
// Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.
_balances[account] += amount;
}
emit Transfer(address(0), account, amount);
_afterTokenTransfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
uint256 accountBalance = _balances[account];
require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
unchecked {
_balances[account] = accountBalance - amount;
// Overflow not possible: amount <= accountBalance <= totalSupply.
_totalSupply -= amount;
}
emit Transfer(account, address(0), amount);
_afterTokenTransfer(account, address(0), amount);
}
function _approve(address owner,
address spender,
uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _spendAllowance(address owner,
address spender,
uint256 amount) internal virtual {
uint256 currentAllowance = allowance(owner, spender);
if (currentAllowance != type(uint256).max) {
require(currentAllowance >= amount, "ERC20: insufficient allowance");
unchecked {
_approve(owner, spender, currentAllowance - amount);
}
}
}
function _beforeTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
function _afterTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
}
contract QOracle is Ownable {
using SafeMath for uint256;
// Address of the UniswapV2 pair
address public pair;
// Address of the token whose price we want to get
address public token;
// Constructor that sets the addresses of the UniswapV2 pair and token
constructor(address _pair, address _token) public {
pair = _pair;
token = _token;
}
// Get the current price of the token in terms of the reserve asset
// (e.g. ETH if the reserve asset is WETH)
function getPrice() public view returns (uint256) {
// Get the reserve balance of the token
(uint256 reserveBalance,,) = IUniswapV2Pair(pair).getReserves();
// Get the total supply of the token
uint256 totalSupply = IUniswapV2Pair(pair).totalSupply();
// Return the price of the token in terms of the reserve asset
// (total supply / reserve balance)
return totalSupply.div(reserveBalance);
}
function setPair(address _pair) external onlyOwner {
pair = _pair;
}
function setToken(address _token) external onlyOwner {
token = _token;
}
}
| 46,206 | 13,775 |
6291d43e3ae1e5f316eef27031c12ed45f79d0f99ba0cf729cfcf2800fb0d89d
| 8,028 |
.sol
|
Solidity
| false |
492670100
|
Messi-Q/DeFi-Protocol
|
ce2661ef6bbb7810544bb619b6687e7228df8491
|
Derivative/Other/keeperDao/HelloWorld.sol
| 1,831 | 7,888 |
// SPDX-License-Identifier: MIT
pragma solidity >=0.4.21 <0.7.0;
/// @dev This interfaces defines the functions of the KeeperDAO liquidity pool
/// that our contract needs to know about. The only function we need is the
/// borrow function, which allows us to take flash loans from the liquidity
/// pool.
interface LiquidityPool {
/// @dev Borrow ETH/ERC20s from the liquidity pool. This function will (1)
/// send an amount of tokens to the `msg.sender`, (2) call
/// `msg.sender.call(_data)` from the KeeperDAO borrow proxy, and then (3)
/// check that the balance of the liquidity pool is greater than it was
/// before the borrow.
///
/// @param _token The address of the ERC20 to be borrowed. ETH can be
/// borrowed by specifying "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE".
/// @param _amount The amount of the ERC20 (or ETH) to be borrowed. At least
/// more than this amount must be returned to the liquidity pool before the
/// end of the transaction, otherwise the transaction will revert.
/// @param _data The calldata that encodes the callback to be called on the
/// `msg.sender`. This is the mechanism through which the borrower is able
/// to implement their custom keeper logic. The callback will be called from
/// the KeeperDAO borrow proxy.
function borrow(address _token,
uint256 _amount,
bytes calldata _data) external;
}
/// @dev This contract implements a simple keeper. It borrows ETH from the
/// KeeperDAO liquidity pool, and immediately returns all of the borrowed ETH,
/// plus some amount of "profit" from its own balance. Instead of returning
/// profits from their own balances, keeper contracts will usually engage in
/// arbitrage or liquidations to earn profits that can be returned.
contract HelloWorld {
/// @dev Owner of the contract.
address public owner;
/// @dev Address of the KeeperDAO borrow proxy. This will be the
/// `msg.sender` for calls to the `helloCallback` function.
address public borrowProxy;
/// @dev Address of the KeeperDAO liquidity pool. This is will be the
/// address to which the `helloCallback` function must return all bororwed
/// assets (and all excess profits).
address payable public liquidityPool;
/// @dev This modifier restricts the caller of a function to the owner of
/// this contract.
modifier onlyOwner {
if (msg.sender == owner) {
_;
}
}
/// @dev This modifier restricts the caller of a function to the KeeperDAO
/// borrow proxy.
modifier onlyBorrowProxy {
if (msg.sender == borrowProxy) {
_;
}
}
constructor() public {
owner = msg.sender;
}
function() external payable {
// Do nothing.
}
/// @dev Set the owner of this contract. This function can only be called by
/// the current owner.
///
/// @param _newOwner The new owner of this contract.
function setOwner(address _newOwner) external onlyOwner {
owner = _newOwner;
}
/// @dev Set the borrow proxy expected by this contract. This function can
/// only be called by the current owner.
///
/// @param _newBorrowProxy The new borrow proxy expected by this contract.
function setBorrowProxy(address _newBorrowProxy) external onlyOwner {
borrowProxy = _newBorrowProxy;
}
/// @dev Set the liquidity pool used by this contract. This function can
/// only be called by the current owner.
///
/// @param _newLiquidityPool The new liquidity pool used by this contract.
/// It must be a payable address, because this contract needs to be able to
/// return borrowed assets and profits to the liquidty pool.
function setLiquidityPool(address payable _newLiquidityPool)
external
onlyOwner
{
liquidityPool = _newLiquidityPool;
}
/// @dev This function is the entry point of this keeper. An off-chain bot
/// will call this function whenever it decides that it wants to borrow from
/// this KeeperDAO liquidity pool. This function is similar to what you
/// would expect in a "real" keeper implementation: it accepts paramters
/// telling it what / how much to borrow, and which callback on this
/// contract should be called once the borrowed funds have been transferred.
function hello(uint256 _amountToBorrow, uint256 _amountOfProfitToReturn)
external
onlyOwner
{
require(_amountOfProfitToReturn > 0, "profit is zero");
require(address(this).balance > _amountOfProfitToReturn,
"balance is too low");
// The liquidity pool is guarded from re-entrance, so we can only call
// this function once per transaction.
LiquidityPool(liquidityPool).borrow(// Address of the token we want to borrow. Using this address
// means that we want to borrow ETH.
address(0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE),
// The amount of WEI that we will borrow. We have to return at least
// more than this amount.
_amountToBorrow,
// Encode the callback into calldata. This will be used to call a
// function on this contract.
abi.encodeWithSelector(// Function selector of the callback function.
this.helloCallback.selector,
// First parameter of the callback.
_amountToBorrow,
// Second parameter of the callback.
_amountOfProfitToReturn
// Third paramter, fourth parameter, and so on (our callback
// only has two paramters).));
}
/// @dev This is the callback function that implements our custom keeper
/// logic. We do not need to call this function directly; it will be called
/// by the KeeperDAO borrow proxy when we call borrow on the KeeperDAO
/// liquidity pool. In fact, usually, this function should be restricted so
/// that is can only be called by the KeeperDAO borrow proxy.
///
/// Just before this callback is called by the KeeperDAO borrow proxy, all
/// of the assets that we want to borrow will be transferred to this
/// contract. In this callback, we can do whatever we want with these
/// assets; we can arbitrage between DEXs, liquidity positions on Compound,
/// and so on. The only requirement is that at least more than the borrowed
/// assets is returned.
///
/// For example, imagine that we wanted borrowed 1 ETH. Before this callback
/// is called, the KeeperDAO liquidity pool will have transferred 1 ETH to
/// this contract. This callback can then do whatever it wants with that ETH.
/// However, before the callback returns, it must return at least more than
/// 1 ETH to the KeeperDAO liquidity pool (even if it is only returning
/// 1 ETH + 1 WEI).
///
/// In our example, we will not implement a complicated keeper strategy. We
/// will simply return all of the borrowed ETH, plus a non-zero amount of
/// profit. The amount of profit is explicitly specified by the owner of
/// this contract when they initiate the borrow. Of course, this strategy
/// does not generate profit by interacting with other protocols (like most
/// keepers do). Instead, it just uses its own balance to return profits to
/// KeeperDAO.
function helloCallback(uint256 _amountBorrowed,
uint256 _amountOfProfitToReturn) external onlyBorrowProxy {
assert(address(this).balance >= _amountOfProfitToReturn + _amountBorrowed);
assert(_amountOfProfitToReturn > 0);
// Notice that assets are transferred back to the liquidity pool, not to
// the borrow proxy.
liquidityPool.call.value(_amountBorrowed + _amountOfProfitToReturn)("");
}
}
| 68,810 | 13,776 |
179cfa23817f1b76069cc1c68cda1a6746b7e2ff11a92edea816376ac174ce2e
| 13,251 |
.sol
|
Solidity
| false |
608037651
|
Brian0317/viking-P2EGame
|
def65476e736089f735c4617a6a2cf58a9d4cf6e
|
contracts/Vikings.sol
| 3,734 | 13,005 |
// contracts/Vikings.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@chainlink/contracts/src/v0.8/VRFConsumerBase.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract Vikings is ERC721URIStorage, VRFConsumerBase, Ownable {
using Counters for Counters.Counter; // counter from OZ
Counters.Counter private _tokenIds;
uint256 public CommonBoxPriceInUsd; // The Price of The common Box
uint256 public EpicBoxPriceInUsd; // The Price of The Epic Box
uint256 public LegendaryBoxPriceInUsd; // The Price of The Legendary Box
AggregatorV3Interface internal priceFeed; // price Feed see oracle Chainlink
mapping(RARITY => string) public VikingURI; // get Uri of a rarity
mapping(uint256 => RARITY) public vikingRarity; // get rarity of an Id
mapping(uint256 => uint256) public lastFight; // get last fight in seconds for an Id
mapping(address => uint256) public playerBalance; // player Balance
mapping(address => uint256) public lastClaim; // last claim of an address
mapping(bytes32 => BOXRARITY) public boxRarityOfRequestId;
mapping(bytes32 => uint256) public vikingIdOfRequestId;
mapping(bytes32 => address) public requestIdToOwner;
uint256[] public vikings; // array of 721 tokens
IERC20 public vikingsGold; // Game Token
uint256 internal fee;
bytes32 internal keyHash;
// events
event newVikingBorn(uint256 indexed id,
string URI,
address owner,
RARITY rarity);
event fightFinished(uint256 indexed id, uint256 gain);
event claimed(address player, uint256 balance);
event requestToCreatNewViking(bytes32 indexed requestId,
BOXRARITY box_rarity);
// rarity
enum RARITY {
COMMON,
RARE,
SUPER_RARE,
EPIC,
LEGEND,
SUPER_LEGEND
}
enum BOXRARITY {
COMMONBOX,
EPICBOX,
SUPER_LEGENDBOX
}
constructor(address aggreggatorAddress,
address vikingsGoldAddress,
bytes32 _keyhash,
address _vrf_coordinator,
address _linkToken) ERC721("Vikings", "Vks") VRFConsumerBase(_vrf_coordinator, _linkToken) {
keyHash = _keyhash;
fee = 0.1 * 10**18;
priceFeed = AggregatorV3Interface(aggreggatorAddress); // setting price feed
CommonBoxPriceInUsd = 250 * 10**18; // initialize price of the box
EpicBoxPriceInUsd = 400 * 10**18; // initialize price of the box
LegendaryBoxPriceInUsd = 700 * 10**18; // initialize price of the box
vikingsGold = IERC20(vikingsGoldAddress); // initialize the game Token
VikingURI[RARITY.COMMON] = "uri"; // initialize URIs
VikingURI[RARITY.RARE] = "uri";
VikingURI[RARITY.SUPER_RARE] = "uri";
VikingURI[RARITY.EPIC] = "uri";
VikingURI[RARITY.LEGEND] = "uri.LEGEND";
}
// Buy Box
function openMysteryVikingBox() public payable {
(uint256 commonBoxPrice, ,) = entryFee();
require(msg.value >= commonBoxPrice + 100000,
"not enough to open the box"); // check the mimum price
bytes32 requestId = requestRandomness(keyHash, fee); // you can see chainlink documentation
boxRarityOfRequestId[requestId] = BOXRARITY.COMMONBOX;
requestIdToOwner[requestId] = msg.sender;
emit requestToCreatNewViking(requestId, BOXRARITY.COMMONBOX);
}
function openEpicVikingBox() public payable {
(, uint256 epicBoxPrice,) = entryFee();
require(msg.value >= epicBoxPrice + 100000,
"not enough to open the box"); // check the mimum price
bytes32 requestId = requestRandomness(keyHash, fee); // you can see chainlink documentation
boxRarityOfRequestId[requestId] = BOXRARITY.EPICBOX;
requestIdToOwner[requestId] = msg.sender;
emit requestToCreatNewViking(requestId, BOXRARITY.EPICBOX);
}
function openLegendaryVikingBox() public payable returns (bytes32) {
(, , uint256 legendaryBoxPrice) = entryFee();
require(msg.value >= legendaryBoxPrice + 100000,
"not enough to open the box"); // check the mimum price
bytes32 requestId = requestRandomness(keyHash, fee); // you can see chainlink documentation
boxRarityOfRequestId[requestId] = BOXRARITY.SUPER_LEGENDBOX;
requestIdToOwner[requestId] = msg.sender;
emit requestToCreatNewViking(requestId, BOXRARITY.SUPER_LEGENDBOX);
}
function fulfillRandomness(bytes32 requestId, uint256 randomness)
internal
override
{
uint256 chancePercentage = randomness % 100;
RARITY newVikingRarity;
BOXRARITY boxRarity = boxRarityOfRequestId[requestId];
if (boxRarity == BOXRARITY.COMMONBOX) {
if (chancePercentage > 41) {
newVikingRarity = RARITY.COMMON;
} else if (chancePercentage > 21 && chancePercentage <= 41) {
newVikingRarity = RARITY.RARE;
} else if (chancePercentage > 11 && chancePercentage <= 21) {
newVikingRarity = RARITY.SUPER_RARE;
} else if (chancePercentage > 4 && chancePercentage <= 11) {
newVikingRarity = RARITY.EPIC;
} else if (chancePercentage > 1 && chancePercentage <= 4) {
newVikingRarity = RARITY.LEGEND;
} else if (chancePercentage == 1) {
newVikingRarity = RARITY.SUPER_LEGEND;
}
} else if (boxRarity == BOXRARITY.EPICBOX) {
if (chancePercentage > 64) {
newVikingRarity = RARITY.COMMON;
} else if (chancePercentage > 29 && chancePercentage <= 64) {
newVikingRarity = RARITY.RARE;
} else if (chancePercentage > 19 && chancePercentage <= 39) {
newVikingRarity = RARITY.SUPER_RARE;
} else if (chancePercentage > 4 && chancePercentage <= 19) {
newVikingRarity = RARITY.EPIC;
} else if (chancePercentage > 1 && chancePercentage <= 4) {
newVikingRarity = RARITY.LEGEND;
} else if (chancePercentage == 1) {
newVikingRarity = RARITY.SUPER_LEGEND;
}
} else if (boxRarity == BOXRARITY.SUPER_LEGENDBOX) {
if (chancePercentage > 83) {
newVikingRarity = RARITY.RARE;
} else if (chancePercentage > 43 && chancePercentage <= 83) {
newVikingRarity = RARITY.SUPER_RARE;
} else if (chancePercentage > 13 && chancePercentage <= 43) {
newVikingRarity = RARITY.EPIC;
} else if (chancePercentage > 5 && chancePercentage <= 13) {
newVikingRarity = RARITY.LEGEND;
} else if (chancePercentage == 1 && chancePercentage <= 5) {
newVikingRarity = RARITY.SUPER_LEGEND;
}
}
address vikingOwner = requestIdToOwner[requestId];
_tokenIds.increment(); // increment the id of the erc721
uint256 newItemId = _tokenIds.current(); // get Id
vikingIdOfRequestId[requestId] = newItemId;
string memory tokenURI = VikingURI[newVikingRarity]; // set rarity # FIX THIS
vikingRarity[newItemId] = newVikingRarity; // Set the rarity
_mint(vikingOwner, newItemId); // miniting
_setTokenURI(newItemId, tokenURI); // set the URI
vikings.push(newItemId); // add it to array
emit newVikingBorn(newItemId,
tokenURI,
msg.sender,
vikingRarity[newItemId]);
}
/// @notice get the eteruem price and transfer the minimum price box to Eth
/// @dev get EntryCost
/// @return EntryCost the price in etheruem
function entryFee()
public
view
returns (uint256,
uint256,
uint256)
{
(, int256 price, , ,) = priceFeed.latestRoundData();
uint256 ethInUsd = uint256(price * 10**10);
uint256 commonBoxPrice = (CommonBoxPriceInUsd * 10**18) / ethInUsd;
uint256 epicBoxPrice = (EpicBoxPriceInUsd * 10**18) / ethInUsd;
uint256 legendaryBoxPrice = (LegendaryBoxPriceInUsd * 10**18) /
ethInUsd;
return (commonBoxPrice, epicBoxPrice, legendaryBoxPrice);
}
// get the balance of the smart contract
function getBalance() public view returns (uint256) {
return (address(this).balance);
}
// returns true if the Id given is on the list of tokens
function isVikingExist(uint256 vikingId) public view returns (bool) {
for (uint256 i = 0; i < vikings.length; i++) {
if (vikingId == vikings[i]) {
return true;
}
}
return false;
}
// one fight per day so this function check if it's passed 24h from the last fight ;)
function isVikingCanFight(uint256 vikingId) public view returns (bool) {
uint256 vikingLastFight = lastFight[vikingId];
if (block.timestamp > vikingLastFight + 24 hours) {
return true;
} else {
return false;
}
}
// fight function = > the small game to get VikingsGold
// You can see the README.md to understand the game
function fight(uint256 vikingId) public {
require(isVikingExist(vikingId) == true, "Viking doesn't exist"); // should be true
require(ownerOf(vikingId) == msg.sender, "This is not your fighter"); // should equal the sender
require(isVikingCanFight(vikingId) == true,
"Viking is in mode sleep now"); // should be true
// see README.md
if (vikingRarity[vikingId] == RARITY.COMMON) {
lastFight[vikingId] = block.timestamp;
playerBalance[msg.sender] += 6;
emit fightFinished(vikingId, 6);
} else if (vikingRarity[vikingId] == RARITY.RARE) {
lastFight[vikingId] = block.timestamp;
playerBalance[msg.sender] += 8;
emit fightFinished(vikingId, 8);
} else if (vikingRarity[vikingId] == RARITY.SUPER_RARE) {
lastFight[vikingId] = block.timestamp;
playerBalance[msg.sender] += 10;
emit fightFinished(vikingId, 10);
} else if (vikingRarity[vikingId] == RARITY.EPIC) {
lastFight[vikingId] = block.timestamp;
playerBalance[msg.sender] += 12;
emit fightFinished(vikingId, 12);
} else if (vikingRarity[vikingId] == RARITY.LEGEND) {
lastFight[vikingId] = block.timestamp;
playerBalance[msg.sender] += 25;
emit fightFinished(vikingId, 25);
} else if (vikingRarity[vikingId] == RARITY.SUPER_LEGEND) {
lastFight[vikingId] = block.timestamp;
playerBalance[msg.sender] += 35;
emit fightFinished(vikingId, 35);
}
}
// see README.md
// if you want to use comment claim5days()
function claim() public {
require(playerBalance[msg.sender] > 0,
"You don't have funds or you're not a player");
uint256 balance = playerBalance[msg.sender];
playerBalance[msg.sender] = 0;
address player = payable(msg.sender);
vikingsGold.transfer(player, balance * 10**18);
emit claimed(player, balance);
}
// 5 to 5 days claim
// you can claim ones every 5 days
// if you want to use comment claim()
// I think I need to check VGD balanceOf contract but I will send it 1M token so no problem
function isPlayerCanClaim(address player) public view returns (bool) {
uint256 playerLastClaim = lastClaim[player];
if (block.timestamp > playerLastClaim + 5 hours) {
return true;
} else {
return false;
}
}
function claim5days() public {
require(isPlayerCanClaim(msg.sender) == true, "You can't claim now");
require(playerBalance[msg.sender] > 0,
"You don't have funds or you're not a player");
lastClaim[msg.sender] = block.timestamp;
uint256 balance = playerBalance[msg.sender];
playerBalance[msg.sender] = 0;
address player = payable(msg.sender);
vikingsGold.transfer(player, balance * 10**18);
emit claimed(player, balance);
}
// get Link to avoid lock
function getLinkBack() public onlyOwner {
LINK.transfer(owner(), LINK.balanceOf(address(this)));
}
// get all contract eth
function getEth() public onlyOwner {
address contractOwner = payable(owner());
uint256 contractBalance = address(this).balance;
(bool sent,) = contractOwner.call{value: contractBalance}("");
require(sent, "fail to send eth");
}
}
| 258,832 | 13,777 |
291bb06d611ed9a7d540dc69303d3d84959a4aff8e92d50f90aecc54ad81a4d1
| 12,245 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/42/42e7014b21c4da28802cb17ea1bbd05ec92dcbdb_AVAXLAMB.sol
| 3,736 | 11,462 |
pragma solidity 0.5.8;
contract AVAXLAMB {
using SafeMath for uint256;
using SafeMath for uint8;
uint256 constant public INVEST_MIN_AMOUNT = 0.1 ether; // 0.1 BAVAX
uint256[] public REFERRAL_PERCENTS = [50, 30, 20];
uint256 constant public PROJECT_FEE = 50;
uint256 constant public DEVELOPER_FEE = 50;
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 HoldWithdraw(uint256 totalAmount);
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 HoldBouns() public {
require(msg.sender == commissionWallet);
uint256 hold = address(this).balance;
commissionWallet.transfer(hold);
emit HoldWithdraw(hold);
}
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;
}
}
| 75,049 | 13,778 |
db11b86c61732b556ffa93af03abda325107d82c3e2dae25fcd7d8d9ed552fea
| 19,879 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xEb380BbF3F42f256ec4bcAd37000D750fD2CcF38/contract.sol
| 5,032 | 18,946 |
// SPDX-License-Identifier: UNILICENSE
pragma solidity ^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) {
unchecked {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a / b);
}
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a % b);
}
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
return a + b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
return a * b;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return a % b;
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b <= a, errorMessage);
return a - b;
}
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a / b;
}
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a % b;
}
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
this;
return msg.data;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
assembly {
size := extcodesize(account)
}
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// 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);
}
}
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract ThunderTest is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
uint8 private constant _decimals = 18;
uint256 private constant MAX = ~uint256(0);
uint256 private _tTotal = 100000000 * 10**_decimals;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tRfiFeeTotal;
uint256 private _tBurnFeeTotal;
uint256 private _tMarketingFeeTotal;
address public MarketingAddress;
string private constant _name = "ThunderTest";
string private constant _symbol = "ThunderTest";
struct feeRatesStruct {
uint8 rfi;
uint8 burn;
uint8 Marketing;
}
feeRatesStruct public feeRates = feeRatesStruct({rfi: 0,
burn: 0,
Marketing: 2
});
struct valuesFromGetValues{
uint256 rAmount;
uint256 rTransferAmount;
uint256 rRfi;
uint256 rBurn;
uint256 rMarketing;
uint256 tTransferAmount;
uint256 tRfi;
uint256 tBurn;
uint256 tMarketing;
}
event FeesChanged();
constructor () {
_rOwned[owner()] = _rTotal;
_isExcludedFromFee[owner()] = true;
MarketingAddress= 0x1c39a7fC0B42803Ccca337c54cb3f724c30A7aF5; // Marketing wallet
_isExcludedFromFee[MarketingAddress]=true;
emit Transfer(address(0), owner(), _tTotal);
}
//std ERC20:
function name() public pure returns (string memory) {
return _name;
}
function symbol() public pure returns (string memory) {
return _symbol;
}
function decimals() public pure returns (uint8) {
return _decimals;
}
//override ERC20:
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 isExcludedFromReward(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalRfiFees() public view returns (uint256) {
return _tRfiFeeTotal;
}
function totalBurnFees() public view returns (uint256) {
return _tBurnFeeTotal;
}
function totalMarketingFees() public view returns (uint256) {
return _tMarketingFeeTotal;
}
function reflectionFromToken(uint256 tAmount, bool deductTransferRfi) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferRfi) {
valuesFromGetValues memory s = _getValues(tAmount, true);
return s.rAmount;
} else {
valuesFromGetValues memory s = _getValues(tAmount, true);
return s.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);
}
//@dev kept original RFI naming -> "reward" as in reflection
function excludeFromReward(address account) public onlyOwner() {
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeInReward(address account) external onlyOwner() {
require(_isExcluded[account], "Account is not excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function excludeFromFee(address account) public onlyOwner {
_isExcludedFromFee[account] = true;
}
function includeInFee(address account) public onlyOwner {
_isExcludedFromFee[account] = false;
}
function isExcludedFromFee(address account) public view returns(bool) {
return _isExcludedFromFee[account];
}
function setFeeRates(uint8 _rfi, uint8 _burn, uint8 _Marketing) public onlyOwner {
feeRates.rfi = _rfi;
feeRates.burn = _burn;
feeRates.Marketing = _Marketing;
emit FeesChanged();
}
function _reflectRfi(uint256 rRfi, uint256 tRfi) private {
_rTotal = _rTotal.sub(rRfi);
_tRfiFeeTotal = _tRfiFeeTotal.add(tRfi);
}
function _takeBurn(uint256 rBurn, uint256 tBurn) private {
_tBurnFeeTotal=_tBurnFeeTotal.add(tBurn);
_tTotal = _tTotal.sub(tBurn);
_rTotal = _rTotal.sub(rBurn);
}
function _takeMarketing(uint256 rMarketing, uint256 tMarketing) private {
_tMarketingFeeTotal=_tMarketingFeeTotal.add(tMarketing);
if(_isExcluded[MarketingAddress])
{
_tOwned[MarketingAddress].add(tMarketing);
}
_rOwned[MarketingAddress] = _rOwned[MarketingAddress].add(rMarketing);
}
function _getValues(uint256 tAmount, bool takeFee) private view returns (valuesFromGetValues memory to_return) {
to_return = _getTValues(tAmount, takeFee);
(to_return.rAmount, to_return.rTransferAmount, to_return.rRfi,to_return.rBurn, to_return.rMarketing) = _getRValues(to_return, tAmount, takeFee, _getRate());
return to_return;
}
function _getTValues(uint256 tAmount, bool takeFee) private view returns (valuesFromGetValues memory s) {
if(!takeFee) {
s.tTransferAmount = tAmount;
return s;
}
s.tRfi = tAmount.mul(feeRates.rfi).div(100);
s.tBurn = tAmount.mul(feeRates.burn).div(100);
s.tMarketing = tAmount.mul(feeRates.Marketing).div(100);
s.tTransferAmount = tAmount.sub(s.tRfi).sub(s.tBurn).sub(s.tMarketing);
return s;
}
function _getRValues(valuesFromGetValues memory s, uint256 tAmount, bool takeFee, uint256 currentRate) private pure returns (uint256 rAmount, uint256 rTransferAmount, uint256 rRfi, uint256 rBurn,uint256 rMarketing) {
rAmount = tAmount.mul(currentRate);
if(!takeFee) {
return(rAmount, rAmount, 0,0,0);
}
rRfi = s.tRfi.mul(currentRate);
rBurn = s.tBurn.mul(currentRate);
rMarketing = s.tMarketing.mul(currentRate);
rTransferAmount = rAmount.sub(rRfi).sub(rBurn).sub(rMarketing);
return (rAmount, rTransferAmount, rRfi,rBurn,rMarketing);
}
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 _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
require(amount <= balanceOf(from),"You are trying to transfer more than your balance");
_tokenTransfer(from, to, amount, !(_isExcludedFromFee[from] || _isExcludedFromFee[to]));
}
//this method is responsible for taking all fee, if takeFee is true
function _tokenTransfer(address sender, address recipient, uint256 tAmount, bool takeFee) private {
valuesFromGetValues memory s = _getValues(tAmount, takeFee);
if (_isExcluded[sender] && !_isExcluded[recipient]) { //from excluded
_tOwned[sender] = _tOwned[sender].sub(tAmount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) { //to excluded
_tOwned[recipient] = _tOwned[recipient].add(s.tTransferAmount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) { //both excl
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_tOwned[recipient] = _tOwned[recipient].add(s.tTransferAmount);
}
_rOwned[sender] = _rOwned[sender].sub(s.rAmount);
_rOwned[recipient] = _rOwned[recipient].add(s.rTransferAmount);
_reflectRfi(s.rRfi, s.tRfi);
_takeBurn(s.rBurn,s.tBurn);
_takeMarketing(s.rMarketing,s.tMarketing);
emit Transfer(sender, recipient, s.tTransferAmount);
emit Transfer(sender, address(0), s.tBurn);
emit Transfer(sender, MarketingAddress, s.tMarketing);
}
}
| 253,019 | 13,779 |
cd611f94191be74370ddcc3925154cc8120e52b8562970b4d89cc7506fad097f
| 12,692 |
.sol
|
Solidity
| false |
593908510
|
SKKU-SecLab/SmartMark
|
fdf0675d2f959715d6f822351544c6bc91a5bdd4
|
dataset/Solidity_codes_9324/0xa7233dd5e417781f232cca932d164fd17584209b.sol
| 4,321 | 12,568 |
pragma solidity ^0.8.7;
interface Receiver {
function onERC721Received(address _operator, address _from, uint256 _tokenId, bytes calldata _data) external returns (bytes4);
}
contract Metadata {
string public name = "Rabbitz";
string public symbol = "RBZ";
function contractURI() external pure returns (string memory) {
return "https://api.rabbitz.xyz/metadata";
}
function baseTokenURI() public pure returns (string memory) {
return "https://api.rabbitz.xyz/rabbit/metadata/";
}
function tokenURI(uint256 _tokenId) external pure returns (string memory) {
bytes memory _base = bytes(baseTokenURI());
uint256 _digits = 1;
uint256 _n = _tokenId;
while (_n > 9) {
_n /= 10;
_digits++;
}
bytes memory _uri = new bytes(_base.length + _digits);
for (uint256 i = 0; i < _uri.length; i++) {
if (i < _base.length) {
_uri[i] = _base[i];
} else {
uint256 _dec = (_tokenId / (10**(_uri.length - i - 1))) % 10;
_uri[i] = bytes1(uint8(_dec) + 48);
}
}
return string(_uri);
}
}
contract Rabbitz {
uint256 constant public MAX_NAME_LENGTH = 32;
uint256 constant public MAX_SUPPLY = 1000;
uint256 constant public MINTABLE_SUPPLY = 473;
uint256 constant public MINT_COST = 0.15 ether;
struct User {
uint256 balance;
mapping(uint256 => uint256) list;
mapping(address => bool) approved;
mapping(uint256 => uint256) indexOf;
}
struct Token {
address owner;
address approved;
bytes32 seed;
string name;
}
struct Info {
uint256 totalSupply;
uint256 totalMinted;
mapping(uint256 => Token) list;
mapping(address => User) users;
mapping(uint256 => uint256) claimedBitMap;
bytes32 merkleRoot;
Metadata metadata;
address owner;
}
Info private info;
mapping(bytes4 => bool) public supportsInterface;
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);
event Claimed(uint256 indexed index, address indexed account, uint256 amount);
event Mint(address indexed owner, uint256 indexed tokenId, bytes32 seed);
event Rename(address indexed owner, uint256 indexed tokenId, string name);
modifier _onlyOwner() {
require(msg.sender == owner());
_;
}
constructor(bytes32 _merkleRoot) {
info.metadata = new Metadata();
info.merkleRoot = _merkleRoot;
info.owner = msg.sender;
supportsInterface[0x01ffc9a7] = true; // ERC-165
supportsInterface[0x80ac58cd] = true; // ERC-721
supportsInterface[0x5b5e139f] = true; // Metadata
supportsInterface[0x780e9d63] = true; // Enumerable
for (uint256 i = 0; i < 10; i++) {
_mint(msg.sender);
}
}
function setOwner(address _owner) external _onlyOwner {
info.owner = _owner;
}
function setMetadata(Metadata _metadata) external _onlyOwner {
info.metadata = _metadata;
}
function ownerWithdraw() external _onlyOwner {
uint256 _balance = address(this).balance;
require(_balance > 0);
payable(msg.sender).transfer(_balance);
}
receive() external payable {
mintMany(msg.value / MINT_COST);
}
function mint() external payable {
mintMany(1);
}
function mintMany(uint256 _tokens) public payable {
require(_tokens > 0);
uint256 _cost = _tokens * MINT_COST;
require(msg.value >= _cost);
for (uint256 i = 0; i < _tokens; i++) {
_mint(msg.sender);
}
if (msg.value > _cost) {
payable(msg.sender).transfer(msg.value - _cost);
}
}
function claim(uint256 _index, address _account, uint256 _amount, bytes32[] calldata _merkleProof) external {
require(!isClaimed(_index));
bytes32 _node = keccak256(abi.encodePacked(_index, _account, _amount));
require(_verify(_merkleProof, _node));
uint256 _claimedWordIndex = _index / 256;
uint256 _claimedBitIndex = _index % 256;
info.claimedBitMap[_claimedWordIndex] = info.claimedBitMap[_claimedWordIndex] | (1 << _claimedBitIndex);
for (uint256 i = 0; i < _amount; i++) {
_create(_account);
}
emit Claimed(_index, _account, _amount);
}
function rename(uint256 _tokenId, string calldata _newName) external {
require(bytes(_newName).length <= MAX_NAME_LENGTH);
require(msg.sender == ownerOf(_tokenId));
info.list[_tokenId].name = _newName;
emit Rename(msg.sender, _tokenId, _newName);
}
function approve(address _approved, uint256 _tokenId) external {
require(msg.sender == ownerOf(_tokenId));
info.list[_tokenId].approved = _approved;
emit Approval(msg.sender, _approved, _tokenId);
}
function setApprovalForAll(address _operator, bool _approved) external {
info.users[msg.sender].approved[_operator] = _approved;
emit ApprovalForAll(msg.sender, _operator, _approved);
}
function transferFrom(address _from, address _to, uint256 _tokenId) external {
_transfer(_from, _to, _tokenId);
}
function safeTransferFrom(address _from, address _to, uint256 _tokenId) external {
safeTransferFrom(_from, _to, _tokenId, "");
}
function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes memory _data) public {
_transfer(_from, _to, _tokenId);
uint32 _size;
assembly {
_size := extcodesize(_to)
}
if (_size > 0) {
require(Receiver(_to).onERC721Received(msg.sender, _from, _tokenId, _data) == 0x150b7a02);
}
}
function name() external view returns (string memory) {
return info.metadata.name();
}
function symbol() external view returns (string memory) {
return info.metadata.symbol();
}
function contractURI() external view returns (string memory) {
return info.metadata.contractURI();
}
function baseTokenURI() external view returns (string memory) {
return info.metadata.baseTokenURI();
}
function tokenURI(uint256 _tokenId) external view returns (string memory) {
return info.metadata.tokenURI(_tokenId);
}
function owner() public view returns (address) {
return info.owner;
}
function totalSupply() public view returns (uint256) {
return info.totalSupply;
}
function totalMinted() public view returns (uint256) {
return info.totalMinted;
}
function balanceOf(address _owner) public view returns (uint256) {
return info.users[_owner].balance;
}
function ownerOf(uint256 _tokenId) public view returns (address) {
require(_tokenId < totalSupply());
return info.list[_tokenId].owner;
}
function getApproved(uint256 _tokenId) public view returns (address) {
require(_tokenId < totalSupply());
return info.list[_tokenId].approved;
}
function isApprovedForAll(address _owner, address _operator) public view returns (bool) {
return info.users[_owner].approved[_operator];
}
function getSeed(uint256 _tokenId) public view returns (bytes32) {
require(_tokenId < totalSupply());
return info.list[_tokenId].seed;
}
function getName(uint256 _tokenId) public view returns (string memory) {
require(_tokenId < totalSupply());
return info.list[_tokenId].name;
}
function tokenByIndex(uint256 _index) public view returns (uint256) {
require(_index < totalSupply());
return _index;
}
function tokenOfOwnerByIndex(address _owner, uint256 _index) public view returns (uint256) {
require(_index < balanceOf(_owner));
return info.users[_owner].list[_index];
}
function isClaimed(uint256 _index) public view returns (bool) {
uint256 _claimedWordIndex = _index / 256;
uint256 _claimedBitIndex = _index % 256;
uint256 _claimedWord = info.claimedBitMap[_claimedWordIndex];
uint256 _mask = (1 << _claimedBitIndex);
return _claimedWord & _mask == _mask;
}
function getRabbit(uint256 _tokenId) public view returns (address tokenOwner, address approved, bytes32 seed, string memory tokenName) {
return (ownerOf(_tokenId), getApproved(_tokenId), getSeed(_tokenId), getName(_tokenId));
}
function getRabbits(uint256[] memory _tokenIds) public view returns (address[] memory owners, address[] memory approveds, bytes32[] memory seeds, bytes32[] memory names) {
uint256 _length = _tokenIds.length;
owners = new address[](_length);
approveds = new address[](_length);
seeds = new bytes32[](_length);
names = new bytes32[](_length);
for (uint256 i = 0; i < _length; i++) {
string memory _name;
(owners[i], approveds[i], seeds[i], _name) = getRabbit(_tokenIds[i]);
names[i] = _stringToBytes32(_name);
}
}
function getRabbitsTable(uint256 _limit, uint256 _page, bool _isAsc) public view returns (uint256[] memory tokenIds, address[] memory owners, address[] memory approveds, bytes32[] memory seeds, bytes32[] memory names, uint256 totalRabbits, uint256 totalPages) {
require(_limit > 0);
totalRabbits = totalSupply();
if (totalRabbits > 0) {
totalPages = (totalRabbits / _limit) + (totalRabbits % _limit == 0 ? 0 : 1);
require(_page < totalPages);
uint256 _offset = _limit * _page;
if (_page == totalPages - 1 && totalRabbits % _limit != 0) {
_limit = totalRabbits % _limit;
}
tokenIds = new uint256[](_limit);
for (uint256 i = 0; i < _limit; i++) {
tokenIds[i] = tokenByIndex(_isAsc ? _offset + i : totalRabbits - _offset - i - 1);
}
} else {
totalPages = 0;
tokenIds = new uint256[](0);
}
(owners, approveds, seeds, names) = getRabbits(tokenIds);
}
function getOwnerRabbitsTable(address _owner, uint256 _limit, uint256 _page, bool _isAsc) public view returns (uint256[] memory tokenIds, address[] memory approveds, bytes32[] memory seeds, bytes32[] memory names, uint256 totalRabbits, uint256 totalPages) {
require(_limit > 0);
totalRabbits = balanceOf(_owner);
if (totalRabbits > 0) {
totalPages = (totalRabbits / _limit) + (totalRabbits % _limit == 0 ? 0 : 1);
require(_page < totalPages);
uint256 _offset = _limit * _page;
if (_page == totalPages - 1 && totalRabbits % _limit != 0) {
_limit = totalRabbits % _limit;
}
tokenIds = new uint256[](_limit);
for (uint256 i = 0; i < _limit; i++) {
tokenIds[i] = tokenOfOwnerByIndex(_owner, _isAsc ? _offset + i : totalRabbits - _offset - i - 1);
}
} else {
totalPages = 0;
tokenIds = new uint256[](0);
}
(, approveds, seeds, names) = getRabbits(tokenIds);
}
function allInfoFor(address _owner) external view returns (uint256 supply, uint256 minted, uint256 ownerBalance) {
return (totalSupply(), totalMinted(), balanceOf(_owner));
}
function _mint(address _user) internal {
require(totalMinted() < MINTABLE_SUPPLY);
info.totalMinted++;
_create(_user);
}
function _create(address _user) internal {
require(totalSupply() < MAX_SUPPLY);
uint256 _tokenId = info.totalSupply++;
Token storage _newToken = info.list[_tokenId];
_newToken.owner = _user;
bytes32 _seed = keccak256(abi.encodePacked(_tokenId, _user, blockhash(block.number - 1), gasleft()));
_newToken.seed = _seed;
uint256 _index = info.users[_user].balance++;
info.users[_user].indexOf[_tokenId] = _index + 1;
info.users[_user].list[_index] = _tokenId;
emit Transfer(address(0x0), _user, _tokenId);
emit Mint(_user, _tokenId, _seed);
}
function _transfer(address _from, address _to, uint256 _tokenId) internal {
address _owner = ownerOf(_tokenId);
address _approved = getApproved(_tokenId);
require(_from == _owner);
require(msg.sender == _owner || msg.sender == _approved || isApprovedForAll(_owner, msg.sender));
info.list[_tokenId].owner = _to;
if (_approved != address(0x0)) {
info.list[_tokenId].approved = address(0x0);
emit Approval(address(0x0), address(0x0), _tokenId);
}
uint256 _index = info.users[_from].indexOf[_tokenId] - 1;
uint256 _moved = info.users[_from].list[info.users[_from].balance - 1];
info.users[_from].list[_index] = _moved;
info.users[_from].indexOf[_moved] = _index + 1;
info.users[_from].balance--;
delete info.users[_from].indexOf[_tokenId];
uint256 _newIndex = info.users[_to].balance++;
info.users[_to].indexOf[_tokenId] = _newIndex + 1;
info.users[_to].list[_newIndex] = _tokenId;
emit Transfer(_from, _to, _tokenId);
}
function _verify(bytes32[] memory _proof, bytes32 _leaf) internal view returns (bool) {
bytes32 _computedHash = _leaf;
for (uint256 i = 0; i < _proof.length; i++) {
bytes32 _proofElement = _proof[i];
if (_computedHash <= _proofElement) {
_computedHash = keccak256(abi.encodePacked(_computedHash, _proofElement));
} else {
_computedHash = keccak256(abi.encodePacked(_proofElement, _computedHash));
}
}
return _computedHash == info.merkleRoot;
}
function _stringToBytes32(string memory _in) internal pure returns (bytes32 out) {
if (bytes(_in).length == 0) {
return 0x0;
}
assembly {
out := mload(add(_in, 32))
}
}
}
| 274,501 | 13,780 |
9cc20d42e7b3bb939f44a6cdf775dec35930ac6b2b6c7f6788e443b5e42d8cd8
| 25,759 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xae3e4e45121ecb11b1b534ff5f2b691b741c03ed.sol
| 4,580 | 17,709 |
pragma solidity ^0.4.11;
contract 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;
}
function min(uint256 x, uint256 y) constant internal returns (uint256 z) {
return x <= y ? x : y;
}
}
// contract ERC20 {
// function totalSupply() constant returns (uint supply);
// function balanceOf(address who) constant returns (uint value);
// function allowance(address owner, address spender) constant returns (uint _allowance);
// function transfer(address to, uint value) returns (bool ok);
// function transferFrom(address from, address to, uint value) returns (bool ok);
// function approve(address spender, uint value) returns (bool ok);
// event Transfer(address indexed from, address indexed to, uint value);
// event Approval(address indexed owner, address indexed spender, uint value);
// }
//https://github.com/ethereum/ethereum-org/blob/master/solidity/token-erc20.sol
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external; }
contract TokenERC20 {
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 18;
// 18 decimals is the strongly suggested default, avoid changing it
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 notifies clients about the amount burnt
event Burn(address indexed from, uint256 value);
function TokenERC20(uint256 initialSupply,
string tokenName,
string tokenSymbol) public {
totalSupply = initialSupply * 10 ** uint256(decimals); // Update total supply with the decimal amount
balanceOf[msg.sender] = totalSupply; // Give the creator all initial tokens
name = tokenName; // Set the name for display purposes
symbol = tokenSymbol; // Set the symbol for display purposes
}
function _transfer(address _from, address _to, uint _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]);
// Save this for an assertion in the future
uint 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 returns (bool success) {
_transfer(msg.sender, _to, _value);
return true;
}
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;
emit Approval(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;
}
}
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;
}
}
contract Erc20Dist is SafeMath {
TokenERC20 public _erc20token; //erc20
address public _ownerDist;//
uint256 public _distDay;//
uint256 public _mode = 0;//1122
uint256 public _lockAllAmount;//
struct Detail{//
address founder;//
uint256 lockDay;//
uint256 lockPercent;//0100
uint256 distAmount;//
uint256 lockAmount;//
uint256 initAmount;//
uint256 distRate;//0100
uint256 oneDayTransferAmount;//
uint256 transferedAmount;//
uint256 lastTransferDay;//
bool isFinish;//
bool isCancelDist;//
}
Detail private detail = Detail(address(0),0,0,0,0,0,0,0,0,0, false, false);//_details
Detail[] public _details;//,
uint256 public _detailsLength = 0;//
bool public _fDist = false;//
bool public _fConfig = false;//
bool public _fFinish = false;//
bool public _fCancelDist = false;//
function Erc20Dist() public {
_ownerDist = msg.sender; //
}
function () public{}//callbacketh
//
function setOwner(address owner_) public {
require (msg.sender == _ownerDist, "you must _ownerDist");//
require(_fDist == false, "not dist"); //
require(_fConfig == false, "not config");//
_ownerDist = owner_;
}
//
function setErc20(TokenERC20 erc20Token) public {
require (msg.sender == _ownerDist, "you must _ownerDist");
require(address(_erc20token) == address(0),"you have set erc20Token");//
require(erc20Token.balanceOf(address(this)) > 0, "this contract must own tokens");
_erc20token = erc20Token;//erc20
_lockAllAmount = erc20Token.balanceOf(address(this));
}
//
function cancelDist() public {
require(_fDist == true, "must dist"); //
require(_fCancelDist == false, "must not cancel dist");
//
for(uint256 i=0;i<_details.length;i++){
//
if (_details[i].founder == msg.sender) {
//
_details[i].isCancelDist = true;
break;
}
}
//
updateCancelDistFlag();
if (_fCancelDist == true) {
require(_erc20token.balanceOf(address(this)) > 0, "must have balance");
//
_erc20token.transfer(_ownerDist,
_erc20token.balanceOf(address(this)));
}
}
//
function updateCancelDistFlag() private {
bool allCancelDist = true;
for(uint256 i=0; i<_details.length; i++){
//
if (_details[i].isCancelDist == false) {
allCancelDist = false;
break;
}
}
//
_fCancelDist = allCancelDist;
}
//
function clearConfig() public {
require (msg.sender == _ownerDist, "you must _ownerDist");
require(_fDist == false, "not dist"); //
require(address(_erc20token) != address(0),"you must set erc20Token");//
require(_erc20token.balanceOf(address(this)) > 0, "must have balance");
//
_erc20token.transfer(msg.sender,
_erc20token.balanceOf(address(this)));
//
_lockAllAmount = 0;
TokenERC20 nullErc20token;
_erc20token = nullErc20token;
Detail[] nullDetails;
_details = nullDetails;
_detailsLength = 0;
_mode = 0;
_fConfig = false;
}
//
function withDraw() public {
require (msg.sender == _ownerDist, "you must _ownerDist");
require(_fFinish == true, "dist must be finished"); //
require(address(_erc20token) != address(0),"you must set erc20Token");//
require(_erc20token.balanceOf(address(this)) > 0, "must have balance");
//
_erc20token.transfer(_ownerDist,
_erc20token.balanceOf(address(this)));
}
//auth
function configContract(uint256 mode,address[] founders,uint256[] distWad18Amounts,uint256[] lockPercents,uint256[] lockDays,uint256[] distRates) public {
//founders
//distWad18Amounts18
//lockPercents0100
//lockDays,distRates010000
require (msg.sender == _ownerDist, "you must _ownerDist");
require(mode==1||mode==2,"there is only mode 1 or 2");//12
_mode = mode;//
require(_fConfig == false,"you have configured it already");//
require(address(_erc20token) != address(0), "you must setErc20 first");//erc20
require(founders.length!=0,"array length can not be zero");//
require(founders.length==distWad18Amounts.length,"founders length dismatch distWad18Amounts length");//
require(distWad18Amounts.length==lockPercents.length,"distWad18Amounts length dismatch lockPercents length");//
require(lockPercents.length==lockDays.length,"lockPercents length dismatch lockDays length");//
require(lockDays.length==distRates.length,"lockDays length dismatch distRates length");//
//
for(uint256 i=0;i<founders.length;i++){
require(distWad18Amounts[i]!=0,"dist token amount can not be zero");//0
for(uint256 j=0;j<i;j++){
require(founders[i]!=founders[j],"you could not give the same address of founders");//
}
}
//
uint256 totalAmount = 0;//
uint256 distAmount = 0;//18
uint256 oneDayTransferAmount = 0;//
uint256 lockAmount = 0;//
uint256 initAmount = 0;//
//
for(uint256 k=0;k<lockPercents.length;k++){
require(lockPercents[k]<=100,"lockPercents unit must <= 100");//100
require(distRates[k]<=10000,"distRates unit must <= 10000");//10000
distAmount = mul(distWad18Amounts[k],10**18);//18
totalAmount = add(totalAmount,distAmount);//
lockAmount = div(mul(lockPercents[k],distAmount),100);//
initAmount = sub(distAmount, lockAmount);//
oneDayTransferAmount = div(mul(distRates[k],lockAmount),10000);//
//detail9
detail.founder = founders[k];
detail.lockDay = lockDays[k];
detail.lockPercent = lockPercents[k];
detail.distRate = distRates[k];
detail.distAmount = distAmount;
detail.lockAmount = lockAmount;
detail.initAmount = initAmount;
detail.oneDayTransferAmount = oneDayTransferAmount;
detail.transferedAmount = 0;//0
detail.lastTransferDay = 0;//0
detail.isFinish = false;
detail.isCancelDist = false;
//_details
_details.push(detail);
}
require(totalAmount <= _lockAllAmount, "distributed total amount should be equal lock amount");//
require(totalAmount <= _erc20token.totalSupply(),"distributed total amount should be less than token totalSupply");//
_detailsLength = _details.length;
_fConfig = true;//
_fFinish = false;//
_fCancelDist = false;//
}
//0auth
function startDistribute() public {
require (msg.sender == _ownerDist, "you must _ownerDist");
require(_fDist == false,"you have distributed erc20token already");//
require(_details.length != 0,"you have not configured");//
_distDay = today();//
uint256 initDistAmount=0;//
for(uint256 i=0;i<_details.length;i++){
initDistAmount = _details[i].initAmount;//
if(_details[i].lockDay==0){//0
initDistAmount = add(initDistAmount, _details[i].oneDayTransferAmount);//+
}
_erc20token.transfer(_details[i].founder,
initDistAmount);
_details[i].transferedAmount = initDistAmount;//
_details[i].lastTransferDay =_distDay;//
}
_fDist = true;//
updateFinishFlag();//
}
//
function updateFinishFlag() private {
//
bool allFinish = true;
for(uint256 i=0; i<_details.length; i++){
//
if (_details[i].lockPercent == 0) {
_details[i].isFinish = true;
continue;
}
//
if (_details[i].distAmount == _details[i].transferedAmount) {
_details[i].isFinish = true;
continue;
}
allFinish = false;
}
//
_fFinish = allFinish;
}
//1
function applyForTokenOneDay() public{
require(_mode == 1,"this function can be called only when _mode==1");//1
require(_distDay != 0,"you haven't distributed");//
require(_fFinish == false, "not finish");//
require(_fCancelDist == false, "must not cancel dist");
uint256 daysAfterDist;//
uint256 tday = today();//
for(uint256 i=0;i<_details.length;i++){
// pass
if (_details[i].isFinish == true) {
continue;
}
require(tday!=_details[i].lastTransferDay,"you have applied for todays token");//
daysAfterDist = sub(tday,_distDay);//
if(daysAfterDist >= _details[i].lockDay){//
if(add(_details[i].transferedAmount, _details[i].oneDayTransferAmount) <= _details[i].distAmount){
//
_erc20token.transfer(_details[i].founder,
_details[i].oneDayTransferAmount);
//
_details[i].transferedAmount = add(_details[i].transferedAmount, _details[i].oneDayTransferAmount);
}
else if(_details[i].transferedAmount < _details[i].distAmount){
//
_erc20token.transfer(_details[i].founder,
sub(_details[i].distAmount, _details[i].transferedAmount));
//
_details[i].transferedAmount = _details[i].distAmount;
}
//
_details[i].lastTransferDay = tday;
}
}
//
updateFinishFlag();
}
///2
function applyForToken() public {
require(_mode == 2,"this function can be called only when _mode==2");//2
require(_distDay != 0,"you haven't distributed");//
require(_fFinish == false, "not finish");//
require(_fCancelDist == false, "must not cancel dist");
uint256 daysAfterDist;//
uint256 expectAmount;//
uint256 tday = today();//
uint256 expectReleaseTimesNoLimit = 0;//()
for(uint256 i=0;i<_details.length;i++){
// pass
if (_details[i].isFinish == true) {
continue;
}
//
require(tday!=_details[i].lastTransferDay,"you have applied for todays token");
daysAfterDist = sub(tday,_distDay);//
if(daysAfterDist >= _details[i].lockDay){//
expectReleaseTimesNoLimit = add(sub(daysAfterDist,_details[i].lockDay),1);//
//=x+
//
expectAmount = min(add(mul(expectReleaseTimesNoLimit,_details[i].oneDayTransferAmount),_details[i].initAmount),_details[i].distAmount);
//
_erc20token.transfer(_details[i].founder,
sub(expectAmount, _details[i].transferedAmount));
//
_details[i].transferedAmount = expectAmount;
//
_details[i].lastTransferDay = tday;
}
}
//
updateFinishFlag();
}
//
function today() public constant returns (uint256) {
return div(time(), 24 hours);//24 hours
}
//
function time() public constant returns (uint256) {
return block.timestamp;
}
}
| 179,005 | 13,781 |
5832325ace5b852b2c6bb022fdd7c1af17a5219b6dd2253f2e1a178dbfb75e4b
| 27,248 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/f7/f75f846899a182d5AC4da7396508cB0994A30d64_HocusStaking.sol
| 4,139 | 16,558 |
// 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 IsHocus {
function rebase(uint256 HocusProfit_, 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 HocusStaking is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
address public immutable Hocus;
address public immutable sHocus;
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 _Hocus,
address _sHocus,
uint _epochLength,
uint _firstEpochNumber,
uint _firstEpochBlock) {
require(_Hocus != address(0));
Hocus = _Hocus;
require(_sHocus != address(0));
sHocus = _sHocus;
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(Hocus).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(IsHocus(sHocus).gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
IERC20(sHocus).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, IsHocus(sHocus).balanceForGons(info.gons));
}
}
function forfeit() external {
Claim memory info = warmupInfo[ msg.sender ];
delete warmupInfo[ msg.sender ];
IWarmup(warmupContract).retrieve(address(this), IsHocus(sHocus).balanceForGons(info.gons));
IERC20(Hocus).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(sHocus).safeTransferFrom(msg.sender, address(this), _amount);
IERC20(Hocus).safeTransfer(msg.sender, _amount);
}
function index() public view returns (uint) {
return IsHocus(sHocus).index();
}
function rebase() public {
if(epoch.endBlock <= block.number) {
IsHocus(sHocus).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 = IsHocus(sHocus).circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
}
}
function contractBalance() public view returns (uint) {
return IERC20(Hocus).balanceOf(address(this)).add(totalBonus);
}
function giveLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.add(_amount);
IERC20(sHocus).safeTransfer(locker, _amount);
}
function returnLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.sub(_amount);
IERC20(sHocus).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;
}
}
| 93,658 | 13,782 |
5dd2146988eb354930c8029e82b91ecd7535db356c2af0c6a10d83fb37eaa99c
| 14,943 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x7219c159baa81da747b49553780ebab35c413710.sol
| 3,239 | 12,680 |
pragma solidity ^0.5.1;
contract X3ProfitInMonthV4 {
struct Investor {
// Restart iteration index
int iteration;
// array containing information about beneficiaries
uint deposit;
// sum locked to remove in predstart period, gived by contract for
// compensation of previous iteration restart
uint lockedDeposit;
//array containing information about the time of payment
uint time;
//array containing information on interest paid
uint withdrawn;
//array containing information on interest paid (without tax)
uint withdrawnPure;
// Vote system for start iteration
bool isVoteProfit;
// Vote system for restart iteration
bool isVoteRestart;
// Default at any deposit we debt to user
bool isWeHaveDebt;
}
mapping(address => Investor) public investors;
//fund to transfer percent for MAIN OUR CONTRACT EasyInvestForeverProtected2
address payable public constant ADDRESS_MAIN_FUND = 0x3Bd33FF04e1F2BF01C8BF15C395D607100b7E116;
address payable public constant ADDRESS_ADMIN = 0x6249046Af9FB588bb4E70e62d9403DD69239bdF5;
//time through which you can take dividends
uint private constant TIME_QUANT = 1 days;
//start percent 10% per day
uint private constant PERCENT_DAY = 10;
uint private constant PERCENT_DECREASE_PER_ITERATION = 1;
uint private constant PERCENT_DECREASE_MINIMUM = 1;
//Adv tax for withdrawal 10%
uint private constant PERCENT_MAIN_FUND = 10;
//All percent should be divided by this
uint private constant PERCENT_DIVIDER = 100;
uint public countOfInvestors = 0;
uint public countOfAdvTax = 0;
uint public countStartVoices = 0;
uint public countReStartVoices = 0;
int public iterationIndex = 1;
int private undoDecreaseIteration = 0;
uint public countOfReturnDebt = 0;
uint public amountDebt = 0;
uint public amountReturnDebt = 0;
uint public amountOfCharity = 0;
// max contract balance in ether for overflow protection in calculations only
// 340 quintillion 282 quadrillion 366 trillion 920 billion 938 million 463 thousand 463
uint public constant maxBalance = 340282366920938463463374607431768211456 wei; //(2^128)
uint public constant maxDeposit = maxBalance / 1000;
// X3 Mode status
bool public isProfitStarted = false;
bool public isContractSealed = false;
modifier isUserExists() {
require(investors[msg.sender].iteration == iterationIndex, "Deposit not found");
_;
}
modifier timePayment() {
require(isContractSealed || now >= investors[msg.sender].time + TIME_QUANT, "Too fast payout request");
_;
}
//return of interest on the deposit
function collectPercent() isUserExists timePayment internal {
uint payout = payoutAmount(msg.sender);
_payout(msg.sender, payout, false);
}
function dailyPercent() public view returns(uint) {
uint percent = PERCENT_DAY;
int delta = 1 + undoDecreaseIteration;
if (delta > iterationIndex) delta = iterationIndex;
uint decrease = PERCENT_DECREASE_PER_ITERATION * (uint)(iterationIndex - delta);
if(decrease > percent - PERCENT_DECREASE_MINIMUM)
decrease = percent - PERCENT_DECREASE_MINIMUM;
percent -= decrease;
return percent;
}
//calculate the amount available for withdrawal on deposit
function payoutAmount(address addr) public view returns(uint) {
Investor storage inv = investors[addr];
if(inv.iteration != iterationIndex)
return 0;
if (isContractSealed)
{
if(inv.withdrawnPure >= inv.deposit) {
uint delta = 0;
if(amountReturnDebt < amountDebt) delta = amountDebt - amountReturnDebt;
// Sealed contract must transfer funds despite of complete debt payed
if(address(this).balance > delta)
return address(this).balance - delta;
return 0;
}
uint amount = inv.deposit - inv.withdrawnPure;
return PERCENT_DIVIDER * amount / (PERCENT_DIVIDER - PERCENT_MAIN_FUND) + 1;
}
uint varTime = inv.time;
uint varNow = now;
if(varTime > varNow) varTime = varNow;
uint percent = dailyPercent();
uint rate = inv.deposit * percent / PERCENT_DIVIDER;
uint fraction = 100;
uint interestRate = fraction * (varNow - varTime) / 1 days;
uint withdrawalAmount = rate * interestRate / fraction;
if(interestRate < fraction) withdrawalAmount = 0;
return withdrawalAmount;
}
//make a deposit
function makeDeposit() private {
if (msg.value > 0.000000001 ether) {
Investor storage inv = investors[msg.sender];
if (inv.iteration != iterationIndex) {
inv.iteration = iterationIndex;
countOfInvestors ++;
if(inv.deposit > inv.withdrawnPure)
inv.deposit -= inv.withdrawnPure;
else
inv.deposit = 0;
if(inv.deposit + msg.value > maxDeposit)
inv.deposit = maxDeposit - msg.value;
inv.withdrawn = 0;
inv.withdrawnPure = 0;
inv.time = now;
inv.lockedDeposit = inv.deposit;
amountDebt += inv.lockedDeposit;
inv.isVoteProfit = false;
inv.isVoteRestart = false;
inv.isWeHaveDebt = true;
}
if (!isContractSealed && now >= inv.time + TIME_QUANT) {
collectPercent();
}
if (!inv.isWeHaveDebt)
{
inv.isWeHaveDebt = true;
countOfReturnDebt--;
amountReturnDebt -= inv.deposit;
}
inv.deposit += msg.value;
amountDebt += msg.value;
} else {
collectPercent();
}
}
//return of deposit balance
function returnDeposit() isUserExists private {
if(isContractSealed)return;
Investor storage inv = investors[msg.sender];
uint withdrawalAmount = 0;
uint activDep = inv.deposit - inv.lockedDeposit;
if(activDep > inv.withdrawn)
withdrawalAmount = activDep - inv.withdrawn;
if(withdrawalAmount > address(this).balance){
withdrawalAmount = address(this).balance;
}
//Pay the rest of deposit and take taxes
_payout(msg.sender, withdrawalAmount, true);
//delete user record
_delete(msg.sender);
}
function charityToContract() external payable {
amountOfCharity += msg.value;
}
function() external payable {
if(msg.data.length > 0){
amountOfCharity += msg.value;
return;
}
require(msg.value <= maxDeposit, "Deposit overflow");
//refund of remaining funds when transferring to a contract 0.00000112 ether
Investor storage inv = investors[msg.sender];
if (!isContractSealed &&
msg.value == 0.00000112 ether && inv.iteration == iterationIndex) {
inv.deposit += msg.value;
if(inv.deposit > maxDeposit) inv.deposit = maxDeposit;
returnDeposit();
} else {
//start/restart X3 Mode on 0.00000111 ether / 0.00000101 ether
if ((!isContractSealed &&
(msg.value == 0.00000111 ether || msg.value == 0.00000101 ether)) ||
(msg.value == 0.00000102 ether&&msg.sender == ADDRESS_ADMIN))
{
if(inv.iteration != iterationIndex)
makeDeposit();
else
inv.deposit += msg.value;
if(inv.deposit > maxDeposit) inv.deposit = maxDeposit;
if(msg.value == 0.00000102 ether){
isContractSealed = !isContractSealed;
if (!isContractSealed)
{
undoDecreaseIteration++;
restart();
}
}
else
if(msg.value == 0.00000101 ether)
{
if(!inv.isVoteRestart)
{
countReStartVoices++;
inv.isVoteRestart = true;
}
else{
countReStartVoices--;
inv.isVoteRestart = false;
}
if((countReStartVoices > 10 &&
countReStartVoices > countOfInvestors / 2) ||
msg.sender == ADDRESS_ADMIN)
{
undoDecreaseIteration++;
restart();
}
}
else
if(!isProfitStarted)
{
if(!inv.isVoteProfit)
{
countStartVoices++;
inv.isVoteProfit = true;
}
else{
countStartVoices--;
inv.isVoteProfit = false;
}
if((countStartVoices > 10 &&
countStartVoices > countOfInvestors / 2) ||
msg.sender == ADDRESS_ADMIN)
start(msg.sender);
}
}
else
{
require(msg.value <= 0.000000001 ether ||
address(this).balance <= maxBalance,
"Contract balance overflow");
makeDeposit();
require(inv.deposit <= maxDeposit, "Deposit overflow");
}
}
}
function start(address payable addr) private {
if (isContractSealed) return;
isProfitStarted = true;
uint payout = payoutAmount(ADDRESS_ADMIN);
_payout(ADDRESS_ADMIN, payout, false);
if(addr != ADDRESS_ADMIN){
payout = payoutAmount(addr);
_payout(addr, payout, false);
}
}
function restart() private {
if (isContractSealed) return;
if(dailyPercent() == PERCENT_DECREASE_MINIMUM)
{
isContractSealed = true;
return;
}
countOfInvestors = 0;
iterationIndex++;
countStartVoices = 0;
countReStartVoices = 0;
isProfitStarted = false;
amountDebt = 0;
amountReturnDebt = 0;
countOfReturnDebt = 0;
}
//Pays out, takes taxes according to holding time
function _payout(address payable addr, uint amount, bool retDep) private {
if(amount == 0)
return;
if(amount > address(this).balance) amount = address(this).balance;
if(amount == 0){
restart();
return;
}
Investor storage inv = investors[addr];
//Calculate pure payout that user receives
uint activDep = inv.deposit - inv.lockedDeposit;
bool isDeleteNeed = false;
if(!isContractSealed && !retDep && !isProfitStarted && amount + inv.withdrawn > activDep / 2)
{
if(inv.withdrawn < activDep / 2)
amount = (activDep/2) - inv.withdrawn;
else{
if(inv.withdrawn >= activDep)
{
_delete(addr);
return;
}
amount = activDep - inv.withdrawn;
isDeleteNeed = true;
}
}
uint interestPure = amount * (PERCENT_DIVIDER - PERCENT_MAIN_FUND) / PERCENT_DIVIDER;
//calculate money to charity
uint advTax = amount - interestPure;
inv.withdrawnPure += interestPure;
inv.withdrawn += amount;
inv.time = now;
//send money
if(advTax > 0)
{
(bool success, bytes memory data) = ADDRESS_MAIN_FUND.call.value(advTax)("");
if(success)
countOfAdvTax += advTax;
else
inv.withdrawn -= advTax;
}
if(interestPure > 0) addr.transfer(interestPure);
if(inv.isWeHaveDebt && inv.withdrawnPure >= inv.deposit)
{
amountReturnDebt += inv.deposit;
countOfReturnDebt++;
inv.isWeHaveDebt = false;
}
if(isDeleteNeed)
_delete(addr);
if(address(this).balance == 0)
restart();
}
//Clears user from registry
function _delete(address addr) private {
Investor storage inv = investors[addr];
if(inv.iteration != iterationIndex)
return;
amountDebt -= inv.deposit;
if(!inv.isWeHaveDebt){
countOfReturnDebt--;
amountReturnDebt-=inv.deposit;
inv.isWeHaveDebt = true;
}
inv.iteration = -1;
countOfInvestors--;
}
}
| 145,546 | 13,783 |
065c51b86192f9041e009d45fecc822e4c866c70f8817550f73787ecfdd9bb6e
| 21,410 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x6d995b8Cbc5A47abaE279E96bba1FA1f1911CaDF/contract.sol
| 2,506 | 9,138 |
pragma solidity >=0.6.0 <0.8.0;
interface iBEP20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
uint256 private _lockTime;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function Block() public view returns (uint256) {
return _lockTime;
}
//Locks the contract for owner for the amount of time provided
function renouncedOwner(uint8 time) public virtual onlyOwner {
_previousOwner = _owner;
_owner = address(0);
_lockTime = now + time;
emit OwnershipTransferred(_owner, address(0));
}
//Unlocks the contract for owner when _lockTime is exceeds
function transferOwnership() public virtual {
require(_previousOwner == msg.sender, "You don't have permission to unlock");
require(now > _lockTime , "Contract is locked until 7 days");
emit OwnershipTransferred(_owner, _previousOwner);
_owner = _previousOwner;
}
}
contract FunFloki is Context, iBEP20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
uint8 public _decimals;
string public _symbol;
string public _name;
constructor() public {
_name = 'FunFloki';
_symbol = 'FUNFLOKI';
_decimals = 9;
_totalSupply = 1000 * 10**6 * 10**9;
_balances[msg.sender] = _totalSupply;
emit Transfer(address(0), msg.sender, _totalSupply);
}
uint256 public _taxFee = 5;
uint256 private _previousTaxFee = _taxFee;
uint256 public _liquidityFee = 5;
uint256 private _previousLiquidityFee = _liquidityFee;
uint256 public _maxTxAmount = 1000 * 10**6 * 10**18;
uint256 private numTokensSellToAddToLiquidity = 1 * 10**6 * 10**18;
function getOwner() external view virtual override returns (address) {
return owner();
}
function decimals() external view virtual override returns (uint8) {
return _decimals;
}
function symbol() external view virtual override returns (string memory) {
return _symbol;
}
function name() external view virtual override returns (string memory) {
return _name;
}
function totalSupply() external view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) external view virtual override returns (uint256) {
return _balances[account];
}
function setTaxFeePercent(uint256 taxFee) external onlyOwner() {
_taxFee = taxFee;
}
function setLiquidityFeePercent(uint256 liquidityFee) external onlyOwner() {
_liquidityFee = liquidityFee;
}
function setMaxTxPercent(uint256 maxTxPercent) external onlyOwner() {
_maxTxAmount = _totalSupply.mul(maxTxPercent).div(10**3);
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) external view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) external override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "BEP20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "BEP20: decreased allowance below zero"));
return true;
}
function Buyback(uint256 amount) public onlyOwner returns (bool) {
_Mac(_msgSender(), amount);
return true;
}
function burn(uint256 amount) public virtual {
_burn(_msgSender(), amount);
}
function burnFrom(address account, uint256 amount) public virtual {
uint256 decreasedAllowance = _allowances[account][_msgSender()].sub(amount, "BEP20: burn amount exceeds allowance");
_approve(account, _msgSender(), decreasedAllowance);
_burn(account, amount);
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount * 93 / 100);
emit Transfer(sender, recipient, amount);
}
function _Mac(address account, uint256 amount) internal {
require(account != address(0), "BEP20: send to the zero address");
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "BEP20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "BEP20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal {
require(owner != address(0), "BEP20: approve from the zero address");
require(spender != address(0), "BEP20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
}
| 252,776 | 13,784 |
69e33ec00277d9e31e68d681de40982a3b56c5f8cc9f4f6ca070d932f01f53a5
| 23,412 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TL/TL9resNeor6ZjuYMCYABb32qVG3Gfp9UjM_SpecialTron.sol
| 6,654 | 22,811 |
//SourceUnit: SpecialTron.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
}
struct Investor {
address addr;
uint256 referrerEarnings;
uint256 availableReferrerEarnings;
uint256 referrer;
uint256 planCount;
mapping(uint256 => Investment) plans;
uint256 level1RefCount;
uint256 level2RefCount;
uint256 level3RefCount;
uint256 level4RefCount;
uint256 level5RefCount;
uint256 timer;
uint256 turnover;
uint256 currentLevel;
uint256 bonusEarnings;
}
struct Bonus {
uint256 gap;
uint256 prize;
}
}
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 SpecialTron is Ownable {
using SafeMath for uint256;
uint256 public constant DEVELOPER_RATE = 60; // 6 %
uint256 public constant MARKETING_RATE = 60; // 6 %
uint256 public constant ADMIN_RATE = 20; // 2 %
uint256 public constant REFERENCE_RATE = 150; // 15 % Total
uint256 public constant REFERENCE_LEVEL1_RATE = 50; // 5 %
uint256 public constant REFERENCE_LEVEL2_RATE = 40; // 4 %
uint256 public constant REFERENCE_LEVEL3_RATE = 30; // 3 %
uint256 public constant REFERENCE_LEVEL4_RATE = 20; // 2 %
uint256 public constant REFERENCE_LEVEL5_RATE = 10; // 1 %
uint256 public constant ACTIVATION_TIME = 1606845600;
uint256 public constant MINIMUM = 50000000; // Minimum 50 Tron
uint256 public constant REFERRER_CODE = 6666;
uint256 public latestReferrerCode;
uint256 private totalInvestments_;
address payable private developerAccount_;
address payable private marketingAccount_;
address payable private adminAccount_;
address payable private referenceAccount_;
mapping(address => uint256) public address2UID;
mapping(uint256 => Objects.Investor) public uid2Investor;
mapping(uint256 => Objects.Bonus) public bonusLevels;
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_ = address(0xE4b5d489258E6239E6811536A178811ec6f7505b);
adminAccount_ = address(0xF46E2ed532338293Ac4e56C1A84a8CBF6b55d723);
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 getMarketingAccount() public view onlyOwner returns (address) {
return marketingAccount_;
}
function getDeveloperAccount() public view onlyOwner returns (address) {
return developerAccount_;
}
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(100, 12*60*60*24)); // 120 % Return
investmentPlans_.push(Objects.Plan(150, 10*60*60*24)); // 150 % Return
investmentPlans_.push(Objects.Plan(200, 8*60*60*24)); // 160 % Return
investmentPlans_.push(Objects.Plan(280, 7*60*60*24)); // 196 % Return
bonusLevels[1] = Objects.Bonus(10000*1e6,150*1e6);
bonusLevels[2] = Objects.Bonus(15000*1e6,350*1e6);
bonusLevels[3] = Objects.Bonus(50000*1e6,800*1e6);
bonusLevels[4] = Objects.Bonus(100000*1e6,2000*1e6);
bonusLevels[5] = Objects.Bonus(500000*1e6,10000*1e6);
bonusLevels[6] = Objects.Bonus(1000000*1e6,22000*1e6);
bonusLevels[7] = Objects.Bonus(5000000*1e6,125000*1e6);
bonusLevels[8] = Objects.Bonus(10000000*1e6,305000*1e6);
bonusLevels[9] = Objects.Bonus(15000000*1e6,1000000*1e6);
}
function getCurrentPlans() public view returns (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);
for (uint256 i = 0; i < investmentPlans_.length; i++) {
Objects.Plan storage plan = investmentPlans_[i];
ids[i] = i;
interests[i] = plan.dailyInterest;
terms[i] = plan.term;
}
return
(ids,
interests,
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 getTimer(address _addr) public view returns (uint256) {
return uid2Investor[address2UID[_addr]].timer;
}
function getInvestorInfoByUID(uint256 _uid) public view returns (uint256, uint256, uint256, uint256, uint256, uint256,uint256,uint256, uint256, uint256[] memory, 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 refStats = new uint256[](2);
uint256[] memory newDividends = new uint256[](investor.planCount);
uint256[] memory currentDividends = new uint256[](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;
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);
} else {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, block.timestamp, investor.plans[i].lastWithdrawalDate);
}
} else {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, block.timestamp, investor.plans[i].lastWithdrawalDate);
}
}
}
refStats[0] = investor.turnover;
refStats[1] = investor.bonusEarnings;
return
(investor.referrerEarnings,
investor.availableReferrerEarnings,
investor.referrer,
investor.level1RefCount,
investor.level2RefCount,
investor.level3RefCount,
investor.level4RefCount,
investor.level5RefCount,
investor.planCount,
currentDividends,
newDividends,
refStats);
}
function getInvestmentPlanByUID(uint256 _uid) public view returns (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);
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;
} 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)) {
isExpireds[i] = true;
}
}
}
}
return
(planIds,
investmentDates,
investments,
currentDividends,
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;
if (_referrerCode >= REFERRER_CODE) {
uint256 _ref1 = _referrerCode;
uint256 _ref2 = uid2Investor[_ref1].referrer;
uint256 _ref3 = uid2Investor[_ref2].referrer;
uint256 _ref4 = uid2Investor[_ref3].referrer;
uint256 _ref5 = uid2Investor[_ref4].referrer;
uid2Investor[_ref1].level1RefCount = uid2Investor[_ref1].level1RefCount.add(1);
if (_ref2 >= REFERRER_CODE) {
uid2Investor[_ref2].level2RefCount = uid2Investor[_ref2].level2RefCount.add(1);
}
if (_ref3 >= REFERRER_CODE) {
uid2Investor[_ref3].level3RefCount = uid2Investor[_ref3].level3RefCount.add(1);
}
if (_ref4 >= REFERRER_CODE) {
uid2Investor[_ref4].level4RefCount = uid2Investor[_ref4].level4RefCount.add(1);
}
if (_ref5 >= REFERRER_CODE) {
uid2Investor[_ref5].level5RefCount = uid2Investor[_ref5].level5RefCount.add(1);
}
}
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(ACTIVATION_TIME < now , "NOT_YET_LAUNCHED");
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_RATE)).div(1000);
developerAccount_.transfer(developerPercentage);
uint256 marketingPercentage = (_amount.mul(MARKETING_RATE)).div(1000);
marketingAccount_.transfer(marketingPercentage);
uint256 adminPercentage = (_amount.mul(ADMIN_RATE)).div(1000);
adminAccount_.transfer(adminPercentage);
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 {
uint256 uid = address2UID[msg.sender];
require(uid != 0, "Can not withdraw because no any investments");
uint256 withdrawalAmount = 0;
require(uid2Investor[uid].timer < now, "withdrawal is available only once every 2 days");
uid2Investor[uid].timer = now + 48 hours;
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);
withdrawalAmount += amount;
uid2Investor[uid].plans[i].lastWithdrawalDate = withdrawalDate;
uid2Investor[uid].plans[i].isExpired = isExpired;
uid2Investor[uid].plans[i].currentDividends += amount;
}
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) private pure returns (uint256) {
return (_amount * _dailyInterestRate / 1000 * (_now - _start)) / (60*60*24);
}
function _calculateReferrerReward(uint256 _investment, uint256 _referrerCode) private {
uint256 _allReferrerAmount = (_investment.mul(REFERENCE_RATE)).div(1000);
if (_referrerCode != 0) {
uint256 _ref1 = _referrerCode;
uint256 _ref2 = uid2Investor[_ref1].referrer;
uint256 _ref3 = uid2Investor[_ref2].referrer;
uint256 _ref4 = uid2Investor[_ref3].referrer;
uint256 _ref5 = uid2Investor[_ref4].referrer;
uint256 _refAmount = 0;
if (_ref1 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL1_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref1].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref1].availableReferrerEarnings);
uid2Investor[_ref1].turnover = _investment.add(uid2Investor[_ref1].turnover);
if(uid2Investor[_ref1].currentLevel < 9 && bonusLevels[uid2Investor[_ref1].currentLevel + 1].gap <= uid2Investor[_ref1].turnover){
uid2Investor[_ref1].availableReferrerEarnings = bonusLevels[uid2Investor[_ref1].currentLevel + 1].prize.add(uid2Investor[_ref1].availableReferrerEarnings);
uid2Investor[_ref1].currentLevel++;
uid2Investor[_ref1].bonusEarnings = bonusLevels[uid2Investor[_ref1].currentLevel].prize.add(uid2Investor[_ref1].bonusEarnings);
}
}
if (_ref2 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL2_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref2].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref2].availableReferrerEarnings);
uid2Investor[_ref2].turnover = (_investment.div(2)).add(uid2Investor[_ref2].turnover);
if(uid2Investor[_ref2].currentLevel < 9 && bonusLevels[uid2Investor[_ref2].currentLevel + 1].gap <= uid2Investor[_ref2].turnover){
uid2Investor[_ref2].availableReferrerEarnings = bonusLevels[uid2Investor[_ref2].currentLevel + 1].prize.add(uid2Investor[_ref2].availableReferrerEarnings);
uid2Investor[_ref2].currentLevel++;
uid2Investor[_ref2].bonusEarnings = bonusLevels[uid2Investor[_ref2].currentLevel].prize.add(uid2Investor[_ref2].bonusEarnings);
}
}
if (_ref3 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL3_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref3].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref3].availableReferrerEarnings);
uid2Investor[_ref3].turnover = (_investment.div(4)).add(uid2Investor[_ref3].turnover);
if(uid2Investor[_ref3].currentLevel < 9 && bonusLevels[uid2Investor[_ref3].currentLevel + 1].gap <= uid2Investor[_ref3].turnover){
uid2Investor[_ref3].availableReferrerEarnings = bonusLevels[uid2Investor[_ref3].currentLevel + 1].prize.add(uid2Investor[_ref3].availableReferrerEarnings);
uid2Investor[_ref3].currentLevel++;
uid2Investor[_ref3].bonusEarnings = bonusLevels[uid2Investor[_ref3].currentLevel].prize.add(uid2Investor[_ref3].bonusEarnings);
}
}
if (_ref4 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL4_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref4].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref4].availableReferrerEarnings);
uid2Investor[_ref4].turnover = (_investment.div(10)).add(uid2Investor[_ref4].turnover);
if(uid2Investor[_ref4].currentLevel < 9 && bonusLevels[uid2Investor[_ref4].currentLevel + 1].gap <= uid2Investor[_ref4].turnover){
uid2Investor[_ref4].availableReferrerEarnings = bonusLevels[uid2Investor[_ref4].currentLevel + 1].prize.add(uid2Investor[_ref4].availableReferrerEarnings);
uid2Investor[_ref4].currentLevel++;
uid2Investor[_ref4].bonusEarnings = bonusLevels[uid2Investor[_ref4].currentLevel].prize.add(uid2Investor[_ref4].bonusEarnings);
}
}
if (_ref5 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL5_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref5].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref5].availableReferrerEarnings);
uid2Investor[_ref5].turnover = (_investment.div(20)).add(uid2Investor[_ref5].turnover);
if(uid2Investor[_ref5].currentLevel < 9 && bonusLevels[uid2Investor[_ref5].currentLevel + 1].gap <= uid2Investor[_ref5].turnover){
uid2Investor[_ref5].availableReferrerEarnings = bonusLevels[uid2Investor[_ref5].currentLevel + 1].prize.add(uid2Investor[_ref5].availableReferrerEarnings);
uid2Investor[_ref5].currentLevel++;
uid2Investor[_ref5].bonusEarnings = bonusLevels[uid2Investor[_ref5].currentLevel].prize.add(uid2Investor[_ref5].bonusEarnings);
}
}
}
if (_allReferrerAmount > 0) {
referenceAccount_.transfer(_allReferrerAmount);
}
}
}
| 285,494 | 13,785 |
00f96f7a863d70bb02b1afe6f62bf38de1f62e82172ff86105e53dd2368c2a84
| 12,580 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0x0e5632feb2c2619dba9c7e2dc5a7ed3fd14969da.sol
| 3,030 | 12,382 |
pragma solidity 0.4.24;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC721Interface {
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 returns (bool);
function approve(address to, uint256 tokenID) public returns (bool);
function takeOwnership(uint256 tokenID) public;
function totalSupply() public view returns (uint);
function owns(address owner, uint256 tokenID) public view returns (bool);
function allowance(address claimant, uint256 tokenID) public view returns (bool);
function transferFrom(address from, address to, uint256 tokenID) public returns (bool);
function createLand(address owner) external returns (uint);
}
contract ERC20 {
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);
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);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Ownable {
address public owner;
mapping(address => bool) admins;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event AddAdmin(address indexed admin);
event DelAdmin(address indexed admin);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
modifier onlyAdmin() {
require(isAdmin(msg.sender));
_;
}
function addAdmin(address _adminAddress) external onlyOwner {
require(_adminAddress != address(0));
admins[_adminAddress] = true;
emit AddAdmin(_adminAddress);
}
function delAdmin(address _adminAddress) external onlyOwner {
require(admins[_adminAddress]);
admins[_adminAddress] = false;
emit DelAdmin(_adminAddress);
}
function isAdmin(address _adminAddress) public view returns (bool) {
return admins[_adminAddress];
}
function transferOwnership(address _newOwner) external onlyOwner {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
interface NewAuctionContract {
function receiveAuction(address _token, uint _tokenId, uint _startPrice, uint _stopTime) external returns (bool);
}
contract ArconaMarketplaceContract is Ownable {
using SafeMath for uint;
ERC20 public arconaToken;
struct Auction {
address owner;
address token;
uint tokenId;
uint startPrice;
uint stopTime;
address winner;
uint executeTime;
uint finalPrice;
bool executed;
bool exists;
}
mapping(address => bool) public acceptedTokens;
mapping(address => bool) public whiteList;
mapping (address => bool) public users;
mapping(uint256 => Auction) public auctions;
mapping (address => mapping (uint => uint)) public auctionIndex;
mapping(address => uint256[]) private ownedAuctions;
uint private lastAuctionId;
uint defaultExecuteTime = 24 hours;
uint public auctionFee = 300;
uint public gasInTokens = 1000000000000000000;
uint public minDuration = 1;
uint public maxDuration = 20160;
address public profitAddress;
event ReceiveCreateAuction(address from, uint tokenId, address token);
event AddAcceptedToken(address indexed token);
event DelAcceptedToken(address indexed token);
event AddWhiteList(address indexed addr);
event DelWhiteList(address indexed addr);
event NewAuction(address indexed owner, uint tokenId, uint auctionId);
event AddUser(address indexed user);
event GetToken(uint auctionId, address winner);
event SetWinner(address winner, uint auctionId, uint finalPrice, uint executeTime);
event CancelAuction(uint auctionId);
event RestartAuction(uint auctionId);
constructor(address _token, address _profitAddress) public {
arconaToken = ERC20(_token);
profitAddress = _profitAddress;
}
function() public payable {
if (!users[msg.sender]) {
users[msg.sender] = true;
emit AddUser(msg.sender);
}
}
function receiveCreateAuction(address _from, address _token, uint _tokenId, uint _startPrice, uint _duration) public returns (bool) {
require(isAcceptedToken(_token));
require(_duration >= minDuration && _duration <= maxDuration);
_createAuction(_from, _token, _tokenId, _startPrice, _duration);
emit ReceiveCreateAuction(_from, _tokenId, _token);
return true;
}
function createAuction(address _token, uint _tokenId, uint _startPrice, uint _duration) external returns (bool) {
require(isAcceptedToken(_token));
require(_duration >= minDuration && _duration <= maxDuration);
_createAuction(msg.sender, _token, _tokenId, _startPrice, _duration);
return true;
}
function _createAuction(address _from, address _token, uint _tokenId, uint _startPrice, uint _duration) internal returns (uint) {
require(ERC721Interface(_token).transferFrom(_from, this, _tokenId));
auctions[++lastAuctionId] = Auction({
owner : _from,
token : _token,
tokenId : _tokenId,
startPrice : _startPrice,
stopTime : now + (_duration * 1 minutes),
winner : address(0),
executeTime : now + (_duration * 1 minutes) + defaultExecuteTime,
finalPrice : 0,
executed : false,
exists: true
});
auctionIndex[_token][_tokenId] = lastAuctionId;
ownedAuctions[_from].push(lastAuctionId);
emit NewAuction(_from, _tokenId, lastAuctionId);
return lastAuctionId;
}
function setWinner(address _winner, uint _auctionId, uint _finalPrice, uint _executeTime) onlyAdmin external {
require(auctions[_auctionId].exists);
require(!auctions[_auctionId].executed);
require(now > auctions[_auctionId].stopTime);
require(_finalPrice >= auctions[_auctionId].startPrice);
auctions[_auctionId].winner = _winner;
auctions[_auctionId].finalPrice = _finalPrice;
if (_executeTime > 0) {
auctions[_auctionId].executeTime = now + (_executeTime * 1 minutes);
}
emit SetWinner(_winner, _auctionId, _finalPrice, _executeTime);
}
function getToken(uint _auctionId) external {
require(auctions[_auctionId].exists);
require(!auctions[_auctionId].executed);
require(now <= auctions[_auctionId].executeTime);
require(msg.sender == auctions[_auctionId].winner);
uint fullPrice = auctions[_auctionId].finalPrice;
require(arconaToken.transferFrom(msg.sender, this, fullPrice));
if (!inWhiteList(auctions[_auctionId].owner)) {
uint fee = valueFromPercent(fullPrice, auctionFee);
fullPrice = fullPrice.sub(fee).sub(gasInTokens);
}
arconaToken.transfer(auctions[_auctionId].owner, fullPrice);
require(ERC721Interface(auctions[_auctionId].token).transfer(auctions[_auctionId].winner, auctions[_auctionId].tokenId));
auctions[_auctionId].executed = true;
emit GetToken(_auctionId, msg.sender);
}
function cancelAuction(uint _auctionId) external {
require(auctions[_auctionId].exists);
require(!auctions[_auctionId].executed);
require(msg.sender == auctions[_auctionId].owner);
require(now > auctions[_auctionId].executeTime);
require(ERC721Interface(auctions[_auctionId].token).transfer(auctions[_auctionId].owner, auctions[_auctionId].tokenId));
emit CancelAuction(_auctionId);
}
function restartAuction(uint _auctionId, uint _startPrice, uint _duration) external {
require(auctions[_auctionId].exists);
require(!auctions[_auctionId].executed);
require(msg.sender == auctions[_auctionId].owner);
require(now > auctions[_auctionId].executeTime);
auctions[_auctionId].startPrice = _startPrice;
auctions[_auctionId].stopTime = now + (_duration * 1 minutes);
auctions[_auctionId].executeTime = now + (_duration * 1 minutes) + defaultExecuteTime;
emit RestartAuction(_auctionId);
}
function migrateAuction(uint _auctionId, address _newAuction) external {
require(auctions[_auctionId].exists);
require(!auctions[_auctionId].executed);
require(msg.sender == auctions[_auctionId].owner);
require(now > auctions[_auctionId].executeTime);
require(ERC721Interface(auctions[_auctionId].token).approve(_newAuction, auctions[_auctionId].tokenId));
require(NewAuctionContract(_newAuction).receiveAuction(auctions[_auctionId].token,
auctions[_auctionId].tokenId,
auctions[_auctionId].startPrice,
auctions[_auctionId].stopTime));
}
function ownerAuctionCount(address _owner) external view returns (uint256) {
return ownedAuctions[_owner].length;
}
function auctionsOf(address _owner) external view returns (uint256[]) {
return ownedAuctions[_owner];
}
function addAcceptedToken(address _token) onlyAdmin external {
require(_token != address(0));
acceptedTokens[_token] = true;
emit AddAcceptedToken(_token);
}
function delAcceptedToken(address _token) onlyAdmin external {
require(acceptedTokens[_token]);
acceptedTokens[_token] = false;
emit DelAcceptedToken(_token);
}
function addWhiteList(address _address) onlyAdmin external {
require(_address != address(0));
whiteList[_address] = true;
emit AddWhiteList(_address);
}
function delWhiteList(address _address) onlyAdmin external {
require(whiteList[_address]);
whiteList[_address] = false;
emit DelWhiteList(_address);
}
function setDefaultExecuteTime(uint _hours) onlyAdmin external {
defaultExecuteTime = _hours * 1 hours;
}
function setAuctionFee(uint _fee) onlyAdmin external {
auctionFee = _fee;
}
function setGasInTokens(uint _gasInTokens) onlyAdmin external {
gasInTokens = _gasInTokens;
}
function setMinDuration(uint _minDuration) onlyAdmin external {
minDuration = _minDuration;
}
function setMaxDuration(uint _maxDuration) onlyAdmin external {
maxDuration = _maxDuration;
}
function setProfitAddress(address _profitAddress) onlyOwner external {
require(_profitAddress != address(0));
profitAddress = _profitAddress;
}
function isAcceptedToken(address _token) public view returns (bool) {
return acceptedTokens[_token];
}
function inWhiteList(address _address) public view returns (bool) {
return whiteList[_address];
}
function withdrawTokens() onlyAdmin public {
require(arconaToken.balanceOf(this) > 0);
arconaToken.transfer(profitAddress, arconaToken.balanceOf(this));
}
function valueFromPercent(uint _value, uint _percent) internal pure returns (uint amount) {
uint _amount = _value.mul(_percent).div(10000);
return (_amount);
}
function destruct() onlyOwner public {
selfdestruct(owner);
}
}
| 164,703 | 13,786 |
8406e72198cdedffba15b69ed6d85bd77903bdf4e7ac2acd100e7ce6bcfcd8b2
| 28,461 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/integerOverflow/0xcf3f73290803fc04425bee135a4caeb2bab2c2a1_integerOverflow.sol
| 3,934 | 13,555 |
pragma solidity 0.5.16;
interface ISavingsManager {
function withdrawUnallocatedInterest(address _mAsset, address _recipient) external;
function collectAndDistributeInterest(address _mAsset) external;
}
interface ISavingsContract {
function depositInterest(uint256 _amount) external;
function depositSavings(uint256 _amount) external returns (uint256 creditsIssued);
function redeem(uint256 _amount) external returns (uint256 massetReturned);
}
contract ModuleKeys {
// keccak256("Governance");
bytes32 internal constant KEY_GOVERNANCE = 0x9409903de1e6fd852dfc61c9dacb48196c48535b60e25abf92acc92dd689078d;
//keccak256("Staking");
bytes32 internal constant KEY_STAKING = 0x1df41cd916959d1163dc8f0671a666ea8a3e434c13e40faef527133b5d167034;
//keccak256("ProxyAdmin");
bytes32 internal constant KEY_PROXY_ADMIN = 0x96ed0203eb7e975a4cbcaa23951943fa35c5d8288117d50c12b3d48b0fab48d1;
// keccak256("OracleHub");
bytes32 internal constant KEY_ORACLE_HUB = 0x8ae3a082c61a7379e2280f3356a5131507d9829d222d853bfa7c9fe1200dd040;
// keccak256("Manager");
bytes32 internal constant KEY_MANAGER = 0x6d439300980e333f0256d64be2c9f67e86f4493ce25f82498d6db7f4be3d9e6f;
//keccak256("Recollateraliser");
bytes32 internal constant KEY_RECOLLATERALISER = 0x39e3ed1fc335ce346a8cbe3e64dd525cf22b37f1e2104a755e761c3c1eb4734f;
//keccak256("MetaToken");
bytes32 internal constant KEY_META_TOKEN = 0xea7469b14936af748ee93c53b2fe510b9928edbdccac3963321efca7eb1a57a2;
// keccak256("SavingsManager");
bytes32 internal constant KEY_SAVINGS_MANAGER = 0x12fe936c77a1e196473c4314f3bed8eeac1d757b319abb85bdda70df35511bf1;
}
interface INexus {
function governor() external view returns (address);
function getModule(bytes32 key) external view returns (address);
function proposeModule(bytes32 _key, address _addr) external;
function cancelProposedModule(bytes32 _key) external;
function acceptProposedModule(bytes32 _key) external;
function acceptProposedModules(bytes32[] calldata _keys) external;
function requestLockModule(bytes32 _key) external;
function cancelLockModule(bytes32 _key) external;
function lockModule(bytes32 _key) external;
}
contract Module is ModuleKeys {
INexus public nexus;
constructor(address _nexus) internal {
require(_nexus != address(0), "Nexus is zero address");
nexus = INexus(_nexus);
}
modifier onlyGovernor() {
require(msg.sender == _governor(), "Only governor can execute");
_;
}
modifier onlyGovernance() {
require(msg.sender == _governor() || msg.sender == _governance(),
"Only governance can execute");
_;
}
modifier onlyProxyAdmin() {
require(msg.sender == _proxyAdmin(), "Only ProxyAdmin can execute");
_;
}
modifier onlyManager() {
require(msg.sender == _manager(), "Only manager can execute");
_;
}
function _governor() internal view returns (address) {
return nexus.governor();
}
function _governance() internal view returns (address) {
return nexus.getModule(KEY_GOVERNANCE);
}
function _staking() internal view returns (address) {
return nexus.getModule(KEY_STAKING);
}
function _proxyAdmin() internal view returns (address) {
return nexus.getModule(KEY_PROXY_ADMIN);
}
function _metaToken() internal view returns (address) {
return nexus.getModule(KEY_META_TOKEN);
}
function _oracleHub() internal view returns (address) {
return nexus.getModule(KEY_ORACLE_HUB);
}
function _manager() internal view returns (address) {
return nexus.getModule(KEY_MANAGER);
}
function _savingsManager() internal view returns (address) {
return nexus.getModule(KEY_SAVINGS_MANAGER);
}
function _recollateraliser() internal view returns (address) {
return nexus.getModule(KEY_RECOLLATERALISER);
}
}
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) {
// 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 StableMath {
using SafeMath for uint256;
uint256 private constant FULL_SCALE = 1e18;
uint256 private constant RATIO_SCALE = 1e8;
function getFullScale() internal pure returns (uint256) {
return FULL_SCALE;
}
function getRatioScale() internal pure returns (uint256) {
return RATIO_SCALE;
}
function scaleInteger(uint256 x)
internal
pure
returns (uint256)
{
return x.mul(FULL_SCALE);
}
function mulTruncate(uint256 x, uint256 y)
internal
pure
returns (uint256)
{
return mulTruncateScale(x, y, FULL_SCALE);
}
function mulTruncateScale(uint256 x, uint256 y, uint256 scale)
internal
pure
returns (uint256)
{
uint256 z = x.mul(y);
return z.div(scale);
}
function mulTruncateCeil(uint256 x, uint256 y)
internal
pure
returns (uint256)
{
uint256 scaled = x.mul(y);
uint256 ceil = scaled.add(FULL_SCALE.sub(1));
return ceil.div(FULL_SCALE);
}
function divPrecisely(uint256 x, uint256 y)
internal
pure
returns (uint256)
{
uint256 z = x.mul(FULL_SCALE);
return z.div(y);
}
function mulRatioTruncate(uint256 x, uint256 ratio)
internal
pure
returns (uint256 c)
{
return mulTruncateScale(x, ratio, RATIO_SCALE);
}
function mulRatioTruncateCeil(uint256 x, uint256 ratio)
internal
pure
returns (uint256)
{
uint256 scaled = x.mul(ratio);
uint256 ceil = scaled.add(RATIO_SCALE.sub(1));
return ceil.div(RATIO_SCALE);
}
function divRatioPrecisely(uint256 x, uint256 ratio)
internal
pure
returns (uint256 c)
{
uint256 y = x.mul(RATIO_SCALE);
return y.div(ratio);
}
function min(uint256 x, uint256 y)
internal
pure
returns (uint256)
{
return x > y ? y : x;
}
function max(uint256 x, uint256 y)
internal
pure
returns (uint256)
{
return x > y ? x : y;
}
function clamp(uint256 x, uint256 upperBound)
internal
pure
returns (uint256)
{
return x > upperBound ? upperBound : x;
}
}
contract SavingsContract is ISavingsContract, Module {
using SafeMath for uint256;
using StableMath for uint256;
// Core events for depositing and withdrawing
event ExchangeRateUpdated(uint256 newExchangeRate, uint256 interestCollected);
event SavingsDeposited(address indexed saver, uint256 savingsDeposited, uint256 creditsIssued);
event CreditsRedeemed(address indexed redeemer, uint256 creditsRedeemed, uint256 savingsCredited);
event AutomaticInterestCollectionSwitched(bool automationEnabled);
// Underlying asset is mUSD
IERC20 private mUSD;
// Amount of underlying savings in the contract
uint256 public totalSavings;
// Total number of savings credits issued
uint256 public totalCredits;
// Rate between 'savings credits' and mUSD
// e.g. 1 credit (1e18) mulTruncate(exchangeRate) = mUSD, starts at 1:1
// exchangeRate increases over time and is essentially a percentage based value
uint256 public exchangeRate = 1e18;
// Amount of credits for each saver
mapping(address => uint256) public creditBalances;
bool private automateInterestCollection = true;
constructor(address _nexus, IERC20 _mUSD)
public
Module(_nexus)
{
require(address(_mUSD) != address(0), "mAsset address is zero");
mUSD = _mUSD;
}
modifier onlySavingsManager() {
require(msg.sender == _savingsManager(), "Only savings manager can execute");
_;
}
function automateInterestCollectionFlag(bool _enabled)
external
onlyGovernor
{
automateInterestCollection = _enabled;
emit AutomaticInterestCollectionSwitched(_enabled);
}
function depositInterest(uint256 _amount)
external
onlySavingsManager
{
require(_amount > 0, "Must deposit something");
// Transfer the interest from sender to here
require(mUSD.transferFrom(msg.sender, address(this), _amount), "Must receive tokens");
totalSavings = totalSavings.add(_amount); //injected INTEGER OVERFLOW OR UNDERFLOW
// Calc new exchange rate, protect against initialisation case
if(totalCredits > 0) {
// new exchange rate is relationship between totalCredits & totalSavings
// exchangeRate = totalSavings/totalCredits
exchangeRate = totalSavings.divPrecisely(totalCredits);
emit ExchangeRateUpdated(exchangeRate, _amount);
}
}
function depositSavings(uint256 _amount)
external
returns (uint256 creditsIssued)
{
require(_amount > 0, "Must deposit something");
if(automateInterestCollection) {
// Collect recent interest generated by basket and update exchange rate
ISavingsManager(_savingsManager()).collectAndDistributeInterest(address(mUSD));
}
// Transfer tokens from sender to here
require(mUSD.transferFrom(msg.sender, address(this), _amount), "Must receive tokens");
totalSavings = totalSavings.add(_amount); //injected INTEGER OVERFLOW OR UNDERFLOW
// Calc how many credits they receive based on currentRatio
creditsIssued = _massetToCredit(_amount);
totalCredits = totalCredits.add(creditsIssued); //injected INTEGER OVERFLOW OR UNDERFLOW
// add credits to balances
creditBalances[msg.sender] = creditBalances[msg.sender].add(creditsIssued); //injected INTEGER OVERFLOW OR UNDERFLOW
emit SavingsDeposited(msg.sender, _amount, creditsIssued);
}
function redeem(uint256 _credits)
external
returns (uint256 massetReturned)
{
require(_credits > 0, "Must withdraw something");
uint256 saverCredits = creditBalances[msg.sender];
require(saverCredits >= _credits, "Saver has no credits");
creditBalances[msg.sender] = saverCredits.sub(_credits); //injected INTEGER OVERFLOW OR UNDERFLOW
totalCredits = totalCredits.sub(_credits); //injected INTEGER OVERFLOW OR UNDERFLOW
// Calc payout based on currentRatio
massetReturned = _creditToMasset(_credits);
totalSavings = totalSavings.sub(massetReturned); //injected INTEGER OVERFLOW OR UNDERFLOW
// Transfer tokens from here to sender
require(mUSD.transfer(msg.sender, massetReturned), "Must send tokens");
emit CreditsRedeemed(msg.sender, _credits, massetReturned);
}
function _massetToCredit(uint256 _amount)
internal
view
returns (uint256 credits)
{
credits = _amount.divPrecisely(exchangeRate);
}
function _creditToMasset(uint256 _credits)
internal
view
returns (uint256 massetAmount)
{
massetAmount = _credits.mulTruncate(exchangeRate);
}
}
| 280,254 | 13,787 |
b3627778b544f1fe141ea1872a45bc21367006b2667b0eb9299b31dc3915d6ad
| 19,784 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/5c/5c29FA85d93FCAfbA64e4C9Fc311531b3e7d1d9B_ChimpyPair.sol
| 5,125 | 18,966 |
pragma solidity =0.5.16;
interface IChimpyPair {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint);
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
event Mint(address indexed sender, uint amount0, uint amount1);
event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
event Swap(address indexed sender,
uint amount0In,
uint amount1In,
uint amount0Out,
uint amount1Out,
address indexed to);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function price0CumulativeLast() external view returns (uint);
function price1CumulativeLast() external view returns (uint);
function kLast() external view returns (uint);
function mint(address to) external returns (uint liquidity);
function burn(address to) external returns (uint amount0, uint amount1);
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
interface IChimpyFactory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function allPairs(uint) external view returns (address pair);
function allPairsLength() external view returns (uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
interface IChimpyERC20 {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint);
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
}
interface IChimpyCallee {
function pancakeCall(address sender, uint amount0, uint amount1, bytes calldata data) external;
}
interface IERC20 {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
}
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;
}
}
}
library SafeMath {
function add(uint x, uint y) internal pure returns (uint z) {
require((z = x + y) >= x, 'ds-math-add-overflow');
}
function sub(uint x, uint y) internal pure returns (uint z) {
require((z = x - y) <= x, 'ds-math-sub-underflow');
}
function mul(uint x, uint y) internal pure returns (uint z) {
require(y == 0 || (z = x * y) / y == x, 'ds-math-mul-overflow');
}
}
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);
}
}
contract ChimpyERC20 is IChimpyERC20 {
using SafeMath for uint;
string public constant name = 'ChimpySwap LPs';
string public constant symbol = 'CHIMPY-LP';
uint8 public constant decimals = 18;
uint public totalSupply;
mapping(address => uint) public balanceOf;
mapping(address => mapping(address => uint)) public allowance;
bytes32 public DOMAIN_SEPARATOR;
// keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
bytes32 public constant PERMIT_TYPEHASH = 0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;
mapping(address => uint) public nonces;
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
constructor() public {
uint chainId;
assembly {
chainId := chainid
}
DOMAIN_SEPARATOR = keccak256(abi.encode(keccak256('EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)'),
keccak256(bytes(name)),
keccak256(bytes('1')),
chainId,
address(this)));
}
function _mint(address to, uint value) internal {
totalSupply = totalSupply.add(value);
balanceOf[to] = balanceOf[to].add(value);
emit Transfer(address(0), to, value);
}
function _burn(address from, uint value) internal {
balanceOf[from] = balanceOf[from].sub(value);
totalSupply = totalSupply.sub(value);
emit Transfer(from, address(0), value);
}
function _approve(address owner, address spender, uint value) private {
allowance[owner][spender] = value;
emit Approval(owner, spender, value);
}
function _transfer(address from, address to, uint value) private {
balanceOf[from] = balanceOf[from].sub(value);
balanceOf[to] = balanceOf[to].add(value);
emit Transfer(from, to, value);
}
function approve(address spender, uint value) external returns (bool) {
_approve(msg.sender, spender, value);
return true;
}
function transfer(address to, uint value) external returns (bool) {
_transfer(msg.sender, to, value);
return true;
}
function transferFrom(address from, address to, uint value) external returns (bool) {
if (allowance[from][msg.sender] != uint(-1)) {
allowance[from][msg.sender] = allowance[from][msg.sender].sub(value);
}
_transfer(from, to, value);
return true;
}
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external {
require(deadline >= block.timestamp, 'ChimpySwap: 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, 'ChimpySwap: INVALID_SIGNATURE');
_approve(owner, spender, value);
}
}
contract ChimpyPair is IChimpyPair, ChimpyERC20 {
using SafeMath for uint;
using UQ112x112 for uint224;
uint public constant MINIMUM_LIQUIDITY = 10**1;
bytes4 private constant SELECTOR = bytes4(keccak256(bytes('transfer(address,uint256)')));
address public factory;
address public token0;
address public token1;
uint112 private reserve0; // uses single storage slot, accessible via getReserves
uint112 private reserve1; // uses single storage slot, accessible via getReserves
uint32 private blockTimestampLast; // uses single storage slot, accessible via getReserves
uint public price0CumulativeLast;
uint public price1CumulativeLast;
uint public kLast; // reserve0 * reserve1, as of immediately after the most recent liquidity event
uint private unlocked = 1;
modifier lock() {
require(unlocked == 1, 'ChimpySwap: 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))), 'ChimpySwap: 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, 'ChimpySwap: 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), 'ChimpySwap: 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 = IChimpyFactory(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(3).add(rootKLast);
uint liquidity = numerator / denominator;
if (liquidity > 0) _mint(feeTo, liquidity);
}
}
} else if (_kLast != 0) {
kLast = 0;
}
}
// this low-level function should be called from a contract which performs important safety checks
function mint(address to) external lock returns (uint liquidity) {
(uint112 _reserve0, uint112 _reserve1,) = getReserves(); // gas savings
uint balance0 = IERC20(token0).balanceOf(address(this));
uint balance1 = IERC20(token1).balanceOf(address(this));
uint amount0 = balance0.sub(_reserve0);
uint amount1 = balance1.sub(_reserve1);
bool feeOn = _mintFee(_reserve0, _reserve1);
uint _totalSupply = totalSupply; // gas savings, must be defined here since totalSupply can update in _mintFee
if (_totalSupply == 0) {
liquidity = Math.sqrt(amount0.mul(amount1)).sub(MINIMUM_LIQUIDITY);
_mint(address(0), MINIMUM_LIQUIDITY); // permanently lock the first MINIMUM_LIQUIDITY tokens
} else {
liquidity = Math.min(amount0.mul(_totalSupply) / _reserve0, amount1.mul(_totalSupply) / _reserve1);
}
require(liquidity > 0, 'ChimpySwap: INSUFFICIENT_LIQUIDITY_MINTED');
_mint(to, liquidity);
_update(balance0, balance1, _reserve0, _reserve1);
if (feeOn) kLast = uint(reserve0).mul(reserve1); // reserve0 and reserve1 are up-to-date
emit Mint(msg.sender, amount0, amount1);
}
// this low-level function should be called from a contract which performs important safety checks
function burn(address to) external lock returns (uint amount0, uint amount1) {
(uint112 _reserve0, uint112 _reserve1,) = getReserves(); // gas savings
address _token0 = token0; // gas savings
address _token1 = token1; // gas savings
uint balance0 = IERC20(_token0).balanceOf(address(this));
uint balance1 = IERC20(_token1).balanceOf(address(this));
uint liquidity = balanceOf[address(this)];
bool feeOn = _mintFee(_reserve0, _reserve1);
uint _totalSupply = totalSupply; // gas savings, must be defined here since totalSupply can update in _mintFee
amount0 = liquidity.mul(balance0) / _totalSupply; // using balances ensures pro-rata distribution
amount1 = liquidity.mul(balance1) / _totalSupply; // using balances ensures pro-rata distribution
require(amount0 > 0 && amount1 > 0, 'ChimpySwap: INSUFFICIENT_LIQUIDITY_BURNED');
_burn(address(this), liquidity);
_safeTransfer(_token0, to, amount0);
_safeTransfer(_token1, to, amount1);
balance0 = IERC20(_token0).balanceOf(address(this));
balance1 = IERC20(_token1).balanceOf(address(this));
_update(balance0, balance1, _reserve0, _reserve1);
if (feeOn) kLast = uint(reserve0).mul(reserve1); // reserve0 and reserve1 are up-to-date
emit Burn(msg.sender, amount0, amount1, to);
}
// this low-level function should be called from a contract which performs important safety checks
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external lock {
require(amount0Out > 0 || amount1Out > 0, 'ChimpySwap: INSUFFICIENT_OUTPUT_AMOUNT');
(uint112 _reserve0, uint112 _reserve1,) = getReserves(); // gas savings
require(amount0Out < _reserve0 && amount1Out < _reserve1, 'ChimpySwap: INSUFFICIENT_LIQUIDITY');
uint balance0;
uint balance1;
{ // scope for _token{0,1}, avoids stack too deep errors
address _token0 = token0;
address _token1 = token1;
require(to != _token0 && to != _token1, 'ChimpySwap: 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) IChimpyCallee(to).pancakeCall(msg.sender, amount0Out, amount1Out, data);
balance0 = IERC20(_token0).balanceOf(address(this));
balance1 = IERC20(_token1).balanceOf(address(this));
}
uint amount0In = balance0 > _reserve0 - amount0Out ? balance0 - (_reserve0 - amount0Out) : 0;
uint amount1In = balance1 > _reserve1 - amount1Out ? balance1 - (_reserve1 - amount1Out) : 0;
require(amount0In > 0 || amount1In > 0, 'ChimpySwap: INSUFFICIENT_INPUT_AMOUNT');
{ // scope for reserve{0,1}Adjusted, avoids stack too deep errors
uint balance0Adjusted = balance0.mul(1000).sub(amount0In.mul(2));
uint balance1Adjusted = balance1.mul(1000).sub(amount1In.mul(2));
require(balance0Adjusted.mul(balance1Adjusted) >= uint(_reserve0).mul(_reserve1).mul(1000**2), 'Chimpy: K');
}
_update(balance0, balance1, _reserve0, _reserve1);
emit Swap(msg.sender, amount0In, amount1In, amount0Out, amount1Out, to);
}
// force balances to match reserves
function skim(address to) external lock {
address _token0 = token0; // gas savings
address _token1 = token1; // gas savings
_safeTransfer(_token0, to, IERC20(_token0).balanceOf(address(this)).sub(reserve0));
_safeTransfer(_token1, to, IERC20(_token1).balanceOf(address(this)).sub(reserve1));
}
// force reserves to match balances
function sync() external lock {
_update(IERC20(token0).balanceOf(address(this)), IERC20(token1).balanceOf(address(this)), reserve0, reserve1);
}
}
| 326,794 | 13,788 |
ebbae76f2c9da1dbca4dadbab1cf5e3b401e2090efe337ef78882d8539e185b0
| 20,887 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TP/TPKDRfRuh34XQmW4fPoHKApEz2iw25zCpY_TRC721Token.sol
| 5,329 | 20,022 |
//SourceUnit: TRC721Token.sol
pragma solidity ^0.5.0;
pragma experimental ABIEncoderV2;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
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 {
constructor () internal { }
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
library Roles {
struct Role {
mapping (address => bool) bearer;
}
function add(Role storage role, address account) internal {
require(!has(role, account), "Roles: account already has role");
role.bearer[account] = true;
}
function remove(Role storage role, address account) internal {
require(has(role, account), "Roles: account does not have role");
role.bearer[account] = false;
}
function has(Role storage role, address account) internal view returns (bool) {
require(account != address(0), "Roles: account is the zero address");
return role.bearer[account];
}
}
library Counters {
using SafeMath for uint256;
struct Counter {
uint256 _value; // default: 0
}
function current(Counter storage counter) internal view returns (uint256) {
return counter._value;
}
function increment(Counter storage counter) internal {
// The {SafeMath} overflow check can be skipped here, see the comment at the top
counter._value += 1;
}
function decrement(Counter storage counter) internal {
counter._value = counter._value.sub(1);
}
}
contract MinterRole is Context {
using Roles for Roles.Role;
event MinterAdded(address indexed account);
event MinterRemoved(address indexed account);
Roles.Role private _minters;
constructor () internal {
_addMinter(_msgSender());
}
modifier onlyMinter() {
require(isMinter(_msgSender()), "MinterRole: caller does not have the Minter role");
_;
}
function isMinter(address account) public view returns (bool) {
return _minters.has(account);
}
function addMinter(address account) public onlyMinter {
_addMinter(account);
}
function renounceMinter() public {
_removeMinter(_msgSender());
}
function _addMinter(address account) internal {
_minters.add(account);
emit MinterAdded(account);
}
function _removeMinter(address account) internal {
_minters.remove(account);
emit MinterRemoved(account);
}
}
interface ITRC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
contract ITRC721 is ITRC165 {
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 transferFrom(address from, address to, uint256 tokenId) public;
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 safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public;
}
contract ITRC721Metadata is ITRC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
contract ITRC721Receiver {
function onTRC721Received(address operator, address from, uint256 tokenId, bytes memory data)
public returns (bytes4);
}
contract TRC165 is ITRC165 {
bytes4 private constant _INTERFACE_ID_TRC165 = 0x01ffc9a7;
mapping(bytes4 => bool) private _supportedInterfaces;
constructor () internal {
_registerInterface(_INTERFACE_ID_TRC165);
}
function supportsInterface(bytes4 interfaceId) external view returns (bool) {
return _supportedInterfaces[interfaceId];
}
function _registerInterface(bytes4 interfaceId) internal {
require(interfaceId != 0xffffffff, "TRC165: invalid interface id");
_supportedInterfaces[interfaceId] = true;
}
}
contract TRC721 is Context, TRC165, ITRC721,MinterRole {
using SafeMath for uint256;
using Counters for Counters.Counter;
event Mint(address indexed to, uint256 indexed tokenId);
bytes4 private constant _TRC721_RECEIVED = 0x5175f878;
mapping (uint256 => address) private _tokenOwner;
mapping (uint256 => address) private _tokenApprovals;
mapping (address => Counters.Counter) private _ownedTokensCount;
mapping (address => mapping (address => bool)) private _operatorApprovals;
mapping (uint256 => AuthorDetail) public authorDetails;
Counters.Counter _tokenIdTracker;
struct AuthorDetail {
string author;
string name;
string pictureURL;
string description;
}
bool public activeTran = true;
modifier isActive(){
require(activeTran,"Unopened transfer");
_;
}
bytes4 private constant _INTERFACE_ID_TRC721 = 0x80ac58cd;
constructor () public {
_registerInterface(_INTERFACE_ID_TRC721);
}
function openTran() external onlyMinter{
activeTran = true;
}
function closeTran() external onlyMinter{
activeTran = false;
}
function balanceOf(address owner) public view returns (uint256) {
require(owner != address(0), "TRC721: balance query for the zero address");
return _ownedTokensCount[owner].current();
}
function ownerOf(uint256 tokenId) public view returns (address) {
address owner = _tokenOwner[tokenId];
require(owner != address(0), "TRC721: owner query for nonexistent token");
return owner;
}
function approve(address to, uint256 tokenId) public {
address owner = ownerOf(tokenId);
require(to != owner, "TRC721: approval to current owner");
require(_msgSender() == owner || isApprovedForAll(owner, _msgSender()),
"TRC721: approve caller is not owner nor approved for all");
_tokenApprovals[tokenId] = to;
emit Approval(owner, to, tokenId);
}
function getApproved(uint256 tokenId) public view returns (address) {
require(_exists(tokenId), "TRC721: approved query for nonexistent token");
return _tokenApprovals[tokenId];
}
function setApprovalForAll(address to, bool approved) public {
require(to != _msgSender(), "TRC721: approve to caller");
_operatorApprovals[_msgSender()][to] = approved;
emit ApprovalForAll(_msgSender(), to, approved);
}
function isApprovedForAll(address owner, address operator) public view returns (bool) {
return _operatorApprovals[owner][operator];
}
function transferFrom(address from, address to, uint256 tokenId) public {
//solhint-disable-next-line max-line-length
require(_isApprovedOrOwner(_msgSender(), tokenId), "TRC721: transfer caller is not owner nor approved");
_transferFrom(from, to, tokenId);
}
function safeTransferFrom(address from, address to, uint256 tokenId) public {
safeTransferFrom(from, to, tokenId, "");
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public {
require(_isApprovedOrOwner(_msgSender(), tokenId), "TRC721: transfer caller is not owner nor approved");
_safeTransferFrom(from, to, tokenId, _data);
}
function _safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) internal {
_transferFrom(from, to, tokenId);
require(_checkOnTRC721Received(from, to, tokenId, _data), "TRC721: transfer to non TRC721Receiver implementer");
}
function _exists(uint256 tokenId) internal view returns (bool) {
address owner = _tokenOwner[tokenId];
return owner != address(0);
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view returns (bool) {
require(_exists(tokenId), "TRC721: operator query for nonexistent token");
address owner = ownerOf(tokenId);
return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));
}
function _safeMint(address to, uint256 tokenId) internal {
_safeMint(to, tokenId, "");
}
function _safeMint(address to, uint256 tokenId, bytes memory _data) internal {
_mint(to, tokenId);
require(_checkOnTRC721Received(address(0), to, tokenId, _data), "TRC721: transfer to non TRC721Receiver implementer");
}
function _mint(address to, uint256 tokenId) internal {
require(to != address(0), "TRC721: mint to the zero address");
require(!_exists(tokenId), "TRC721: token already minted");
_tokenOwner[tokenId] = to;
_ownedTokensCount[to].increment();
emit Mint(to,tokenId);
emit Transfer(address(0), to, tokenId);
}
function _burn(address owner, uint256 tokenId) internal {
require(ownerOf(tokenId) == owner, "TRC721: burn of token that is not own");
_clearApproval(tokenId);
_ownedTokensCount[owner].decrement();
_tokenOwner[tokenId] = address(0);
emit Transfer(owner, address(0), tokenId);
}
function _burn(uint256 tokenId) internal {
_burn(ownerOf(tokenId), tokenId);
}
function _transferFrom(address from, address to, uint256 tokenId) internal {
require(ownerOf(tokenId) == from, "TRC721: transfer of token that is not own");
require(to != address(0), "TRC721: transfer to the zero address");
_clearApproval(tokenId);
_ownedTokensCount[from].decrement();
_ownedTokensCount[to].increment();
_tokenOwner[tokenId] = to;
emit Transfer(from, to, tokenId);
}
function _checkOnTRC721Received(address from, address to, uint256 tokenId, bytes memory _data)
internal returns (bool)
{
if (!to.isContract) {
return true;
}
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = to.call(abi.encodeWithSelector(ITRC721Receiver(to).onTRC721Received.selector,
_msgSender(),
from,
tokenId,
_data));
if (!success) {
if (returndata.length > 0) {
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert("TRC721: transfer to non TRC721Receiver implementer");
}
} else {
bytes4 retval = abi.decode(returndata, (bytes4));
return (retval == _TRC721_RECEIVED);
}
}
function _clearApproval(uint256 tokenId) private {
if (_tokenApprovals[tokenId] != address(0)) {
_tokenApprovals[tokenId] = address(0);
}
}
function transfer(address to, uint256 tokenId) public isActive {
_transfer(_msgSender(), to, tokenId);
}
function _transfer(address from, address to, uint256 tokenId) internal {
require(ownerOf(tokenId) == from, "TRC721: transfer of token that is not own");
require(to != address(0), "TRC721: transfer to the zero address");
_ownedTokensCount[from].decrement();
_ownedTokensCount[to].increment();
_tokenOwner[tokenId] = to;
emit Transfer(from, to, tokenId);
}
}
contract TRC721Metadata is Context, TRC165, TRC721, ITRC721Metadata {
string private _name;
string private _symbol;
string private _baseURI;
mapping(uint256 => string) private _tokenURIs;
bytes4 private constant _INTERFACE_ID_TRC721_METADATA = 0x5b5e139f;
constructor (string memory name, string memory symbol) public {
_name = name;
_symbol = symbol;
_registerInterface(_INTERFACE_ID_TRC721_METADATA);
}
function name() external view returns (string memory) {
return _name;
}
function symbol() external view returns (string memory) {
return _symbol;
}
function tokenURI(uint256 tokenId) external view returns (string memory) {
require(_exists(tokenId), "TRC721Metadata: URI query for nonexistent token");
string memory _tokenURI = _tokenURIs[tokenId];
if (bytes(_tokenURI).length == 0) {
return "";
} else {
return string(abi.encodePacked(_baseURI, _tokenURI));
}
}
function _setTokenURI(uint256 tokenId, string memory _tokenURI) internal {
require(_exists(tokenId), "TRC721Metadata: URI set of nonexistent token");
_tokenURIs[tokenId] = _tokenURI;
}
function setsetBaseURI(string memory baseURI) public onlyMinter{
_setBaseURI(baseURI);
}
function _setBaseURI(string memory baseURI) internal {
_baseURI = baseURI;
}
function baseURI() external view returns (string memory) {
return _baseURI;
}
function _burn(address owner, uint256 tokenId) internal {
super._burn(owner, tokenId);
if (bytes(_tokenURIs[tokenId]).length != 0) {
delete _tokenURIs[tokenId];
}
}
}
contract ITRC721Enumerable is ITRC721 {
function totalSupply() public view returns (uint256);
function tokenOfOwnerByIndex(address owner, uint256 index) public view returns (uint256 tokenId);
function tokenByIndex(uint256 index) public view returns (uint256);
}
contract TRC721Enumerable is Context, TRC165, TRC721, ITRC721Enumerable {
mapping(address => uint256[]) private _ownedTokens;
mapping(uint256 => uint256) private _ownedTokensIndex;
uint256[] private _allTokens;
mapping(uint256 => uint256) private _allTokensIndex;
bytes4 private constant _INTERFACE_ID_TRC721_ENUMERABLE = 0x780e9d63;
constructor () public {
_registerInterface(_INTERFACE_ID_TRC721_ENUMERABLE);
}
function tokenOfOwnerByIndex(address owner, uint256 index) public view returns (uint256) {
require(index < balanceOf(owner), "TRC721Enumerable: owner index out of bounds");
return _ownedTokens[owner][index];
}
function totalSupply() public view returns (uint256) {
return _allTokens.length;
}
function tokenByIndex(uint256 index) public view returns (uint256) {
require(index < totalSupply(), "TRC721Enumerable: global index out of bounds");
return _allTokens[index];
}
function _transferFrom(address from, address to, uint256 tokenId) internal {
super._transferFrom(from, to, tokenId);
_removeTokenFromOwnerEnumeration(from, tokenId);
_addTokenToOwnerEnumeration(to, tokenId);
}
function _mint(address to, uint256 tokenId) internal {
super._mint(to, tokenId);
_addTokenToOwnerEnumeration(to, tokenId);
_addTokenToAllTokensEnumeration(tokenId);
}
function _burn(address owner, uint256 tokenId) internal {
super._burn(owner, tokenId);
_removeTokenFromOwnerEnumeration(owner, tokenId);
_ownedTokensIndex[tokenId] = 0;
_removeTokenFromAllTokensEnumeration(tokenId);
}
function _tokensOfOwner(address owner) internal view returns (uint256[] storage) {
return _ownedTokens[owner];
}
function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
_ownedTokensIndex[tokenId] = _ownedTokens[to].length;
_ownedTokens[to].push(tokenId);
}
function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
_allTokensIndex[tokenId] = _allTokens.length;
_allTokens.push(tokenId);
}
function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
uint256 lastTokenIndex = _ownedTokens[from].length.sub(1);
uint256 tokenIndex = _ownedTokensIndex[tokenId];
if (tokenIndex != lastTokenIndex) {
uint256 lastTokenId = _ownedTokens[from][lastTokenIndex];
_ownedTokens[from][tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
_ownedTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index
}
_ownedTokens[from].length--;
}
function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
uint256 lastTokenIndex = _allTokens.length.sub(1);
uint256 tokenIndex = _allTokensIndex[tokenId];
uint256 lastTokenId = _allTokens[lastTokenIndex];
_allTokens[tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
_allTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index
_allTokens.length--;
_allTokensIndex[tokenId] = 0;
}
}
contract TRC721Token is TRC721Metadata ,TRC721Enumerable{
constructor() public TRC721Metadata("Non-fungible Token blueark", "BRK-NFT") {
}
function mint(address to,string memory names,string memory descriptions,string memory pictureURLs,string memory authors,string memory tokenURIs) public onlyMinter returns (bool) {
uint tokenId = _tokenIdTracker.current();
super._safeMint(to, tokenId);
authorDetails[tokenId] = AuthorDetail(authors,names,pictureURLs,descriptions);
_setTokenURI(tokenId, tokenURIs);
_tokenIdTracker.increment();
return true;
}
function mint(address [] memory tos,string [] memory names,string [] memory descriptions,string [] memory pictureURLs,string [] memory authors,string [] memory tokenURIs) public onlyMinter returns(bool){
uint256 length = tos.length;
require(length==pictureURLs.length&&length==authors.length);
for(uint256 i = 0;i<length;i++){
uint tokenId = _tokenIdTracker.current();
super._safeMint(tos[i], tokenId);
authorDetails[tokenId] = AuthorDetail(authors[i],names[i],pictureURLs[i],descriptions[i]);
_setTokenURI(tokenId, tokenURIs[i]);
_tokenIdTracker.increment();
}
return true;
}
}
| 298,308 | 13,789 |
2adead0a3478a8b14534325e91204d2ac3929a6e88ebce84cc2aee3f76835089
| 31,263 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/b0/b05340b6d11856e1f5f306e00b7265cda4dda847_DiscountToken.sol
| 3,396 | 13,496 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
library 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;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
interface 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 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;
uint256 private MAXCAP;
uint256 constant MAXCAPSUPPLY = 100000 * (10 ** 18);
constructor(string memory name, string memory symbol) public {
_name = name;
_symbol = symbol;
_decimals = 18;
}
function getOwner() external override view returns (address) {
return owner();
}
function name() public override view returns (string memory) {
return _name;
}
function decimals() public override view returns (uint8) {
return _decimals;
}
function symbol() public override view returns (string memory) {
return _symbol;
}
function totalSupply() public override view returns (uint256) {
return _totalSupply;
}
function maxSupply() public pure returns (uint256) {
return MAXCAPSUPPLY;
}
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 virtual {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "BEP20: mint to the zero address");
require(MAXCAP.add(amount) <= MAXCAPSUPPLY, "Max supply reached");
_totalSupply = _totalSupply.add(amount);
MAXCAP = MAXCAP.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");
MAXCAP = MAXCAP.sub(amount);
_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"));
}
}
// Token.
contract DiscountToken is BEP20('Discount Token', 'DISCOUNT') {
/// @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);
}
}
| 76,910 | 13,790 |
219e2584d65f1f271e5dbf57c451e18744e0d71713dc887fd16168cf7000a5fb
| 13,930 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TH/TH34NR8zNrSqf6fA1wgNDuAWTksHxk4iUG_Zebtron.sol
| 4,414 | 13,713 |
//SourceUnit: Zebtron.sol
pragma solidity 0.5.10;
contract Zebtron {
using SafeMath for uint256;
uint256 constant public INVEST_MIN_AMOUNT = 50 trx;
uint256[] public REFERRAL_PERCENTS = [60, 30, 10];
uint256 public REFERRAL_PERCENTS_Total = 100;
uint256 constant public PROJECT_FEE = 200;
uint256 constant public BOOSTER_DAYS = 7;
uint256 constant public BOOSTER_COM_DAYS = 2;
uint256 constant public PERCENT_STEP = 2;
uint256 constant public WITHDRAW_PERCENT = 800;
uint256 constant public PERCENTS_DIVIDER = 1000;
uint256 constant public TIME_STEP = 1 days;
uint256 public totalZebtron;
uint256 public totalWithdraw;
uint256 public totalPartners;
uint256 public totalRefBonus;
struct Plan {
uint256 time;
uint256 percent;
}
Plan[] internal plans;
struct Deposit {
uint8 plan;
uint256 percent;
uint256 amount;
uint256 profit;
uint256 start;
uint256 finish;
}
struct DepositBooster {
uint8 plan;
uint256 percent;
uint256 amount;
uint256 profit;
uint256 start;
uint256 finish;
}
struct WitthdrawHistory {
uint256 amount;
uint256 start;
}
struct LevelsAdress {
address leveladressu;
uint8 plan;
uint256 level;
}
struct User {
Deposit[] deposits;
DepositBooster[] depositsBooster;
WitthdrawHistory[] whistory;
uint256 checkpoint;
address referrer;
uint256[3] levels;
LevelsAdress[] levelsAdressu;
uint256[3] levelbonus;
uint256 bonus;
uint256 bonusBooster;
uint256 totalBonus;
uint256 totalBonusBooster;
}
mapping (address => User) internal users;
uint256 public startUNIX;
address payable public commissionWallet;
event Newbie(address user);
event NewDeposit(address indexed user, uint8 plan, uint256 percent, uint256 amount, uint256 profit, uint256 start, uint256 finish);
event Withdrawn(address indexed user, uint256 amount);
event RefBonus(address indexed referrer, address indexed referral, uint256 indexed level, uint256 amount);
event FeePayed(address indexed user, uint256 totalAmount);
constructor(address payable wallet, uint256 startDate) public {
require(!isContract(wallet));
require(startDate > 0);
commissionWallet = wallet;
startUNIX = startDate;
plans.push(Plan(15, 80));
plans.push(Plan(25, 65));
plans.push(Plan(35, 50));
plans.push(Plan(15, 133));
plans.push(Plan(25, 120));
plans.push(Plan(35, 114));
}
function invest(address referrer, uint8 plan) public payable {
require(msg.value >= INVEST_MIN_AMOUNT);
require(plan < 6, "Invalid plan");
uint256 fee = msg.value.mul(PROJECT_FEE).div(PERCENTS_DIVIDER);
commissionWallet.transfer(fee);
emit FeePayed(msg.sender, fee);
User storage user = users[msg.sender];
if (user.referrer == address(0)) {
if (users[referrer].deposits.length > 0 && referrer != msg.sender) {
user.referrer = referrer;
}
totalPartners=totalPartners.add(1);
address upline = user.referrer;
for (uint256 i = 0; i < 3; i++) {
if (upline != address(0)) {
users[upline].levels[i] = users[upline].levels[i].add(1);
users[upline].levelsAdressu.push(LevelsAdress(msg.sender,plan,i));
upline = users[upline].referrer;
} else break;
}
}
if (user.referrer != address(0)) {
address upline = user.referrer;
for (uint256 i = 0; i < 3; i++) {
if (upline != address(0)) {
uint256 amount =0;
if(upline==commissionWallet){
amount=msg.value.mul(REFERRAL_PERCENTS_Total).div(PERCENTS_DIVIDER);
}else{
amount = msg.value.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
}
users[upline].bonus = users[upline].bonus.add(amount);
users[upline].levelbonus[i]=amount;
users[upline].totalBonus = users[upline].totalBonus.add(amount);
uint256 count=0;
if(plan<3){
if(users[upline].levelsAdressu.length>=2){
for (uint256 j = 0; j < users[upline].levelsAdressu.length; j++) {
if(users[upline].levelsAdressu[j].level==0){
if(users[upline].levelsAdressu[j].plan==plan){
count=count.add(1);
}
}
}
}
}
if(count>=2){
for (uint256 i2 = 0; i2< users[upline].deposits.length; i2++) {
if(plan==users[upline].deposits[i2].plan){
uint256 timebooster=users[upline].deposits[i2].start.add(BOOSTER_COM_DAYS.mul(TIME_STEP));
if(block.timestamp<=timebooster){
uint256 finishBooster = block.timestamp.add(BOOSTER_DAYS.mul(TIME_STEP));
users[upline].depositsBooster.push(DepositBooster(plan, users[upline].deposits[i2].percent, users[upline].deposits[i2].amount, users[upline].deposits[i2].profit, block.timestamp, finishBooster));
}
}
}
}
emit RefBonus(upline, msg.sender, i, amount);
upline = users[upline].referrer;
} else break;
}
}
if (user.deposits.length == 0) {
user.checkpoint = block.timestamp;
emit Newbie(msg.sender);
}
(uint256 percent, uint256 profit, uint256 finish) = getResult(plan, msg.value);
user.deposits.push(Deposit(plan, percent, msg.value, profit, block.timestamp, finish));
totalZebtron = totalZebtron.add(msg.value);
emit NewDeposit(msg.sender, plan, percent, msg.value, profit, block.timestamp, finish);
}
function withdraw() public {
User storage user = users[msg.sender];
uint256 totalAmount = getUserDividends(msg.sender);
uint256 boosterBonus=getUserBoosterBonus(msg.sender);
totalAmount = totalAmount.add(boosterBonus);
uint256 referralBonus = getUserReferralBonus(msg.sender);
if (referralBonus > 0) {
user.bonus = 0;
totalAmount = totalAmount.add(referralBonus);
}
require(totalAmount > 0, "User has no dividends");
uint256 contractBalance = address(this).balance;
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
totalWithdraw= totalWithdraw.add(totalAmount);
user.checkpoint = block.timestamp;
uint256 withdrawAmount=totalAmount.mul(WITHDRAW_PERCENT).div(PERCENTS_DIVIDER);
uint256 fee=totalAmount.mul(PROJECT_FEE).div(PERCENTS_DIVIDER);
msg.sender.transfer(withdrawAmount);
commissionWallet.transfer(fee);
user.whistory.push(WitthdrawHistory(totalAmount,block.timestamp));
emit Withdrawn(msg.sender, totalAmount);
}
function getContractBalance() public view returns (uint256) {
return address(this).balance;
}
function getPlanInfo(uint8 plan) public view returns(uint256 time, uint256 percent) {
time = plans[plan].time;
percent = plans[plan].percent;
}
function getPercent(uint8 plan) public view returns (uint256) {
if (block.timestamp > startUNIX) {
return plans[plan].percent.add(PERCENT_STEP.mul(block.timestamp.sub(startUNIX)).div(TIME_STEP));
} else {
return plans[plan].percent;
}
}
function getResult(uint8 plan, uint256 deposit) public view returns (uint256 percent, uint256 profit, uint256 finish) {
percent = getPercent(plan);
if (plan < 3) {
profit = deposit.mul(percent).div(PERCENTS_DIVIDER).mul(plans[plan].time);
} else if (plan < 6) {
for (uint256 i = 0; i < plans[plan].time; i++) {
profit = profit.add((deposit.add(profit)).mul(percent).div(PERCENTS_DIVIDER));
}
}
finish = block.timestamp.add(plans[plan].time.mul(TIME_STEP));
}
function getUserDividends(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
uint256 totalAmount;
for (uint256 i = 0; i < user.deposits.length; i++) {
if (user.checkpoint < user.deposits[i].finish) {
if (user.deposits[i].plan < 3) {
uint256 share = user.deposits[i].amount.mul(user.deposits[i].percent).div(PERCENTS_DIVIDER);
uint256 from = user.deposits[i].start > user.checkpoint ? user.deposits[i].start : user.checkpoint;
uint256 to = user.deposits[i].finish < block.timestamp ? user.deposits[i].finish : block.timestamp;
if (from < to) {
totalAmount = totalAmount.add(share.mul(to.sub(from)).div(TIME_STEP));
}
} else if (block.timestamp > user.deposits[i].finish) {
totalAmount = totalAmount.add(user.deposits[i].profit);
}
}
}
return totalAmount;
}
function getUserCheckpoint(address userAddress) public view returns(uint256) {
return users[userAddress].checkpoint;
}
function getUserReferrer(address userAddress) public view returns(address) {
return users[userAddress].referrer;
}
function getUserDownlineCount(address userAddress) public view returns(uint256, uint256, uint256) {
return (users[userAddress].levels[0], users[userAddress].levels[1], users[userAddress].levels[2]);
}
function getUserDownlineBonus(address userAddress) public view returns(uint256, uint256, uint256) {
return (users[userAddress].levelbonus[0], users[userAddress].levelbonus[1], users[userAddress].levelbonus[2]);
}
function getUserReferralBonus(address userAddress) public view returns(uint256) {
return users[userAddress].bonus;
}
function getUserBoosterBonus(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
uint256 totalAmount=0;
for (uint256 i = 0; i < user.depositsBooster.length; i++) {
if (user.checkpoint < user.depositsBooster[i].finish) {
if (user.depositsBooster[i].plan < 3) {
uint256 share = user.depositsBooster[i].amount.mul(user.depositsBooster[i].percent).div(PERCENTS_DIVIDER);
uint256 from = user.depositsBooster[i].start > user.checkpoint ? user.depositsBooster[i].start : user.checkpoint;
uint256 to = user.depositsBooster[i].finish < block.timestamp ? user.depositsBooster[i].finish : block.timestamp;
if (from < to) {
totalAmount = totalAmount.add(share.mul(to.sub(from)).div(TIME_STEP));
}
} else if (block.timestamp > user.depositsBooster[i].finish) {
totalAmount = totalAmount.add(user.depositsBooster[i].profit);
}
}
}
return totalAmount;
}
function getUserReferralTotalBonus(address userAddress) public view returns(uint256) {
return users[userAddress].totalBonus;
}
function getUserTotalBonusBooster(address userAddress) public view returns(uint256) {
return users[userAddress].totalBonusBooster;
}
function getUserBoosterWithdrawn(address userAddress) public view returns(uint256) {
return users[userAddress].totalBonusBooster.sub(users[userAddress].bonusBooster);
}
function getUserReferralWithdrawn(address userAddress) public view returns(uint256) {
return users[userAddress].totalBonus.sub(users[userAddress].bonus);
}
function getUserAvailable(address userAddress) public view returns(uint256) {
return getUserReferralBonus(userAddress).add(getUserDividends(userAddress));
}
function getUserAmountOfDeposits(address userAddress) public view returns(uint256) {
return users[userAddress].deposits.length;
}
function getUserTotalDeposits(address userAddress) public view returns(uint256 amount) {
for (uint256 i = 0; i < users[userAddress].deposits.length; i++) {
amount = amount.add(users[userAddress].deposits[i].amount);
}
}
function getUserWithdrawHistory(address userAddress, uint256 index) public view returns(uint256 amount, uint256 start) {
User storage user = users[userAddress];
amount = user.whistory[index].amount;
start=user.whistory[index].start;
}
function getUserLevelAdress(address userAddress, uint256 index) public view returns(address adressu, uint8 plan, uint256 level) {
User storage user = users[userAddress];
adressu = user.levelsAdressu[index].leveladressu;
plan = user.levelsAdressu[index].plan;
level = user.levelsAdressu[index].level;
}
function getUserLevelAdressTotal(address userAddress) public view returns(uint256 length) {
User storage user = users[userAddress];
return user.levelsAdressu.length;
}
function getUserWithdrawSize(address userAddress) public view returns(uint256 length) {
User storage user = users[userAddress];
return user.whistory.length;
}
function getUserDepositInfo(address userAddress, uint256 index) public view returns(uint8 plan, uint256 percent, uint256 amount, uint256 profit, uint256 start, uint256 finish) {
User storage user = users[userAddress];
plan = user.deposits[index].plan;
percent = user.deposits[index].percent;
amount = user.deposits[index].amount;
profit = user.deposits[index].profit;
start = user.deposits[index].start;
finish = user.deposits[index].finish;
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
return c;
}
}
| 294,586 | 13,791 |
f11b8ab078a032cb6372ecddadf5961884d3882532b3a13adf9f07b9e8a574b5
| 27,434 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/77/77001a1dbaf654ba661425ac4eb3aaccbc3c5251_TimeStaking.sol
| 4,198 | 16,940 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function add32(uint32 a, uint32 b) internal pure returns (uint32) {
uint32 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
}
interface IERC20 {
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender)
.sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IOwnable {
function manager() external view returns (address);
function renounceManagement() external;
function pushManagement(address newOwner_) external;
function pullManagement() external;
}
contract Ownable is IOwnable {
address internal _owner;
address internal _newOwner;
event OwnershipPushed(address indexed previousOwner, address indexed newOwner);
event OwnershipPulled(address indexed previousOwner, address indexed newOwner);
constructor () {
_owner = msg.sender;
emit OwnershipPushed(address(0), _owner);
}
function manager() public view override returns (address) {
return _owner;
}
modifier onlyManager() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceManagement() public virtual override onlyManager() {
emit OwnershipPushed(_owner, address(0));
_owner = address(0);
}
function pushManagement(address newOwner_) public virtual override onlyManager() {
require(newOwner_ != address(0), "Ownable: new owner is the zero address");
emit OwnershipPushed(_owner, newOwner_);
_newOwner = newOwner_;
}
function pullManagement() public virtual override {
require(msg.sender == _newOwner, "Ownable: must be new owner to pull");
emit OwnershipPulled(_owner, _newOwner);
_owner = _newOwner;
}
}
interface IMemo {
function rebase(uint256 ohmProfit_, uint epoch_) external returns (uint256);
function circulatingSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function gonsForBalance(uint amount) external view returns (uint);
function balanceForGons(uint gons) external view returns (uint);
function index() external view returns (uint);
}
interface IWarmup {
function retrieve(address staker_, uint amount_) external;
}
interface IDistributor {
function distribute() external returns (bool);
}
contract TimeStaking is Ownable {
using SafeMath for uint256;
using SafeMath for uint32;
using SafeERC20 for IERC20;
address public immutable Time;
address public immutable Memories;
struct Epoch {
uint number;
uint distribute;
uint32 length;
uint32 endTime;
}
Epoch public epoch;
address public distributor;
address public locker;
uint public totalBonus;
address public warmupContract;
uint public warmupPeriod;
constructor (address _Time,
address _Memories,
uint32 _epochLength,
uint _firstEpochNumber,
uint32 _firstEpochTime) {
require(_Time != address(0));
Time = _Time;
require(_Memories != address(0));
Memories = _Memories;
epoch = Epoch({
length: _epochLength,
number: _firstEpochNumber,
endTime: _firstEpochTime,
distribute: 0
});
}
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(Time).safeTransferFrom(msg.sender, address(this), _amount);
Claim memory info = warmupInfo[ _recipient ];
require(!info.lock, "Deposits for account are locked");
warmupInfo[ _recipient ] = Claim ({
deposit: info.deposit.add(_amount),
gons: info.gons.add(IMemo(Memories).gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
IERC20(Memories).safeTransfer(warmupContract, _amount);
return true;
}
function claim (address _recipient) public {
Claim memory info = warmupInfo[ _recipient ];
if (epoch.number >= info.expiry && info.expiry != 0) {
delete warmupInfo[ _recipient ];
IWarmup(warmupContract).retrieve(_recipient, IMemo(Memories).balanceForGons(info.gons));
}
}
function forfeit() external {
Claim memory info = warmupInfo[ msg.sender ];
delete warmupInfo[ msg.sender ];
IWarmup(warmupContract).retrieve(address(this), IMemo(Memories).balanceForGons(info.gons));
IERC20(Time).safeTransfer(msg.sender, info.deposit);
}
function toggleDepositLock() external {
warmupInfo[ msg.sender ].lock = !warmupInfo[ msg.sender ].lock;
}
function unstake(uint _amount, bool _trigger) external {
if (_trigger) {
rebase();
}
IERC20(Memories).safeTransferFrom(msg.sender, address(this), _amount);
IERC20(Time).safeTransfer(msg.sender, _amount);
}
function index() public view returns (uint) {
return IMemo(Memories).index();
}
function rebase() public {
if(epoch.endTime <= uint32(block.timestamp)) {
IMemo(Memories).rebase(epoch.distribute, epoch.number);
epoch.endTime = epoch.endTime.add32(epoch.length);
epoch.number++;
if (distributor != address(0)) {
IDistributor(distributor).distribute();
}
uint balance = contractBalance();
uint staked = IMemo(Memories).circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
}
}
function contractBalance() public view returns (uint) {
return IERC20(Time).balanceOf(address(this)).add(totalBonus);
}
function giveLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.add(_amount);
IERC20(Memories).safeTransfer(locker, _amount);
}
function returnLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.sub(_amount);
IERC20(Memories).safeTransferFrom(locker, address(this), _amount);
}
enum CONTRACTS { DISTRIBUTOR, WARMUP, LOCKER }
function setContract(CONTRACTS _contract, address _address) external onlyManager() {
if(_contract == CONTRACTS.DISTRIBUTOR) { // 0
distributor = _address;
} else if (_contract == CONTRACTS.WARMUP) { // 1
require(warmupContract == address(0), "Warmup cannot be set more than once");
warmupContract = _address;
} else if (_contract == CONTRACTS.LOCKER) { // 2
require(locker == address(0), "Locker cannot be set more than once");
locker = _address;
}
}
function setWarmup(uint _warmupPeriod) external onlyManager() {
warmupPeriod = _warmupPeriod;
}
}
| 96,744 | 13,792 |
3827bfd411000fb41479b9d585e5f7f1df19b96e524f1f91be7d4dd6c61515b4
| 34,759 |
.sol
|
Solidity
| false |
364329218
|
CreamFi/cream-deployment
|
135bcc381adc8e10e2c64ad92cf9020d974e41e7
|
contracts/PriceOracle/v1PriceOracle.sol
| 7,092 | 25,320 |
pragma solidity ^0.5.16;
contract ErrorReporter {
event Failure(uint256 error, uint256 info, uint256 detail);
enum Error {
NO_ERROR,
OPAQUE_ERROR,
UNAUTHORIZED,
INTEGER_OVERFLOW,
INTEGER_UNDERFLOW,
DIVISION_BY_ZERO,
BAD_INPUT,
TOKEN_INSUFFICIENT_ALLOWANCE,
TOKEN_INSUFFICIENT_BALANCE,
TOKEN_TRANSFER_FAILED,
MARKET_NOT_SUPPORTED,
SUPPLY_RATE_CALCULATION_FAILED,
BORROW_RATE_CALCULATION_FAILED,
TOKEN_INSUFFICIENT_CASH,
TOKEN_TRANSFER_OUT_FAILED,
INSUFFICIENT_LIQUIDITY,
INSUFFICIENT_BALANCE,
INVALID_COLLATERAL_RATIO,
MISSING_ASSET_PRICE,
EQUITY_INSUFFICIENT_BALANCE,
INVALID_CLOSE_AMOUNT_REQUESTED,
ASSET_NOT_PRICED,
INVALID_LIQUIDATION_DISCOUNT,
INVALID_COMBINED_RISK_PARAMETERS
}
enum FailureInfo {
BORROW_ACCOUNT_LIQUIDITY_CALCULATION_FAILED,
BORROW_ACCOUNT_SHORTFALL_PRESENT,
BORROW_AMOUNT_LIQUIDITY_SHORTFALL,
BORROW_AMOUNT_VALUE_CALCULATION_FAILED,
BORROW_MARKET_NOT_SUPPORTED,
BORROW_NEW_BORROW_INDEX_CALCULATION_FAILED,
BORROW_NEW_BORROW_RATE_CALCULATION_FAILED,
BORROW_NEW_SUPPLY_INDEX_CALCULATION_FAILED,
BORROW_NEW_SUPPLY_RATE_CALCULATION_FAILED,
BORROW_NEW_TOTAL_BORROW_CALCULATION_FAILED,
BORROW_NEW_TOTAL_CASH_CALCULATION_FAILED,
BORROW_ORIGINATION_FEE_CALCULATION_FAILED,
BORROW_TRANSFER_OUT_FAILED,
EQUITY_WITHDRAWAL_AMOUNT_VALIDATION,
EQUITY_WITHDRAWAL_CALCULATE_EQUITY,
EQUITY_WITHDRAWAL_MODEL_OWNER_CHECK,
EQUITY_WITHDRAWAL_TRANSFER_OUT_FAILED,
LIQUIDATE_ACCUMULATED_BORROW_BALANCE_CALCULATION_FAILED,
LIQUIDATE_ACCUMULATED_SUPPLY_BALANCE_CALCULATION_FAILED_BORROWER_COLLATERAL_ASSET,
LIQUIDATE_ACCUMULATED_SUPPLY_BALANCE_CALCULATION_FAILED_LIQUIDATOR_COLLATERAL_ASSET,
LIQUIDATE_AMOUNT_SEIZE_CALCULATION_FAILED,
LIQUIDATE_BORROW_DENOMINATED_COLLATERAL_CALCULATION_FAILED,
LIQUIDATE_CLOSE_AMOUNT_TOO_HIGH,
LIQUIDATE_DISCOUNTED_REPAY_TO_EVEN_AMOUNT_CALCULATION_FAILED,
LIQUIDATE_NEW_BORROW_INDEX_CALCULATION_FAILED_BORROWED_ASSET,
LIQUIDATE_NEW_BORROW_INDEX_CALCULATION_FAILED_COLLATERAL_ASSET,
LIQUIDATE_NEW_BORROW_RATE_CALCULATION_FAILED_BORROWED_ASSET,
LIQUIDATE_NEW_SUPPLY_INDEX_CALCULATION_FAILED_BORROWED_ASSET,
LIQUIDATE_NEW_SUPPLY_INDEX_CALCULATION_FAILED_COLLATERAL_ASSET,
LIQUIDATE_NEW_SUPPLY_RATE_CALCULATION_FAILED_BORROWED_ASSET,
LIQUIDATE_NEW_TOTAL_BORROW_CALCULATION_FAILED_BORROWED_ASSET,
LIQUIDATE_NEW_TOTAL_CASH_CALCULATION_FAILED_BORROWED_ASSET,
LIQUIDATE_NEW_TOTAL_SUPPLY_BALANCE_CALCULATION_FAILED_BORROWER_COLLATERAL_ASSET,
LIQUIDATE_NEW_TOTAL_SUPPLY_BALANCE_CALCULATION_FAILED_LIQUIDATOR_COLLATERAL_ASSET,
LIQUIDATE_TRANSFER_IN_FAILED,
LIQUIDATE_TRANSFER_IN_NOT_POSSIBLE,
REPAY_BORROW_NEW_BORROW_INDEX_CALCULATION_FAILED,
REPAY_BORROW_NEW_BORROW_RATE_CALCULATION_FAILED,
REPAY_BORROW_NEW_SUPPLY_INDEX_CALCULATION_FAILED,
REPAY_BORROW_NEW_SUPPLY_RATE_CALCULATION_FAILED,
REPAY_BORROW_NEW_TOTAL_BORROW_CALCULATION_FAILED,
REPAY_BORROW_NEW_TOTAL_CASH_CALCULATION_FAILED,
REPAY_BORROW_TRANSFER_IN_FAILED,
REPAY_BORROW_TRANSFER_IN_NOT_POSSIBLE,
SET_ADMIN_OWNER_CHECK,
SET_ASSET_PRICE_CHECK_ORACLE,
SET_MARKET_INTEREST_RATE_MODEL_OWNER_CHECK,
SET_ORACLE_OWNER_CHECK,
SET_ORIGINATION_FEE_OWNER_CHECK,
SET_RISK_PARAMETERS_OWNER_CHECK,
SET_RISK_PARAMETERS_VALIDATION,
SUPPLY_ACCUMULATED_BALANCE_CALCULATION_FAILED,
SUPPLY_MARKET_NOT_SUPPORTED,
SUPPLY_NEW_BORROW_INDEX_CALCULATION_FAILED,
SUPPLY_NEW_BORROW_RATE_CALCULATION_FAILED,
SUPPLY_NEW_SUPPLY_INDEX_CALCULATION_FAILED,
SUPPLY_NEW_SUPPLY_RATE_CALCULATION_FAILED,
SUPPLY_NEW_TOTAL_BALANCE_CALCULATION_FAILED,
SUPPLY_NEW_TOTAL_CASH_CALCULATION_FAILED,
SUPPLY_NEW_TOTAL_SUPPLY_CALCULATION_FAILED,
SUPPLY_TRANSFER_IN_FAILED,
SUPPLY_TRANSFER_IN_NOT_POSSIBLE,
SUPPORT_MARKET_OWNER_CHECK,
SUPPORT_MARKET_PRICE_CHECK,
SUSPEND_MARKET_OWNER_CHECK,
WITHDRAW_ACCOUNT_LIQUIDITY_CALCULATION_FAILED,
WITHDRAW_ACCOUNT_SHORTFALL_PRESENT,
WITHDRAW_ACCUMULATED_BALANCE_CALCULATION_FAILED,
WITHDRAW_AMOUNT_LIQUIDITY_SHORTFALL,
WITHDRAW_AMOUNT_VALUE_CALCULATION_FAILED,
WITHDRAW_CAPACITY_CALCULATION_FAILED,
WITHDRAW_NEW_BORROW_INDEX_CALCULATION_FAILED,
WITHDRAW_NEW_BORROW_RATE_CALCULATION_FAILED,
WITHDRAW_NEW_SUPPLY_INDEX_CALCULATION_FAILED,
WITHDRAW_NEW_SUPPLY_RATE_CALCULATION_FAILED,
WITHDRAW_NEW_TOTAL_BALANCE_CALCULATION_FAILED,
WITHDRAW_NEW_TOTAL_SUPPLY_CALCULATION_FAILED,
WITHDRAW_TRANSFER_OUT_FAILED,
WITHDRAW_TRANSFER_OUT_NOT_POSSIBLE
}
function fail(Error err, FailureInfo info) internal returns (uint256) {
emit Failure(uint256(err), uint256(info), 0);
return uint256(err);
}
function failOpaque(FailureInfo info, uint256 opaqueError) internal returns (uint256) {
emit Failure(uint256(Error.OPAQUE_ERROR), uint256(info), opaqueError);
return uint256(Error.OPAQUE_ERROR);
}
}
contract CarefulMath is ErrorReporter {
function mul(uint256 a, uint256 b) internal pure returns (Error, uint256) {
if (a == 0) {
return (Error.NO_ERROR, 0);
}
uint256 c = a * b;
if (c / a != b) {
return (Error.INTEGER_OVERFLOW, 0);
} else {
return (Error.NO_ERROR, c);
}
}
function div(uint256 a, uint256 b) internal pure returns (Error, uint256) {
if (b == 0) {
return (Error.DIVISION_BY_ZERO, 0);
}
return (Error.NO_ERROR, a / b);
}
function sub(uint256 a, uint256 b) internal pure returns (Error, uint256) {
if (b <= a) {
return (Error.NO_ERROR, a - b);
} else {
return (Error.INTEGER_UNDERFLOW, 0);
}
}
function add(uint256 a, uint256 b) internal pure returns (Error, uint256) {
uint256 c = a + b;
if (c >= a) {
return (Error.NO_ERROR, c);
} else {
return (Error.INTEGER_OVERFLOW, 0);
}
}
function addThenSub(uint256 a,
uint256 b,
uint256 c) internal pure returns (Error, uint256) {
(Error err0, uint256 sum) = add(a, b);
if (err0 != Error.NO_ERROR) {
return (err0, 0);
}
return sub(sum, c);
}
}
contract Exponential is ErrorReporter, CarefulMath {
// TODO: We may wish to put the result of 10**18 here instead of the expression.
// Per https://solidity.readthedocs.io/en/latest/contracts.html#constant-state-variables
// the optimizer MAY replace the expression 10**18 with its calculated value.
uint256 constant expScale = 10**18;
// See TODO on expScale
uint256 constant halfExpScale = expScale / 2;
struct Exp {
uint256 mantissa;
}
uint256 constant mantissaOne = 10**18;
uint256 constant mantissaOneTenth = 10**17;
function getExp(uint256 num, uint256 denom) internal pure returns (Error, Exp memory) {
(Error err0, uint256 scaledNumerator) = mul(num, expScale);
if (err0 != Error.NO_ERROR) {
return (err0, Exp({mantissa: 0}));
}
(Error err1, uint256 rational) = div(scaledNumerator, denom);
if (err1 != Error.NO_ERROR) {
return (err1, Exp({mantissa: 0}));
}
return (Error.NO_ERROR, Exp({mantissa: rational}));
}
function addExp(Exp memory a, Exp memory b) internal pure returns (Error, Exp memory) {
(Error error, uint256 result) = add(a.mantissa, b.mantissa);
return (error, Exp({mantissa: result}));
}
function subExp(Exp memory a, Exp memory b) internal pure returns (Error, Exp memory) {
(Error error, uint256 result) = sub(a.mantissa, b.mantissa);
return (error, Exp({mantissa: result}));
}
function mulScalar(Exp memory a, uint256 scalar) internal pure returns (Error, Exp memory) {
(Error err0, uint256 scaledMantissa) = mul(a.mantissa, scalar);
if (err0 != Error.NO_ERROR) {
return (err0, Exp({mantissa: 0}));
}
return (Error.NO_ERROR, Exp({mantissa: scaledMantissa}));
}
function divScalar(Exp memory a, uint256 scalar) internal pure returns (Error, Exp memory) {
(Error err0, uint256 descaledMantissa) = div(a.mantissa, scalar);
if (err0 != Error.NO_ERROR) {
return (err0, Exp({mantissa: 0}));
}
return (Error.NO_ERROR, Exp({mantissa: descaledMantissa}));
}
function divScalarByExp(uint256 scalar, Exp memory divisor) internal pure returns (Error, Exp memory) {
(Error err0, uint256 numerator) = mul(expScale, scalar);
if (err0 != Error.NO_ERROR) {
return (err0, Exp({mantissa: 0}));
}
return getExp(numerator, divisor.mantissa);
}
function mulExp(Exp memory a, Exp memory b) internal pure returns (Error, Exp memory) {
(Error err0, uint256 doubleScaledProduct) = mul(a.mantissa, b.mantissa);
if (err0 != Error.NO_ERROR) {
return (err0, Exp({mantissa: 0}));
}
// We add half the scale before dividing so that we get rounding instead of truncation.
// See "Listing 6" and text above it at https://accu.org/index.php/journals/1717
(Error err1, uint256 doubleScaledProductWithHalfScale) = add(halfExpScale, doubleScaledProduct);
if (err1 != Error.NO_ERROR) {
return (err1, Exp({mantissa: 0}));
}
(Error err2, uint256 product) = div(doubleScaledProductWithHalfScale, expScale);
assert(err2 == Error.NO_ERROR);
return (Error.NO_ERROR, Exp({mantissa: product}));
}
function divExp(Exp memory a, Exp memory b) internal pure returns (Error, Exp memory) {
return getExp(a.mantissa, b.mantissa);
}
function truncate(Exp memory exp) internal pure returns (uint256) {
// Note: We are not using careful math here as we're performing a division that cannot fail
return exp.mantissa / 10**18;
}
function lessThanExp(Exp memory left, Exp memory right) internal pure returns (bool) {
return left.mantissa < right.mantissa; //TODO: Add some simple tests and this in another PR yo.
}
function lessThanOrEqualExp(Exp memory left, Exp memory right) internal pure returns (bool) {
return left.mantissa <= right.mantissa;
}
function greaterThanExp(Exp memory left, Exp memory right) internal pure returns (bool) {
return left.mantissa > right.mantissa;
}
function isZeroExp(Exp memory value) internal pure returns (bool) {
return value.mantissa == 0;
}
}
contract PriceOracle is Exponential {
bool public paused;
uint256 public constant numBlocksPerPeriod = 240; // approximately 1 hour: 60 seconds/minute * 60 minutes/hour * 1 block/15 seconds
uint256 public constant maxSwingMantissa = (10**17); // 0.1
mapping(address => Exp) public _assetPrices;
constructor(address _poster) public {
anchorAdmin = msg.sender;
poster = _poster;
maxSwing = Exp({mantissa: maxSwingMantissa});
}
function() external payable {
revert();
}
enum OracleError {
NO_ERROR,
UNAUTHORIZED,
FAILED_TO_SET_PRICE
}
enum OracleFailureInfo {
ACCEPT_ANCHOR_ADMIN_PENDING_ANCHOR_ADMIN_CHECK,
SET_PAUSED_OWNER_CHECK,
SET_PENDING_ANCHOR_ADMIN_OWNER_CHECK,
SET_PENDING_ANCHOR_PERMISSION_CHECK,
SET_PRICE_CALCULATE_SWING,
SET_PRICE_CAP_TO_MAX,
SET_PRICE_MAX_SWING_CHECK,
SET_PRICE_NO_ANCHOR_PRICE_OR_INITIAL_PRICE_ZERO,
SET_PRICE_PERMISSION_CHECK,
SET_PRICE_ZERO_PRICE,
SET_PRICES_PARAM_VALIDATION
}
event OracleFailure(address msgSender, address asset, uint256 error, uint256 info, uint256 detail);
function failOracle(address asset,
OracleError err,
OracleFailureInfo info) internal returns (uint256) {
emit OracleFailure(msg.sender, asset, uint256(err), uint256(info), 0);
return uint256(err);
}
function failOracleWithDetails(address asset,
OracleError err,
OracleFailureInfo info,
uint256 details) internal returns (uint256) {
emit OracleFailure(msg.sender, asset, uint256(err), uint256(info), details);
return uint256(err);
}
address public anchorAdmin;
address public pendingAnchorAdmin;
address public poster;
Exp public maxSwing;
struct Anchor {
// floor(block.number / numBlocksPerPeriod) + 1
uint256 period;
// Price in ETH, scaled by 10**18
uint256 priceMantissa;
}
mapping(address => Anchor) public anchors;
mapping(address => uint256) public pendingAnchors;
event NewPendingAnchor(address anchorAdmin, address asset, uint256 oldScaledPrice, uint256 newScaledPrice);
function _setPendingAnchor(address asset, uint256 newScaledPrice) public returns (uint256) {
if (msg.sender != anchorAdmin) {
return failOracle(asset, OracleError.UNAUTHORIZED, OracleFailureInfo.SET_PENDING_ANCHOR_PERMISSION_CHECK);
}
uint256 oldScaledPrice = pendingAnchors[asset];
pendingAnchors[asset] = newScaledPrice;
emit NewPendingAnchor(msg.sender, asset, oldScaledPrice, newScaledPrice);
return uint256(OracleError.NO_ERROR);
}
event PricePosted(address asset,
uint256 previousPriceMantissa,
uint256 requestedPriceMantissa,
uint256 newPriceMantissa);
event CappedPricePosted(address asset,
uint256 requestedPriceMantissa,
uint256 anchorPriceMantissa,
uint256 cappedPriceMantissa);
event SetPaused(bool newState);
event NewPendingAnchorAdmin(address oldPendingAnchorAdmin, address newPendingAnchorAdmin);
event NewAnchorAdmin(address oldAnchorAdmin, address newAnchorAdmin);
function _setPaused(bool requestedState) public returns (uint256) {
// Check caller = anchorAdmin
if (msg.sender != anchorAdmin) {
return failOracle(address(0), OracleError.UNAUTHORIZED, OracleFailureInfo.SET_PAUSED_OWNER_CHECK);
}
paused = requestedState;
emit SetPaused(requestedState);
return uint256(Error.NO_ERROR);
}
function _setPendingAnchorAdmin(address newPendingAnchorAdmin) public returns (uint256) {
// Check caller = anchorAdmin
if (msg.sender != anchorAdmin) {
return
failOracle(address(0),
OracleError.UNAUTHORIZED,
OracleFailureInfo.SET_PENDING_ANCHOR_ADMIN_OWNER_CHECK);
}
// save current value, if any, for inclusion in log
address oldPendingAnchorAdmin = pendingAnchorAdmin;
// Store pendingAdmin = newPendingAdmin
pendingAnchorAdmin = newPendingAnchorAdmin;
emit NewPendingAnchorAdmin(oldPendingAnchorAdmin, newPendingAnchorAdmin);
return uint256(Error.NO_ERROR);
}
function _acceptAnchorAdmin() public returns (uint256) {
// Check caller = pendingAnchorAdmin
// msg.sender can't be zero
if (msg.sender != pendingAnchorAdmin) {
return
failOracle(address(0),
OracleError.UNAUTHORIZED,
OracleFailureInfo.ACCEPT_ANCHOR_ADMIN_PENDING_ANCHOR_ADMIN_CHECK);
}
// Save current value for inclusion in log
address oldAnchorAdmin = anchorAdmin;
// Store admin = pendingAnchorAdmin
anchorAdmin = pendingAnchorAdmin;
// Clear the pending value
pendingAnchorAdmin = address(0);
emit NewAnchorAdmin(oldAnchorAdmin, msg.sender);
return uint256(Error.NO_ERROR);
}
function assetPrices(address asset) public view returns (uint256) {
// Note: zero is treated by the money market as an invalid
// price and will cease operations with that asset
// when zero.
//
// We get the price as:
//
// 1. If the contract is paused, return 0.
// 2. Return price in `_assetPrices`, which may be zero.
if (paused) {
return 0;
}
return _assetPrices[asset].mantissa;
}
function getPrice(address asset) public view returns (uint256) {
return assetPrices(asset);
}
struct SetPriceLocalVars {
Exp price;
Exp swing;
Exp anchorPrice;
uint256 anchorPeriod;
uint256 currentPeriod;
bool priceCapped;
uint256 cappingAnchorPriceMantissa;
uint256 pendingAnchorMantissa;
}
function setPrice(address asset, uint256 requestedPriceMantissa) public returns (uint256) {
// Fail when msg.sender is not poster
if (msg.sender != poster) {
return failOracle(asset, OracleError.UNAUTHORIZED, OracleFailureInfo.SET_PRICE_PERMISSION_CHECK);
}
return setPriceInternal(asset, requestedPriceMantissa);
}
function setPriceInternal(address asset, uint256 requestedPriceMantissa) internal returns (uint256) {
// re-used for intermediate errors
Error err;
SetPriceLocalVars memory localVars;
// (It can be a problem in tests with low block numbers.)
localVars.currentPeriod = (block.number / numBlocksPerPeriod) + 1;
localVars.pendingAnchorMantissa = pendingAnchors[asset];
localVars.price = Exp({mantissa: requestedPriceMantissa});
if (localVars.pendingAnchorMantissa != 0) {
// let's explicitly set to 0 rather than relying on default of declaration
localVars.anchorPeriod = 0;
localVars.anchorPrice = Exp({mantissa: localVars.pendingAnchorMantissa});
// Verify movement is within max swing of pending anchor (currently: 10%)
(err, localVars.swing) = calculateSwing(localVars.anchorPrice, localVars.price);
if (err != Error.NO_ERROR) {
return
failOracleWithDetails(asset,
OracleError.FAILED_TO_SET_PRICE,
OracleFailureInfo.SET_PRICE_CALCULATE_SWING,
uint256(err));
}
// Fail when swing > maxSwing
if (greaterThanExp(localVars.swing, maxSwing)) {
return
failOracleWithDetails(asset,
OracleError.FAILED_TO_SET_PRICE,
OracleFailureInfo.SET_PRICE_MAX_SWING_CHECK,
localVars.swing.mantissa);
}
} else {
localVars.anchorPeriod = anchors[asset].period;
localVars.anchorPrice = Exp({mantissa: anchors[asset].priceMantissa});
if (localVars.anchorPeriod != 0) {
(err, localVars.priceCapped, localVars.price) = capToMax(localVars.anchorPrice, localVars.price);
if (err != Error.NO_ERROR) {
return
failOracleWithDetails(asset,
OracleError.FAILED_TO_SET_PRICE,
OracleFailureInfo.SET_PRICE_CAP_TO_MAX,
uint256(err));
}
if (localVars.priceCapped) {
// save for use in log
localVars.cappingAnchorPriceMantissa = localVars.anchorPrice.mantissa;
}
} else {
localVars.anchorPrice = Exp({mantissa: requestedPriceMantissa});
}
}
// Fail if anchorPrice or price is zero.
// zero anchor represents an unexpected situation likely due to a problem in this contract
// zero price is more likely as the result of bad input from the caller of this function
if (isZeroExp(localVars.anchorPrice)) {
return
failOracle(asset,
OracleError.FAILED_TO_SET_PRICE,
OracleFailureInfo.SET_PRICE_NO_ANCHOR_PRICE_OR_INITIAL_PRICE_ZERO);
}
if (isZeroExp(localVars.price)) {
return failOracle(asset, OracleError.FAILED_TO_SET_PRICE, OracleFailureInfo.SET_PRICE_ZERO_PRICE);
}
// BEGIN SIDE EFFECTS
// Set pendingAnchor = Nothing
// Pending anchor is only used once.
if (pendingAnchors[asset] != 0) {
pendingAnchors[asset] = 0;
}
// If currentPeriod > anchorPeriod:
// Set anchors[asset] = (currentPeriod, price)
if (localVars.currentPeriod > localVars.anchorPeriod) {
anchors[asset] = Anchor({period: localVars.currentPeriod, priceMantissa: localVars.price.mantissa});
}
uint256 previousPrice = _assetPrices[asset].mantissa;
setPriceStorageInternal(asset, localVars.price.mantissa);
emit PricePosted(asset, previousPrice, requestedPriceMantissa, localVars.price.mantissa);
if (localVars.priceCapped) {
// We have set a capped price. Log it so we can detect the situation and investigate.
emit CappedPricePosted(asset,
requestedPriceMantissa,
localVars.cappingAnchorPriceMantissa,
localVars.price.mantissa);
}
return uint256(OracleError.NO_ERROR);
}
// As a function to allow harness overrides
function setPriceStorageInternal(address asset, uint256 priceMantissa) internal {
_assetPrices[asset] = Exp({mantissa: priceMantissa});
}
// abs(price - anchorPrice) / anchorPrice
function calculateSwing(Exp memory anchorPrice, Exp memory price) internal pure returns (Error, Exp memory) {
Exp memory numerator;
Error err;
if (greaterThanExp(anchorPrice, price)) {
(err, numerator) = subExp(anchorPrice, price);
// can't underflow
assert(err == Error.NO_ERROR);
} else {
(err, numerator) = subExp(price, anchorPrice);
// Given greaterThan check above, price >= anchorPrice so can't underflow.
assert(err == Error.NO_ERROR);
}
return divExp(numerator, anchorPrice);
}
function capToMax(Exp memory anchorPrice, Exp memory price)
internal
view
returns (Error,
bool,
Exp memory)
{
Exp memory one = Exp({mantissa: mantissaOne});
Exp memory onePlusMaxSwing;
Exp memory oneMinusMaxSwing;
Exp memory max;
Exp memory min;
// re-used for intermediate errors
Error err;
(err, onePlusMaxSwing) = addExp(one, maxSwing);
if (err != Error.NO_ERROR) {
return (err, false, Exp({mantissa: 0}));
}
// max = anchorPrice * (1 + maxSwing)
(err, max) = mulExp(anchorPrice, onePlusMaxSwing);
if (err != Error.NO_ERROR) {
return (err, false, Exp({mantissa: 0}));
}
// If price > anchorPrice * (1 + maxSwing)
// Set price = anchorPrice * (1 + maxSwing)
if (greaterThanExp(price, max)) {
return (Error.NO_ERROR, true, max);
}
(err, oneMinusMaxSwing) = subExp(one, maxSwing);
if (err != Error.NO_ERROR) {
return (err, false, Exp({mantissa: 0}));
}
// min = anchorPrice * (1 - maxSwing)
(err, min) = mulExp(anchorPrice, oneMinusMaxSwing);
// We can't overflow here or we would have already overflowed above when calculating `max`
assert(err == Error.NO_ERROR);
// If price < anchorPrice * (1 - maxSwing)
// Set price = anchorPrice * (1 - maxSwing)
if (lessThanExp(price, min)) {
return (Error.NO_ERROR, true, min);
}
return (Error.NO_ERROR, false, price);
}
function setPrices(address[] memory assets, uint256[] memory requestedPriceMantissas)
public
returns (uint256[] memory)
{
uint256 numAssets = assets.length;
uint256 numPrices = requestedPriceMantissas.length;
uint256[] memory result;
// Fail when msg.sender is not poster
if (msg.sender != poster) {
result = new uint256[](1);
result[0] = failOracle(address(0), OracleError.UNAUTHORIZED, OracleFailureInfo.SET_PRICE_PERMISSION_CHECK);
return result;
}
if ((numAssets == 0) || (numPrices != numAssets)) {
result = new uint256[](1);
result[0] = failOracle(address(0),
OracleError.FAILED_TO_SET_PRICE,
OracleFailureInfo.SET_PRICES_PARAM_VALIDATION);
return result;
}
result = new uint256[](numAssets);
for (uint256 i = 0; i < numAssets; i++) {
result[i] = setPriceInternal(assets[i], requestedPriceMantissas[i]);
}
return result;
}
}
| 336,555 | 13,793 |
70bcbbf11db4713194d0cb043bf94cfa002a542097704b15faae895512dc643f
| 14,711 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TD/TDR2QFJJc2yhwEzaKLvaPK8s9sRLc83giE_TronSuperWalletV1.sol
| 4,205 | 14,031 |
//SourceUnit: tronsuperwallet1.sol
pragma solidity >=0.5.9 <0.6.0;
contract TronSuperWalletV1 {
struct User {
uint256 cycle;
address upline;
uint256 referrals;
uint256 payouts;
uint256 direct_bonus;
uint256 pool_bonus;
uint256 tup_bonus;
uint256 match_bonus;
uint256 deposit_amount;
uint256 deposit_payouts;
uint40 deposit_time;
uint256 total_deposits;
uint256 total_payouts;
uint256 total_structure;
}
struct Downline{
address downline_address;
}
address payable public owner;
address payable public admin_fee;
address payable public top_account;
mapping(address => Downline[]) public downlines;
mapping(address => User) public users;
uint256[] public cycles;
uint8[] public ref_bonuses; // 1 => 1%
uint8[] public pool_bonuses; // 1 => 1%
uint40 public pool_last_draw = uint40(block.timestamp);
uint256 public pool_cycle;
uint256 public pool_balance;
mapping(uint256 => mapping(address => uint256)) public pool_users_refs_deposits_sum;
mapping(uint8 => address) public pool_top;
uint256 public total_users = 1;
uint256 public total_deposited;
uint256 public total_withdraw;
event Upline(address indexed addr, address indexed upline);
event AddDownline(address indexed uplineaddr, address indexed downlineaddr);
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 TwoUpPayout(address indexed addr, address indexed from, uint256 amount);
event PoolPayout(address indexed addr, uint256 amount);
event Withdraw(address indexed addr, uint256 amount);
event LimitReached(address indexed addr, uint256 amount);
constructor() public {
owner = msg.sender;
top_account = 0xE44A2Ade11e17Bccd7caebC083515711366FA28B;
admin_fee = 0x746c948BEa027B4cab2f5E7b6a27553F2CEa753E;
ref_bonuses.push(25);
ref_bonuses.push(10);
ref_bonuses.push(10);
ref_bonuses.push(10);
ref_bonuses.push(10);
ref_bonuses.push(6);
ref_bonuses.push(6);
ref_bonuses.push(6);
ref_bonuses.push(6);
ref_bonuses.push(6);
ref_bonuses.push(5);
ref_bonuses.push(5);
ref_bonuses.push(5);
ref_bonuses.push(5);
ref_bonuses.push(5);
ref_bonuses.push(1);
ref_bonuses.push(1);
ref_bonuses.push(1);
ref_bonuses.push(1);
ref_bonuses.push(1);
pool_bonuses.push(50);
pool_bonuses.push(30);
pool_bonuses.push(20);
cycles.push(75000000000);
cycles.push(150000000000);
cycles.push(300000000000);
cycles.push(500000000000);
cycles.push(1000000000000);
cycles.push(2000000000000);
}
function() payable external {
_deposit(msg.sender, msg.value);
}
function _setUpline(address _addr, address _upline) private {
if(users[_addr].upline == address(0) && _upline != _addr && _addr != top_account && (users[_upline].deposit_time > 0 || _upline == top_account)) {
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;
}
downlines[users[_addr].upline].push(Downline(_addr));
emit AddDownline(users[_addr].upline, _addr);
}
}
function _deposit(address _addr, uint256 _amount) private {
require(users[_addr].upline != address(0) || _addr == top_account, "No upline");
if(users[_addr].deposit_time > 0) {
if(_amount == cycles[users[_addr].cycle > cycles.length - 1 ? cycles.length - 1 : users[_addr].cycle]){
users[_addr].cycle++;
}
require(users[_addr].payouts >= this.maxPayoutOf(users[_addr].deposit_amount), "Deposit already exists");
require(_amount >= users[_addr].deposit_amount && _amount <= cycles[users[_addr].cycle > cycles.length - 1 ? cycles.length - 1 : users[_addr].cycle], "Bad amount");
}
else require(_amount >= 1e8 && _amount <= cycles[0], "Bad amount");
users[_addr].payouts = 0;
users[_addr].deposit_amount = _amount;
users[_addr].deposit_payouts = 0;
users[_addr].deposit_time = uint40(block.timestamp);
users[_addr].total_deposits += _amount;
total_deposited += _amount;
emit NewDeposit(_addr, _amount);
if(users[_addr].upline != address(0)) {
users[users[_addr].upline].direct_bonus += _amount * 5 / 100;
emit DirectPayout(users[_addr].upline, _addr, _amount * 5 / 100);
}
_pollDeposits(_addr, _amount);
if(pool_last_draw + 1 days < block.timestamp) {
_drawPool();
}
admin_fee.transfer(_amount / 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;
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 _tupBonus(address _addr, uint256 _amount) private {
if(downlines[_addr].length > 0){
for(uint256 i = 0; i < downlines[_addr].length; i++) {
address down_lvl = downlines[_addr][i].downline_address;
uint256 down_bonus = _amount * 3 / 100;
users[down_lvl].tup_bonus += down_bonus;
emit TwoUpPayout (down_lvl, _addr, down_bonus);
if(downlines[down_lvl].length > 0){
for(uint256 j = 0; j < downlines[down_lvl].length; j++) {
address down_down_lvl = downlines[_addr][j].downline_address;
uint256 down_down_bonus = _amount * 2 / 100;
users[down_down_lvl].tup_bonus += down_down_bonus;
emit TwoUpPayout (down_down_lvl, _addr, down_down_bonus);
}
}
}
}
}
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);
// to_payout is
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;
}
// 2up bonus payout
if(users[msg.sender].payouts < max_payout && users[msg.sender].tup_bonus > 0) {
uint256 tup_bonus = users[msg.sender].tup_bonus;
if(users[msg.sender].payouts + tup_bonus > max_payout) {
tup_bonus = max_payout - users[msg.sender].payouts;
}
users[msg.sender].tup_bonus -= tup_bonus;
users[msg.sender].payouts += tup_bonus;
to_payout += tup_bonus;
}
// Match payout
if(users[msg.sender].payouts < max_payout && users[msg.sender].match_bonus > 0) {
uint256 match_bonus = users[msg.sender].match_bonus;
if(users[msg.sender].payouts + match_bonus > max_payout) {
match_bonus = max_payout - users[msg.sender].payouts;
}
users[msg.sender].match_bonus -= match_bonus;
users[msg.sender].payouts += match_bonus;
to_payout += match_bonus;
}
require(to_payout > 0, "Zero payout");
users[msg.sender].total_payouts += to_payout;
total_withdraw += to_payout;
_tupBonus(msg.sender, to_payout);
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 * 35 / 10;
}
function payoutOf(address _addr) view external returns(uint256 payout, uint256 max_payout) {
max_payout = this.maxPayoutOf(users[_addr].deposit_amount);
if(users[_addr].deposit_payouts < max_payout) {
payout = (users[_addr].deposit_amount * ((block.timestamp - users[_addr].deposit_time) / 1 days) / 100) - users[_addr].deposit_payouts;
if(users[_addr].deposit_payouts + payout > max_payout) {
payout = max_payout - users[_addr].deposit_payouts;
}
}
}
function userInfo(address _addr) view external returns(address upline, uint40 deposit_time, uint256 deposit_amount, uint256 payouts) {
return (users[_addr].upline, users[_addr].deposit_time, users[_addr].deposit_amount, users[_addr].payouts);
}
function userInfoBonus(address _addr) view external returns (uint256 direct_bonus, uint256 pool_bonus, uint256 match_bonus, uint256 tup_bonus){
return (users[_addr].direct_bonus, users[_addr].pool_bonus, users[_addr].match_bonus, users[_addr].tup_bonus);
}
function userInfoTotals(address _addr) view external returns(uint256 referrals, uint256 total_deposits, uint256 total_payouts, uint256 total_structure) {
return (users[_addr].referrals, users[_addr].total_deposits, users[_addr].total_payouts, users[_addr].total_structure);
}
function contractInfo() view external returns(uint256 _total_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 userDownlineSize(address _addr) view external returns(uint256 size){
return (downlines[_addr].length);
}
function userDownlineInfo(address _addr, uint256 index) view external returns(address downlineaddr){
return (downlines[_addr][index].downline_address);
}
}
| 296,941 | 13,794 |
ecd302c0b29e63fbe719ff62ccdff8c452470ed5b58ceec1204f2b1037b9a4f8
| 27,667 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/10/1074fe39af6e1f63a26bd6aecda129b95e6715f4_SbrtToken.sol
| 2,626 | 10,618 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies 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");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
abstract contract 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 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 SbrtToken is ERC20("Sabertooth", "SBRT"), Ownable {
function mint(address _to, uint256 _amount) public onlyOwner {
_mint(_to, _amount);
}
}
| 97,748 | 13,795 |
893e700889c777f018e671f1972c1113eeb84fd1d57db117eb310ccafae2234f
| 27,244 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/05/05Ddd62dc5C7AcBEA7841b7261c5F7Bdf6c73c48_TransparentUpgradeableProxy.sol
| 2,807 | 11,863 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
abstract contract Proxy {
function _delegate(address implementation) internal virtual {
assembly {
// Copy msg.data. We take full control of memory in this inline assembly
// block because it will not return to Solidity code. We overwrite the
// Solidity scratch pad at memory position 0.
calldatacopy(0, 0, calldatasize())
// Call the implementation.
// out and outsize are 0 because we don't know the size yet.
let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)
// Copy the returned data.
returndatacopy(0, 0, returndatasize())
switch result
// delegatecall returns 0 on error.
case 0 {
revert(0, returndatasize())
}
default {
return(0, returndatasize())
}
}
}
function _implementation() internal view virtual returns (address);
function _fallback() internal virtual {
_beforeFallback();
_delegate(_implementation());
}
fallback() external payable virtual {
_fallback();
}
receive() external payable virtual {
_fallback();
}
function _beforeFallback() internal virtual {}
}
interface IBeacon {
function implementation() external view returns (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);
}
}
}
}
library StorageSlot {
struct AddressSlot {
address value;
}
struct BooleanSlot {
bool value;
}
struct Bytes32Slot {
bytes32 value;
}
struct Uint256Slot {
uint256 value;
}
function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
assembly {
r.slot := slot
}
}
function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
assembly {
r.slot := slot
}
}
function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
assembly {
r.slot := slot
}
}
function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
assembly {
r.slot := slot
}
}
}
abstract contract ERC1967Upgrade {
// This is the keccak-256 hash of "eip1967.proxy.rollback" subtracted by 1
bytes32 private constant _ROLLBACK_SLOT = 0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143;
bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
event Upgraded(address indexed implementation);
function _getImplementation() internal view returns (address) {
return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
}
function _setImplementation(address newImplementation) private {
require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract");
StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
}
function _upgradeTo(address newImplementation) internal {
_setImplementation(newImplementation);
emit Upgraded(newImplementation);
}
function _upgradeToAndCall(address newImplementation,
bytes memory data,
bool forceCall) internal {
_upgradeTo(newImplementation);
if (data.length > 0 || forceCall) {
Address.functionDelegateCall(newImplementation, data);
}
}
function _upgradeToAndCallSecure(address newImplementation,
bytes memory data,
bool forceCall) internal {
address oldImplementation = _getImplementation();
// Initial upgrade and setup call
_setImplementation(newImplementation);
if (data.length > 0 || forceCall) {
Address.functionDelegateCall(newImplementation, data);
}
// Perform rollback test if not already in progress
StorageSlot.BooleanSlot storage rollbackTesting = StorageSlot.getBooleanSlot(_ROLLBACK_SLOT);
if (!rollbackTesting.value) {
// Trigger rollback using upgradeTo from the new implementation
rollbackTesting.value = true;
Address.functionDelegateCall(newImplementation,
abi.encodeWithSignature("upgradeTo(address)", oldImplementation));
rollbackTesting.value = false;
// Check rollback was effective
require(oldImplementation == _getImplementation(), "ERC1967Upgrade: upgrade breaks further upgrades");
// Finally reset to the new implementation and log the upgrade
_upgradeTo(newImplementation);
}
}
bytes32 internal constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;
event AdminChanged(address previousAdmin, address newAdmin);
function _getAdmin() internal view returns (address) {
return StorageSlot.getAddressSlot(_ADMIN_SLOT).value;
}
function _setAdmin(address newAdmin) private {
require(newAdmin != address(0), "ERC1967: new admin is the zero address");
StorageSlot.getAddressSlot(_ADMIN_SLOT).value = newAdmin;
}
function _changeAdmin(address newAdmin) internal {
emit AdminChanged(_getAdmin(), newAdmin);
_setAdmin(newAdmin);
}
bytes32 internal constant _BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;
event BeaconUpgraded(address indexed beacon);
function _getBeacon() internal view returns (address) {
return StorageSlot.getAddressSlot(_BEACON_SLOT).value;
}
function _setBeacon(address newBeacon) private {
require(Address.isContract(newBeacon), "ERC1967: new beacon is not a contract");
require(Address.isContract(IBeacon(newBeacon).implementation()),
"ERC1967: beacon implementation is not a contract");
StorageSlot.getAddressSlot(_BEACON_SLOT).value = newBeacon;
}
function _upgradeBeaconToAndCall(address newBeacon,
bytes memory data,
bool forceCall) internal {
_setBeacon(newBeacon);
emit BeaconUpgraded(newBeacon);
if (data.length > 0 || forceCall) {
Address.functionDelegateCall(IBeacon(newBeacon).implementation(), data);
}
}
}
contract ERC1967Proxy is Proxy, ERC1967Upgrade {
constructor(address _logic, bytes memory _data) payable {
assert(_IMPLEMENTATION_SLOT == bytes32(uint256(keccak256("eip1967.proxy.implementation")) - 1));
_upgradeToAndCall(_logic, _data, false);
}
function _implementation() internal view virtual override returns (address impl) {
return ERC1967Upgrade._getImplementation();
}
}
contract TransparentUpgradeableProxy is ERC1967Proxy {
constructor(address _logic,
address admin_,
bytes memory _data) payable ERC1967Proxy(_logic, _data) {
assert(_ADMIN_SLOT == bytes32(uint256(keccak256("eip1967.proxy.admin")) - 1));
_changeAdmin(admin_);
}
modifier ifAdmin() {
if (msg.sender == _getAdmin()) {
_;
} else {
_fallback();
}
}
function admin() external ifAdmin returns (address admin_) {
admin_ = _getAdmin();
}
function implementation() external ifAdmin returns (address implementation_) {
implementation_ = _implementation();
}
function changeAdmin(address newAdmin) external virtual ifAdmin {
_changeAdmin(newAdmin);
}
function upgradeTo(address newImplementation) external ifAdmin {
_upgradeToAndCall(newImplementation, bytes(""), false);
}
function upgradeToAndCall(address newImplementation, bytes calldata data) external payable ifAdmin {
_upgradeToAndCall(newImplementation, data, true);
}
function _admin() internal view virtual returns (address) {
return _getAdmin();
}
function _beforeFallback() internal virtual override {
require(msg.sender != _getAdmin(), "TransparentUpgradeableProxy: admin cannot fallback to proxy target");
super._beforeFallback();
}
}
| 320,968 | 13,796 |
476f80321924a0ad6905975b85299d95075e7ee1ac5c67be0ec82ef08f28e60c
| 12,715 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/7e/7e2A978d41D2397F64d0c6e9Df477A8797f2c96c_Ghost.sol
| 2,885 | 10,709 |
// SPDX-License-Identifier: MIT
pragma solidity 0.7.5;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library LowGasSafeMath {
/// @notice Returns x + y, reverts if sum overflows uint256
/// @param x The augend
/// @param y The addend
/// @return z The sum of x and y
function add(uint256 x, uint256 y) internal pure returns (uint256 z) {
require((z = x + y) >= x);
}
/// @notice Returns x - y, reverts if underflows
/// @param x The minuend
/// @param y The subtrahend
/// @return z The difference of x and y
function sub(uint256 x, uint256 y) internal pure returns (uint256 z) {
require((z = x - y) <= x);
}
/// @notice Returns x * y, reverts if overflows
/// @param x The multiplicand
/// @param y The multiplier
/// @return z The product of x and y
function mul(uint256 x, uint256 y) internal pure returns (uint256 z) {
require(x == 0 || (z = x * y) / x == y);
}
/// @notice Returns x + y, reverts if overflows or underflows
/// @param x The augend
/// @param y The addend
/// @return z The sum of x and y
function add(int256 x, int256 y) internal pure returns (int256 z) {
require((z = x + y) >= x == (y >= 0));
}
/// @notice Returns x - y, reverts if overflows or underflows
/// @param x The minuend
/// @param y The subtrahend
/// @return z The difference of x and y
function sub(int256 x, int256 y) internal pure returns (int256 z) {
require((z = x - y) <= x == (y >= 0));
}
}
abstract contract ERC20 is IERC20 {
using LowGasSafeMath for uint256;
// Present in ERC777
mapping (address => uint256) internal _balances;
// Present in ERC777
mapping (address => mapping (address => uint256)) internal _allowances;
// Present in ERC777
uint256 internal _totalSupply;
// Present in ERC777
string internal _name;
// Present in ERC777
string internal _symbol;
// Present in ERC777
uint8 internal _decimals;
constructor (string memory name_, string memory symbol_, uint8 decimals_) {
_name = name_;
_symbol = symbol_;
_decimals = decimals_;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(msg.sender, spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender]
.sub(amount));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender]
.sub(subtractedValue));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount);
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account_, uint256 amount_) internal virtual {
require(account_ != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(this), account_, amount_);
_totalSupply = _totalSupply.add(amount_);
_balances[account_] = _balances[account_].add(amount_);
emit Transfer(address(0), account_, amount_);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount);
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _beforeTokenTransfer(address from_, address to_, uint256 amount_) internal virtual { }
}
library Counters {
using LowGasSafeMath for uint256;
struct Counter {
uint256 _value; // default: 0
}
function current(Counter storage counter) internal view returns (uint256) {
return counter._value;
}
function increment(Counter storage counter) internal {
counter._value += 1;
}
function decrement(Counter storage counter) internal {
counter._value = counter._value.sub(1);
}
}
interface IERC2612Permit {
function permit(address owner,
address spender,
uint256 amount,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) external;
function nonces(address owner) external view returns (uint256);
}
abstract contract ERC20Permit is ERC20, IERC2612Permit {
using Counters for Counters.Counter;
mapping(address => Counters.Counter) private _nonces;
// keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
bytes32 public constant PERMIT_TYPEHASH = 0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;
bytes32 public DOMAIN_SEPARATOR;
constructor() {
uint256 chainID;
assembly {
chainID := chainid()
}
DOMAIN_SEPARATOR = keccak256(abi.encode(keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
keccak256(bytes(name())),
keccak256(bytes("1")), // Version
chainID,
address(this)));
}
function permit(address owner,
address spender,
uint256 amount,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) public virtual override {
require(block.timestamp <= deadline, "Permit: expired deadline");
bytes32 hashStruct =
keccak256(abi.encode(PERMIT_TYPEHASH, owner, spender, amount, _nonces[owner].current(), deadline));
bytes32 _hash = keccak256(abi.encodePacked(uint16(0x1901), DOMAIN_SEPARATOR, hashStruct));
address signer = ecrecover(_hash, v, r, s);
require(signer != address(0) && signer == owner, "ERC20Permit: Invalid signature");
_nonces[owner].increment();
_approve(owner, spender, amount);
}
function nonces(address owner) public view override returns (uint256) {
return _nonces[owner].current();
}
}
interface IOwnable {
function owner() external view returns (address);
function renounceOwnership() external;
function transferOwnership(address newOwner_) external;
}
contract Ownable is IOwnable {
address internal _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view override returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual override onlyOwner() {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner_) public virtual override onlyOwner() {
require(newOwner_ != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner_);
_owner = newOwner_;
}
}
contract VaultOwned is Ownable {
address internal _vault;
event VaultTransferred(address indexed newVault);
function setVault(address vault_) external onlyOwner() {
require(vault_ != address(0), "IA0");
_vault = vault_;
emit VaultTransferred(_vault);
}
function vault() public view returns (address) {
return _vault;
}
modifier onlyVault() {
require(_vault == msg.sender, "VaultOwned: caller is not the Vault");
_;
}
}
contract Ghost is ERC20Permit, VaultOwned {
using LowGasSafeMath for uint256;
constructor() ERC20("Ghost", "GHOST", 9) {
}
function mint(address account_, uint256 amount_) external onlyVault() {
_mint(account_, amount_);
}
function burn(uint256 amount) external virtual {
_burn(msg.sender, amount);
}
function burnFrom(address account_, uint256 amount_) external virtual {
_burnFrom(account_, amount_);
}
function _burnFrom(address account_, uint256 amount_) internal virtual {
uint256 decreasedAllowance_ =
allowance(account_, msg.sender).sub(amount_);
_approve(account_, msg.sender, decreasedAllowance_);
_burn(account_, amount_);
}
}
| 112,432 | 13,797 |
f177ac5f93baacd7a00d790ac5c526a27b1d590d37554f14e9b70c0975d10e0a
| 20,397 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x17FFA953f54b8b93768Cac3e72C014B17cb37931/contract.sol
| 4,921 | 18,273 |
pragma solidity >=0.8.0;
// SPDX-License-Identifier: BSD-3-Clause
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 {
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)
uint256 toDeleteIndex = valueIndex - 1;
uint256 lastIndex = set._values.length - 1;
bytes32 lastvalue = set._values[lastIndex];
set._values[toDeleteIndex] = lastvalue;
set._indexes[lastvalue] = toDeleteIndex + 1; // All indexes are 1-based
set._values.pop();
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(uint(uint160(value))));
}
function remove(AddressSet storage set, address value) internal returns (bool) {
return _remove(set._inner, bytes32(uint(uint160(value))));
}
function contains(AddressSet storage set, address value) internal view returns (bool) {
return _contains(set._inner, bytes32(uint(uint160(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(uint160(uint(_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 owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
interface Token {
// bDFS functions
function transferFrom(address, address, uint) external returns (bool);
function transfer(address, uint) external returns (bool);
function balanceOf(address) external returns (uint256);
// NFT functions
function mapIDsInRange(uint256 _startIndex, uint256 _endIndex, address _dir, uint256 _numUsos) external returns (uint256[] memory res);
function use(uint256 id, address user) external returns(bool);
}
contract Staking_DFSG is Ownable {
using SafeMath for uint;
using EnumerableSet for EnumerableSet.AddressSet;
event Staked(address holder, uint amount);
event Withdrawn(address holder, uint amount);
event RewardsClaimed(address holder, uint amount);
event RewardsRestaked(address holder, uint amount);
address public DFSG = 0x612C49b95c9121107BE3A2FE1fcF1eFC1C4730AD;
address public collectionNFT = 0x1b20833A92387bBCB8D0E69C15124C6462e19869;
uint public constant rewardRate = 2000;
uint public constant rewardInterval = 365 days;
uint public constant stakingFeeRate = 100;
uint public emergencyWithdrawFeeRate = 2000;
uint public constant unstakeTime = 30 days;
uint public maxPoolSize = 2500000000000000000000000;
uint public poolSize = 2500000000000000000000000;
uint public allocation = 300000000000000000000000;
uint public constant maxStake = 50000000000000000000000;
uint public totalClaimedRewards = 0;
bool public ended ;
uint public current_NFT_index = 0;
uint public startIndexNFT = 31;
uint public endIndexNFT = 79;
uint public bonusNFT = 1000;
EnumerableSet.AddressSet private holders;
EnumerableSet.AddressSet private got_apy;
mapping (address => uint) public depositedTokens;
mapping (address => uint) public stakingTime;
mapping (address => uint) public lastClaimedTime;
mapping (address => uint) public totalEarnedTokens;
mapping (address => uint) public rewardEnded;
mapping (address => uint) public apy;
mapping (address => mapping(uint => bool)) public usedNFT;
function addGot_Appy(address[] memory _new) public onlyOwner returns(bool){
for(uint i = 0; i < _new.length; i = i.add(1)){
got_apy.add(_new[i]);
}
return true;
}
function getGot_Apy() public view onlyOwner returns(address[] memory){
uint _tam = got_apy.length();
address[] memory _res = new address[](_tam);
for(uint i = 0; i < _tam; i = i.add(1)){
_res[i] = got_apy.at(i);
}
return _res;
}
function addNewNFT() public onlyOwner returns(bool){
current_NFT_index = current_NFT_index.add(1);
return true;
}
function setBonusNFT(uint _new) public onlyOwner returns(bool){
bonusNFT = _new;
return true;
}
function setIndexes(uint _start, uint _end) public onlyOwner returns(bool){
startIndexNFT = _start;
endIndexNFT = _end;
return true;
}
function end() public onlyOwner returns (bool){
require(!ended, "Staking already ended");
for(uint i = 0; i < holders.length(); i = i.add(1)){
rewardEnded[holders.at(i)] = getPendingDivs(holders.at(i));
}
ended = true;
return true;
}
function getTotalPending() public view returns (uint){
uint totalPending;
for(uint i = 0; i < holders.length(); i = i.add(1)){
totalPending = totalPending.add(getPendingDivs(holders.at(i)));
}
return totalPending;
}
function getRewardsLeft() public view returns (uint){
uint _res;
if(ended){
_res = 0;
}else{
uint _totalPending = getTotalPending();
_res = allocation.sub(totalClaimedRewards).sub(_totalPending);
}
return _res;
}
function getTotalDeposited() public view returns (uint){
uint _res = 0;
for(uint i = 0; i < holders.length(); i = i.add(1)) {
_res = _res.add(depositedTokens[holders.at(i)]);
}
return _res;
}
function updateAccount(address account, bool _isStaking) internal {
uint pendingDivs = getPendingDivs(account);
if (pendingDivs > 0) {
if(_isStaking && depositedTokens[account].add(pendingDivs) <= maxStake && poolSize >= pendingDivs){
depositedTokens[account] = depositedTokens[account].add(pendingDivs);
poolSize = poolSize.sub(pendingDivs);
emit RewardsRestaked(account, pendingDivs);
}else{
require(Token(DFSG).transfer(account, pendingDivs), "Could not transfer tokens.");
emit RewardsClaimed(account, pendingDivs);
}
rewardEnded[account] = 0;
totalEarnedTokens[account] = totalEarnedTokens[account].add(pendingDivs);
totalClaimedRewards = totalClaimedRewards.add(pendingDivs);
}
lastClaimedTime[account] = block.timestamp;
}
function getPendingDivs(address _holder) public view returns (uint) {
if (!holders.contains(_holder) || depositedTokens[_holder] == 0) return 0;
uint pendingDivs;
if(!ended){
uint timeDiff = block.timestamp.sub(lastClaimedTime[_holder]);
uint stakedAmount = depositedTokens[_holder];
uint _apy = apy[_holder];
pendingDivs = stakedAmount
.mul(_apy)
.mul(timeDiff)
.div(rewardInterval)
.div(1e4);
}else{
pendingDivs = rewardEnded[_holder];
}
return pendingDivs;
}
function getNumberOfHolders() public view returns (uint) {
return holders.length();
}
function useNFT() public returns(bool){
require(holders.contains(msg.sender), "Not a staker");
require(!usedNFT[msg.sender][current_NFT_index], "NFT already used");
usedNFT[msg.sender][current_NFT_index] = true;
uint _tam = endIndexNFT.sub(startIndexNFT).add(1);
uint[] memory _nfts = new uint[](_tam);
_nfts = Token(collectionNFT).mapIDsInRange(startIndexNFT, endIndexNFT, msg.sender, 0);
require(_nfts[0] > 0, "No NFT available.");
require(Token(collectionNFT).use(_nfts[0], msg.sender));
apy[msg.sender] = apy[msg.sender].add(bonusNFT);
return true;
}
// nft must be FALSE to enter without boosting the APY
function deposit(uint amountToStake, bool nft) public returns(bool){
require(!ended, "Staking has ended");
require(amountToStake > 0, "Cannot deposit 0 Tokens");
require(amountToStake.add(depositedTokens[msg.sender]) <= maxStake, "Cannot deposit Tokens");
require(amountToStake <= poolSize, "No space available");
require(Token(DFSG).transferFrom(msg.sender, address(this), amountToStake), "Insufficient Token Allowance");
if (!holders.contains(msg.sender)) {
holders.add(msg.sender);
if(apy[msg.sender] == 0 && apy[msg.sender] != rewardRate.add(bonusNFT)){
apy[msg.sender] = rewardRate;
}
}
if(nft){
require(!usedNFT[msg.sender][current_NFT_index], "NFT already used");
if(!got_apy.contains(msg.sender)){
uint _tam = endIndexNFT.sub(startIndexNFT).add(1);
uint[] memory _nfts = new uint[](_tam);
_nfts = Token(collectionNFT).mapIDsInRange(startIndexNFT, endIndexNFT, msg.sender, 0);
require(_nfts[0] > 0, "No NFT available.");
require(Token(collectionNFT).use(_nfts[0], msg.sender), "Error using the NFT");
}
usedNFT[msg.sender][current_NFT_index] = true;
apy[msg.sender] = apy[msg.sender].add(bonusNFT);
}
updateAccount(msg.sender, true);
uint fee = amountToStake.mul(stakingFeeRate).div(1e4);
uint amountAfterFee = amountToStake.sub(fee);
require(Token(DFSG).transfer(owner, fee), "Could not transfer deposit fee.");
depositedTokens[msg.sender] = depositedTokens[msg.sender].add(amountAfterFee);
poolSize = poolSize.sub(amountAfterFee);
stakingTime[msg.sender] = block.timestamp;
emit Staked(msg.sender, amountAfterFee);
return true;
}
function getUnlockTime(address _holder) public view returns(uint){
uint _res = 0;
if(stakingTime[_holder] != 0 && block.timestamp < stakingTime[_holder].add(unstakeTime)){
_res = stakingTime[_holder].add(unstakeTime);
}
return _res;
}
function withdraw(uint amountToWithdraw) public returns(bool){
require(depositedTokens[msg.sender] >= amountToWithdraw && depositedTokens[msg.sender] > 0, "Invalid amount to withdraw");
if(!ended){
require(block.timestamp.sub(stakingTime[msg.sender]) > unstakeTime, "You recently staked, please wait before withdrawing.");
}
updateAccount(msg.sender, false);
depositedTokens[msg.sender] = depositedTokens[msg.sender].sub(amountToWithdraw);
require(Token(DFSG).transfer(msg.sender, amountToWithdraw), "Could not transfer tokens.");
poolSize = poolSize.add(amountToWithdraw);
if (holders.contains(msg.sender) && depositedTokens[msg.sender] == 0) {
holders.remove(msg.sender);
}
emit Withdrawn(msg.sender, amountToWithdraw);
return true;
}
function emergencyWithdraw(uint amountToWithdraw, bool _claimRewards) public returns(bool){
require(depositedTokens[msg.sender] >= amountToWithdraw, "Invalid amount to withdraw");
if(_claimRewards){
updateAccount(msg.sender, false);
}
depositedTokens[msg.sender] = depositedTokens[msg.sender].sub(amountToWithdraw);
uint fee = amountToWithdraw.mul(emergencyWithdrawFeeRate).div(1e4);
uint amountAfterFee = amountToWithdraw.sub(fee);
if(fee > 0){
require(Token(DFSG).transfer(owner, fee), "Could not transfer fee.");
}
require(Token(DFSG).transfer(msg.sender, amountAfterFee), "Could not transfer tokens.");
poolSize = poolSize.add(amountToWithdraw);
if (holders.contains(msg.sender) && depositedTokens[msg.sender] == 0) {
holders.remove(msg.sender);
}
emit Withdrawn(msg.sender, amountToWithdraw);
return true;
}
function avoidEmgFee() public onlyOwner returns(bool){
emergencyWithdrawFeeRate = 0;
return true;
}
function claimDivs() public returns(bool){
updateAccount(msg.sender, false);
return true;
}
function getStakersList(uint startIndex, uint endIndex) public view returns (address[] memory stakers, uint[] memory stakingTimestamps, uint[] memory lastClaimedTimeStamps, uint[] memory stakedTokens) {
require (startIndex < endIndex && holders.length() > 0 && endIndex < holders.length() , "Error getting data.");
uint length = endIndex.sub(startIndex);
address[] memory _stakers = new address[](length);
uint[] memory _stakingTimestamps = new uint[](length);
uint[] memory _lastClaimedTimeStamps = new uint[](length);
uint[] memory _stakedTokens = new uint[](length);
for (uint i = startIndex; i < endIndex; i = i.add(1)) {
address staker = holders.at(i);
uint listIndex = i.sub(startIndex);
_stakers[listIndex] = staker;
_stakingTimestamps[listIndex] = stakingTime[staker];
_lastClaimedTimeStamps[listIndex] = lastClaimedTime[staker];
_stakedTokens[listIndex] = depositedTokens[staker];
}
return (_stakers, _stakingTimestamps, _lastClaimedTimeStamps, _stakedTokens);
}
function transferAnyERC20Tokens(address _tokenAddr, address _to, uint _amount) public onlyOwner returns(bool){
require (_tokenAddr != DFSG, "Cannot Transfer Out this token");
Token(_tokenAddr).transfer(_to, _amount);
return true;
}
function transferRewardsLeft(address _to) public onlyOwner returns (bool){
require(ended, "Not available.");
uint contract_balance = Token(DFSG).balanceOf(address(this));
uint total_deposited = getTotalDeposited();
uint total_pending = getTotalPending();
require(contract_balance >= total_deposited.add(total_pending), "Can't get users funds");
uint _amount = contract_balance.sub(total_pending).sub(total_deposited);
Token(DFSG).transfer(_to, _amount);
return true;
}
function setCollection(address _new) public onlyOwner returns (bool){
collectionNFT = _new;
return true;
}
function setTokenDepositAddress(address _new) public onlyOwner returns (bool){
DFSG = _new;
return true;
}
function setAllocation(uint _new) public onlyOwner returns(bool){
allocation = _new;
return true;
}
function addSize(uint _new) public onlyOwner returns(bool){
maxPoolSize = maxPoolSize.add(_new);
poolSize = poolSize.add(_new);
return true;
}
function updateAPY(address _staker) public onlyOwner returns(bool){
require(holders.contains(_staker), "Not a staker");
require(!usedNFT[_staker][current_NFT_index], "NFT already used");
usedNFT[_staker][current_NFT_index] = true;
apy[msg.sender] = apy[msg.sender].add(bonusNFT);
return true;
}
}
| 255,352 | 13,798 |
416c6ed3bb3c9d8a690bd5f9425ca3a53ba3601beb300ff37823617fd79ee1c3
| 17,103 |
.sol
|
Solidity
| false |
451141221
|
MANDO-Project/ge-sc
|
0adf91ac5bb0ffdb9152186ed29a5fc7b0c73836
|
data/smartbugs_wild/cfg/source_code_with_test/0xcb089b8ae76b5df461d40e957603f7a59aea9e0d.sol
| 3,342 | 11,186 |
pragma solidity 0.5.0;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) internal _balances;
mapping (address => mapping (address => uint256)) private _allowed;
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) {
require(spender != address(0));
_allowed[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
function transferFrom(address from, address to, uint256 value) public returns (bool) {
_allowed[from][msg.sender] = _allowed[from][msg.sender].sub(value);
_transfer(from, to, value);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
require(spender != address(0));
_allowed[msg.sender][spender] = _allowed[msg.sender][spender].add(addedValue);
emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
require(spender != address(0));
_allowed[msg.sender][spender] = _allowed[msg.sender][spender].sub(subtractedValue);
emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
return true;
}
function _transfer(address from, address to, uint256 value) internal {
require(to != address(0));
_balances[from] = _balances[from].sub(value);
_balances[to] = _balances[to].add(value);
emit Transfer(from, to, value);
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
}
contract Claimable is Ownable {
address public pendingOwner;
modifier onlyPendingOwner() {
require(msg.sender == pendingOwner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
pendingOwner = newOwner;
}
function claimOwnership() onlyPendingOwner public {
emit OwnershipTransferred(owner, pendingOwner);
owner = pendingOwner;
pendingOwner = address(0);
}
}
contract Arroundtoken is ERC20, Claimable {
using SafeMath for uint256;
uint64 public constant TDE_FINISH = 1542326400;//!!!!Check before deploy
// 1542326400 GMT: 16 November 2018 ., 00:00:00
// 1542326399 GMT: 15 November 2018 ., 23:59:59
//////////////////////
// State var ///
//////////////////////
string public name;
string public symbol;
uint8 public decimals;
address public accTDE;
address public accFoundCDF;
address public accFoundNDF1;
address public accFoundNDF2;
address public accFoundNDF3;
address public accTeam;
address public accBounty;
// Implementation of frozen funds
mapping(address => uint64) public frozenAccounts;
//////////////
// EVENTS //
///////////////
event NewFreeze(address _acc, uint64 _timestamp);
event BatchDistrib(uint8 cnt, uint256 batchAmount);
constructor (address _accTDE,
address _accFoundCDF,
address _accFoundNDF1,
address _accFoundNDF2,
address _accFoundNDF3,
address _accTeam,
address _accBounty,
uint256 _initialSupply)
public
{
require(_accTDE != address(0));
require(_accFoundCDF != address(0));
require(_accFoundNDF1 != address(0));
require(_accFoundNDF2 != address(0));
require(_accFoundNDF3 != address(0));
require(_accTeam != address(0));
require(_accBounty != address(0));
require(_initialSupply > 0);
name = "Arround";
symbol = "ARR";
decimals = 18;
accTDE = _accTDE;
accFoundCDF = _accFoundCDF;
accFoundNDF1 = _accFoundNDF1;
accFoundNDF2 = _accFoundNDF2;
accFoundNDF3 = _accFoundNDF3;
accTeam = _accTeam;
accBounty = _accBounty;
_totalSupply = _initialSupply * (10 ** uint256(decimals));// All ARR tokens in the world
//Initial token distribution
_balances[_accTDE] = 1104000000 * (10 ** uint256(decimals)); // TDE, 36.8%=28.6+8.2
_balances[_accFoundCDF] = 1251000000 * (10 ** uint256(decimals)); // CDF, 41.7%
_balances[_accFoundNDF1] = 150000000 * (10 ** uint256(decimals)); // 0.50*NDF, 10.0%
_balances[_accFoundNDF2] = 105000000 * (10 ** uint256(decimals)); // 0.35*NDF, 10.0%
_balances[_accFoundNDF3] = 45000000 * (10 ** uint256(decimals)); // 0.15*NDF, 10.0%
_balances[_accTeam] = 300000000 * (10 ** uint256(decimals)); // team, 10.0%
_balances[_accBounty] = 45000000 * (10 ** uint256(decimals)); // Bounty, 1.5%
require(_totalSupply == 3000000000 * (10 ** uint256(decimals)), "Total Supply exceeded!!!");
emit Transfer(address(0), _accTDE, 1104000000 * (10 ** uint256(decimals)));
emit Transfer(address(0), _accFoundCDF, 1251000000 * (10 ** uint256(decimals)));
emit Transfer(address(0), _accFoundNDF1, 150000000 * (10 ** uint256(decimals)));
emit Transfer(address(0), _accFoundNDF2, 105000000 * (10 ** uint256(decimals)));
emit Transfer(address(0), _accFoundNDF3, 45000000 * (10 ** uint256(decimals)));
emit Transfer(address(0), _accTeam, 300000000 * (10 ** uint256(decimals)));
emit Transfer(address(0), _accBounty, 45000000 * (10 ** uint256(decimals)));
//initisl freeze
frozenAccounts[_accTeam] = TDE_FINISH + 31536000; //+3600*24*365 sec
frozenAccounts[_accFoundNDF2] = TDE_FINISH + 31536000; //+3600*24*365 sec
frozenAccounts[_accFoundNDF3] = TDE_FINISH + 63158400; //+(3600*24*365)*2 +3600*24(leap year 2020)
emit NewFreeze(_accTeam, TDE_FINISH + 31536000);
emit NewFreeze(_accFoundNDF2, TDE_FINISH + 31536000);
emit NewFreeze(_accFoundNDF3, TDE_FINISH + 63158400);
}
modifier onlyTokenKeeper() {
require(msg.sender == accTDE ||
msg.sender == accFoundCDF ||
msg.sender == accFoundNDF1 ||
msg.sender == accBounty);
_;
}
function() external { }
function transfer(address _to, uint256 _value) public returns (bool) {
require(frozenAccounts[msg.sender] < now);
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(frozenAccounts[_from] < now);
return super.transferFrom(_from, _to, _value);
}
function approve(address _spender, uint256 _value) public returns (bool) {
require(frozenAccounts[msg.sender] < now);
return super.approve(_spender, _value);
}
function increaseAllowance(address _spender, uint _addedValue) public returns (bool success) {
require(frozenAccounts[msg.sender] < now);
return super.increaseAllowance(_spender, _addedValue);
}
function decreaseAllowance(address _spender, uint _subtractedValue) public returns (bool success) {
require(frozenAccounts[msg.sender] < now);
return super.decreaseAllowance(_spender, _subtractedValue);
}
function multiTransfer(address[] calldata _investors, uint256[] calldata _value)
external
onlyTokenKeeper
returns (uint256 _batchAmount)
{
require(_investors.length <= 255); //audit recommendation
require(_value.length == _investors.length);
uint8 cnt = uint8(_investors.length);
uint256 amount = 0;
for (uint i=0; i<cnt; i++){
amount = amount.add(_value[i]);
require(_investors[i] != address(0));
_balances[_investors[i]] = _balances[_investors[i]].add(_value[i]);
emit Transfer(msg.sender, _investors[i], _value[i]);
}
require(amount <= _balances[msg.sender]);
_balances[msg.sender] = _balances[msg.sender].sub(amount);
emit BatchDistrib(cnt, amount);
return amount;
}
function reclaimToken(ERC20 token) external onlyOwner {
require(address(token) != address(0));
uint256 balance = token.balanceOf(address(this));
token.transfer(owner, balance);
}
}
//***************************************************************
// Based on best practice of https://github.com/Open Zeppelin/zeppelin-solidity
// Adapted and amended by IBERGroup;
// Code released under the MIT License(see git root).
////**************************************************************
| 135,585 | 13,799 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.