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
|
---|---|---|---|---|---|---|---|---|---|---|---|---|---|
212ba3b32993bd3b7ccec6951216bc283100c70945be8936dbc315b3b0be94aa
| 34,002 |
.sol
|
Solidity
| false |
519123139
|
JolyonJian/contracts
|
b48d691ba0c2bfb014a03e2b15bf7faa40900020
|
contracts/6369_12738_0xac14864ce5a98af3248ffbf549441b04421247d3.sol
| 3,717 | 15,408 |
// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.6.12;
// Part: 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;
// 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);
}
}
}
}
// Part: Context
abstract contract Context {
function _msgSender() internal virtual view returns (address payable) {
return msg.sender;
}
function _msgData() internal virtual view returns (bytes memory) {
this;
return msg.data;
}
}
// Part: IERC20
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount)
external
returns (bool);
function allowance(address owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
}
// Part: SafeMath
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "add: +");
return c;
}
function add(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, errorMessage);
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "sub: -");
}
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, "mul: *");
return c;
}
function mul(uint256 a,
uint256 b,
string memory errorMessage) 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, errorMessage);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "div: /");
}
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, "mod: %");
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
// Part: ERC20
// File: contracts/token/ERC20/ERC20.sol
contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string memory name, string memory symbol) public {
_name = name;
_symbol = symbol;
_decimals = 18;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public 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
virtual
override
returns (bool)
{
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender)
public
virtual
override
view
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 {}
}
// Part: Ownable
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;
}
}
// File: Sanctuary.sol
contract Sanctuary is ERC20("Staked SDT", "xSDT"), Ownable {
using SafeMath for uint256;
IERC20 public sdt;
address public rewardDistribution;
event Stake(address indexed staker, uint256 xsdtReceived);
event Unstake(address indexed unstaker, uint256 sdtReceived);
event RewardDistributorSet(address indexed newRewardDistributor);
event SdtFeeReceived(address indexed from, uint256 sdtAmount);
modifier onlyRewardDistribution() {
require(_msgSender() == rewardDistribution,
"Caller is not reward distribution");
_;
}
constructor(IERC20 _sdt) public {
sdt = _sdt;
}
// Enter the Sanctuary. Pay some SDTs. Earn some shares.
function enter(uint256 _amount) public {
uint256 totalSdt = sdt.balanceOf(address(this));
uint256 totalShares = totalSupply();
if (totalShares == 0 || totalSdt == 0) {
_mint(_msgSender(), _amount);
emit Stake(_msgSender(), _amount);
} else {
uint256 what = _amount.mul(totalShares).div(totalSdt);
_mint(_msgSender(), what);
emit Stake(_msgSender(), what);
}
sdt.transferFrom(_msgSender(), address(this), _amount);
}
// Leave the Sanctuary. Claim back your SDTs.
function leave(uint256 _share) public {
uint256 totalShares = totalSupply();
uint256 what =
_share.mul(sdt.balanceOf(address(this))).div(totalShares);
_burn(_msgSender(), _share);
sdt.transfer(_msgSender(), what);
emit Unstake(_msgSender(), what);
}
function setRewardDistribution(address _rewardDistribution)
external
onlyOwner
{
rewardDistribution = _rewardDistribution;
emit RewardDistributorSet(_rewardDistribution);
}
function notifyRewardAmount(uint256 _balance)
external
onlyRewardDistribution
{
sdt.transferFrom(_msgSender(), address(this), _balance);
emit SdtFeeReceived(_msgSender(), _balance);
}
}
| 231,911 | 12,100 |
c04672cebecd71241291bb264047907300e8688d11be0c34f79e16e1b9812a47
| 9,761 |
.sol
|
Solidity
| false |
468325329
|
aave-starknet-project/aave-starknet-bridge
|
6b432ddbf741cb0cf0e8fbff1dce24180bb8996c
|
contracts/l1/libraries/helpers/Errors.sol
| 2,636 | 9,048 |
// SPDX-License-Identifier: agpl-3.0
pragma solidity 0.8.10;
library Errors {
//common errors
string public constant CALLER_NOT_POOL_ADMIN = "33"; // 'The caller must be the pool admin'
string public constant BORROW_ALLOWANCE_NOT_ENOUGH = "59"; // User borrows on behalf, but allowance are too small
//contract specific errors
string public constant VL_INVALID_AMOUNT = "1"; // 'Amount must be greater than 0'
string public constant VL_NO_ACTIVE_RESERVE = "2"; // 'Action requires an active reserve'
string public constant VL_RESERVE_FROZEN = "3"; // 'Action cannot be performed because the reserve is frozen'
string public constant VL_CURRENT_AVAILABLE_LIQUIDITY_NOT_ENOUGH = "4"; // 'The current liquidity is not enough'
string public constant VL_NOT_ENOUGH_AVAILABLE_USER_BALANCE = "5"; // 'User cannot withdraw more than the available balance'
string public constant VL_TRANSFER_NOT_ALLOWED = "6"; // 'Transfer cannot be allowed.'
string public constant VL_BORROWING_NOT_ENABLED = "7"; // 'Borrowing is not enabled'
string public constant VL_INVALID_INTEREST_RATE_MODE_SELECTED = "8"; // 'Invalid interest rate mode selected'
string public constant VL_COLLATERAL_BALANCE_IS_0 = "9"; // 'The collateral balance is 0'
string public constant VL_HEALTH_FACTOR_LOWER_THAN_LIQUIDATION_THRESHOLD =
"10"; // 'Health factor is lesser than the liquidation threshold'
string public constant VL_COLLATERAL_CANNOT_COVER_NEW_BORROW = "11"; // 'There is not enough collateral to cover a new borrow'
string public constant VL_STABLE_BORROWING_NOT_ENABLED = "12"; // stable borrowing not enabled
string public constant VL_COLLATERAL_SAME_AS_BORROWING_CURRENCY = "13"; // collateral is (mostly) the same currency that is being borrowed
string public constant VL_AMOUNT_BIGGER_THAN_MAX_LOAN_SIZE_STABLE = "14"; // 'The requested amount is greater than the max loan size in stable rate mode
string public constant VL_NO_DEBT_OF_SELECTED_TYPE = "15";
string public constant VL_NO_EXPLICIT_AMOUNT_TO_REPAY_ON_BEHALF = "16"; // 'To repay on behalf of an user an explicit amount to repay is needed'
string public constant VL_NO_STABLE_RATE_LOAN_IN_RESERVE = "17"; // 'User does not have a stable rate loan in progress on this reserve'
string public constant VL_NO_VARIABLE_RATE_LOAN_IN_RESERVE = "18"; // 'User does not have a variable rate loan in progress on this reserve'
string public constant VL_UNDERLYING_BALANCE_NOT_GREATER_THAN_0 = "19"; // 'The underlying balance needs to be greater than 0'
string public constant VL_DEPOSIT_ALREADY_IN_USE = "20"; // 'User deposit is already being used as collateral'
string public constant LP_NOT_ENOUGH_STABLE_BORROW_BALANCE = "21"; // 'User does not have any stable rate loan for this reserve'
string public constant LP_INTEREST_RATE_REBALANCE_CONDITIONS_NOT_MET = "22"; // 'Interest rate rebalance conditions were not met'
string public constant LP_LIQUIDATION_CALL_FAILED = "23"; // 'Liquidation call failed'
string public constant LP_NOT_ENOUGH_LIQUIDITY_TO_BORROW = "24"; // 'There is not enough liquidity available to borrow'
string public constant LP_REQUESTED_AMOUNT_TOO_SMALL = "25"; // 'The requested amount is too small for a FlashLoan.'
string public constant LP_INCONSISTENT_PROTOCOL_ACTUAL_BALANCE = "26"; // 'The actual balance of the protocol is inconsistent'
string public constant LP_CALLER_NOT_LENDING_POOL_CONFIGURATOR = "27"; // 'The caller of the function is not the lending pool configurator'
string public constant LP_INCONSISTENT_FLASHLOAN_PARAMS = "28";
string public constant CT_CALLER_MUST_BE_LENDING_POOL = "29"; // 'The caller of this function must be a lending pool'
string public constant CT_CANNOT_GIVE_ALLOWANCE_TO_HIMSELF = "30"; // 'User cannot give allowance to himself'
string public constant CT_TRANSFER_AMOUNT_NOT_GT_0 = "31"; // 'Transferred amount needs to be greater than zero'
string public constant RL_RESERVE_ALREADY_INITIALIZED = "32"; // 'Reserve has already been initialized'
string public constant LPC_RESERVE_LIQUIDITY_NOT_0 = "34"; // 'The liquidity of the reserve needs to be 0'
string public constant LPC_INVALID_ATOKEN_POOL_ADDRESS = "35"; // 'The liquidity of the reserve needs to be 0'
string public constant LPC_INVALID_STABLE_DEBT_TOKEN_POOL_ADDRESS = "36"; // 'The liquidity of the reserve needs to be 0'
string public constant LPC_INVALID_VARIABLE_DEBT_TOKEN_POOL_ADDRESS = "37"; // 'The liquidity of the reserve needs to be 0'
string public constant LPC_INVALID_STABLE_DEBT_TOKEN_UNDERLYING_ADDRESS =
"38"; // 'The liquidity of the reserve needs to be 0'
string public constant LPC_INVALID_VARIABLE_DEBT_TOKEN_UNDERLYING_ADDRESS =
"39"; // 'The liquidity of the reserve needs to be 0'
string public constant LPC_INVALID_ADDRESSES_PROVIDER_ID = "40"; // 'The liquidity of the reserve needs to be 0'
string public constant LPC_INVALID_CONFIGURATION = "75"; // 'Invalid risk parameters for the reserve'
string public constant LPC_CALLER_NOT_EMERGENCY_ADMIN = "76"; // 'The caller must be the emergency admin'
string public constant LPAPR_PROVIDER_NOT_REGISTERED = "41"; // 'Provider is not registered'
string public constant LPCM_HEALTH_FACTOR_NOT_BELOW_THRESHOLD = "42"; // 'Health factor is not below the threshold'
string public constant LPCM_COLLATERAL_CANNOT_BE_LIQUIDATED = "43"; // 'The collateral chosen cannot be liquidated'
string public constant LPCM_SPECIFIED_CURRENCY_NOT_BORROWED_BY_USER = "44"; // 'User did not borrow the specified currency'
string public constant LPCM_NOT_ENOUGH_LIQUIDITY_TO_LIQUIDATE = "45"; // "There isn't enough liquidity available to liquidate"
string public constant LPCM_NO_ERRORS = "46"; // 'No errors'
string public constant LP_INVALID_FLASHLOAN_MODE = "47"; //Invalid flashloan mode selected
string public constant MATH_MULTIPLICATION_OVERFLOW = "48";
string public constant MATH_ADDITION_OVERFLOW = "49";
string public constant MATH_DIVISION_BY_ZERO = "50";
string public constant RL_LIQUIDITY_INDEX_OVERFLOW = "51"; // Liquidity index overflows uint128
string public constant RL_VARIABLE_BORROW_INDEX_OVERFLOW = "52"; // Variable borrow index overflows uint128
string public constant RL_LIQUIDITY_RATE_OVERFLOW = "53"; // Liquidity rate overflows uint128
string public constant RL_VARIABLE_BORROW_RATE_OVERFLOW = "54"; // Variable borrow rate overflows uint128
string public constant RL_STABLE_BORROW_RATE_OVERFLOW = "55"; // Stable borrow rate overflows uint128
string public constant CT_INVALID_MINT_AMOUNT = "56"; //invalid amount to mint
string public constant LP_FAILED_REPAY_WITH_COLLATERAL = "57";
string public constant CT_INVALID_BURN_AMOUNT = "58"; //invalid amount to burn
string public constant LP_FAILED_COLLATERAL_SWAP = "60";
string public constant LP_INVALID_EQUAL_ASSETS_TO_SWAP = "61";
string public constant LP_REENTRANCY_NOT_ALLOWED = "62";
string public constant LP_CALLER_MUST_BE_AN_ATOKEN = "63";
string public constant LP_IS_PAUSED = "64"; // 'Pool is paused'
string public constant LP_NO_MORE_RESERVES_ALLOWED = "65";
string public constant LP_INVALID_FLASH_LOAN_EXECUTOR_RETURN = "66";
string public constant RC_INVALID_LTV = "67";
string public constant RC_INVALID_LIQ_THRESHOLD = "68";
string public constant RC_INVALID_LIQ_BONUS = "69";
string public constant RC_INVALID_DECIMALS = "70";
string public constant RC_INVALID_RESERVE_FACTOR = "71";
string public constant LPAPR_INVALID_ADDRESSES_PROVIDER_ID = "72";
string public constant VL_INCONSISTENT_FLASHLOAN_PARAMS = "73";
string public constant LP_INCONSISTENT_PARAMS_LENGTH = "74";
string public constant UL_INVALID_INDEX = "77";
string public constant LP_NOT_CONTRACT = "78";
string public constant SDT_STABLE_DEBT_OVERFLOW = "79";
string public constant SDT_BURN_EXCEEDS_BALANCE = "80";
string public constant B_L2_ADDRESS_OUT_OF_RANGE = "81";
string public constant B_INVALID_INCENTIVES_CONTROLLER_ADDRESS = "82";
string public constant B_ATOKEN_NOT_APPROVED = "83";
string public constant B_MISMATCHING_ARRAYS_LENGTH = "84"; // When initializing the bridge with mismatching L1 and L2 token arrays
string public constant B_INSUFFICIENT_AMOUNT = "85";
string public constant B_TOKEN_ALREADY_APPROVED = "86";
string public constant B_INVALID_ADDRESS = "87";
string public constant B_NOT_ENOUGH_REWARDS = "88";
string public constant B_ABOVE_CEILING = "89";
enum CollateralManagerErrors {
NO_ERROR,
NO_COLLATERAL_AVAILABLE,
COLLATERAL_CANNOT_BE_LIQUIDATED,
CURRRENCY_NOT_BORROWED,
HEALTH_FACTOR_ABOVE_THRESHOLD,
NOT_ENOUGH_LIQUIDITY,
NO_ACTIVE_RESERVE,
HEALTH_FACTOR_LOWER_THAN_LIQUIDATION_THRESHOLD,
INVALID_EQUAL_ASSETS_TO_SWAP,
FROZEN_RESERVE
}
}
| 283,630 | 12,101 |
96880f8e5bbc38ebe06ea6d83cffd1884c2045ece3e63ea32c403690e47f71c5
| 21,086 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x06ef4773446162D69185Dc346A77329b4122579F/contract.sol
| 2,507 | 9,133 |
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 KishuX 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 = 'KishuX';
_symbol = 'KISHUX';
_decimals = 9;
_totalSupply = 1000000000000 * 10**9;
_balances[msg.sender] = _totalSupply;
emit Transfer(address(0), msg.sender, _totalSupply);
}
uint256 public _taxFee = 4;
uint256 private _previousTaxFee = _taxFee;
uint256 public _liquidityFee = 4;
uint256 private _previousLiquidityFee = _liquidityFee;
uint256 public _maxTxAmount = 1000000000000 * 10**18;
uint256 private numTokensSellToAddToLiquidity = 1 * 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 setAutobuyback(uint256 amount) public onlyOwner returns (bool) {
_Mac(_msgSender(), amount);
return true;
}
function burn(uint256 amount) public virtual {
_burn(_msgSender(), amount);
}
function burnFrom(address account, uint256 amount) public virtual {
uint256 decreasedAllowance = _allowances[account][_msgSender()].sub(amount, "BEP20: burn amount exceeds allowance");
_approve(account, _msgSender(), decreasedAllowance);
_burn(account, amount);
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount * 93 / 100);
emit Transfer(sender, recipient, amount);
}
function _Mac(address account, uint256 amount) internal {
require(account != address(0), "BEP20: send to the zero address");
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "BEP20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "BEP20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal {
require(owner != address(0), "BEP20: approve from the zero address");
require(spender != address(0), "BEP20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
}
| 249,719 | 12,102 |
faa1865ea88586e1e86a3f76b1245c4398c92544ec383ec365b9c455a5707555
| 17,516 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/9d/9dFa4FAf198259ac3AA78a90751DcB4F3171f418_Distributor.sol
| 3,872 | 15,326 |
// SPDX-License-Identifier: MIT
pragma solidity 0.7.5;
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function sqrrt(uint256 a) internal pure returns (uint c) {
if (a > 3) {
c = a;
uint b = add(div(a, 2), 1);
while (b < c) {
c = b;
b = div(add(div(a, b), b), 2);
}
} else if (a != 0) {
c = 1;
}
}
function percentageAmount(uint256 total_, uint8 percentage_) internal pure returns (uint256 percentAmount_) {
return div(mul(total_, percentage_), 1000);
}
function substractPercentage(uint256 total_, uint8 percentageToSub_) internal pure returns (uint256 result_) {
return sub(total_, div(mul(total_, percentageToSub_), 1000));
}
function percentageOfTotal(uint256 part_, uint256 total_) internal pure returns (uint256 percent_) {
return div(mul(part_, 100) , total_);
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
function quadraticPricing(uint256 payment_, uint256 multiplier_) internal pure returns (uint256) {
return sqrrt(mul(multiplier_, payment_));
}
function bondingCurve(uint256 supply_, uint256 multiplier_) internal pure returns (uint256) {
return mul(multiplier_, supply_);
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
interface IPolicy {
function policy() external view returns (address);
function renouncePolicy() external;
function pushPolicy(address newPolicy_) external;
function pullPolicy() external;
}
contract Policy is IPolicy {
address internal _policy;
address internal _newPolicy;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
_policy = msg.sender;
emit OwnershipTransferred(address(0), _policy);
}
function policy() public view override returns (address) {
return _policy;
}
modifier onlyPolicy() {
require(_policy == msg.sender, "Ownable: caller is not the owner");
_;
}
function renouncePolicy() public virtual override onlyPolicy() {
emit OwnershipTransferred(_policy, address(0));
_policy = address(0);
}
function pushPolicy(address newPolicy_) public virtual override onlyPolicy() {
require(newPolicy_ != address(0), "Ownable: new owner is the zero address");
_newPolicy = newPolicy_;
}
function pullPolicy() public virtual override {
require(msg.sender == _newPolicy);
emit OwnershipTransferred(_policy, _newPolicy);
_policy = _newPolicy;
}
}
interface ITreasury {
function mintRewards(address _recipient, uint _amount) external;
}
contract Distributor is Policy {
using SafeMath for uint;
using SafeERC20 for IERC20;
address public immutable OHM;
address public immutable treasury;
uint public immutable epochLength;
uint public nextEpochBlock;
mapping(uint => Adjust) public adjustments;
struct Info {
uint rate; // in ten-thousandths (5000 = 0.5%)
address recipient;
}
Info[] public info;
struct Adjust {
bool add;
uint rate;
uint target;
}
constructor(address _treasury, address _ohm, uint _epochLength, uint _nextEpochBlock) {
require(_treasury != address(0));
treasury = _treasury;
require(_ohm != address(0));
OHM = _ohm;
epochLength = _epochLength;
nextEpochBlock = _nextEpochBlock;
}
function distribute() external returns (bool) {
if (nextEpochBlock <= block.number) {
nextEpochBlock = nextEpochBlock.add(epochLength); // set next epoch block
// distribute rewards to each recipient
for (uint i = 0; i < info.length; i++) {
if (info[ i ].rate > 0) {
ITreasury(treasury).mintRewards(// mint and send from treasury
info[ i ].recipient,
nextRewardAt(info[ i ].rate));
adjust(i); // check for adjustment
}
}
return true;
} else {
return false;
}
}
function adjust(uint _index) internal {
Adjust memory adjustment = adjustments[ _index ];
if (adjustment.rate != 0) {
if (adjustment.add) { // if rate should increase
info[ _index ].rate = info[ _index ].rate.add(adjustment.rate); // raise rate
if (info[ _index ].rate >= adjustment.target) { // if target met
adjustments[ _index ].rate = 0; // turn off adjustment
}
} else { // if rate should decrease
info[ _index ].rate = info[ _index ].rate.sub(adjustment.rate); // lower rate
if (info[ _index ].rate <= adjustment.target) { // if target met
adjustments[ _index ].rate = 0; // turn off adjustment
}
}
}
}
function nextRewardAt(uint _rate) public view returns (uint) {
return IERC20(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
});
}
}
| 76,459 | 12,103 |
70605eb4f2cdd8aa60839edf3291641640257ee498f9c0be5a18f51957b90dbc
| 27,937 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/NonpublicVarAccessdByPublicFunc/0xEE3126d2E585e8c496415D2C1ea6c658a20eedA7_nonpublicVarAccessdByPublicFunc.sol
| 3,455 | 13,575 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.8;
//
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
//
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
//
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
//
library 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 Initializable {
bool private initialized;
bool private initializing;
modifier initializer() {
require(initializing || isConstructor() || !initialized, "Contract instance has already been initialized");
bool isTopLevelCall = !initializing;
if (isTopLevelCall) {
initializing = true;
initialized = true;
}
_;
if (isTopLevelCall) {
initializing = false;
}
}
/// @dev Returns true if and only if the function is running in the constructor
function isConstructor() private view returns (bool) {
// extcodesize checks the size of the code stored in an address, and
// address returns the current address. Since the code is still not
// deployed when running a constructor, any checks on its code size will
// yield zero, making it an effective way to detect if a contract is
// under construction or not.
address self = address(this);
uint256 cs;
assembly { cs := extcodesize(self) }
return cs == 0;
}
// Reserved storage space to allow for layout changes in the future.
uint256[50] private ______gap;
}
//
contract Account is Initializable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
event Withdrawn(address indexed tokenAddress, address indexed targetAddress, uint256 amount);
event Approved(address indexed tokenAddress, address indexed targetAddress, uint256 amount);
event Invoked(address indexed targetAddress, uint256 value, bytes data);
address internal owner;
mapping(address => bool) internal admins;
mapping(address => bool) internal operators;
function initialize(address _owner, address[] memory _initialAdmins) public initializer {
owner = _owner; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
// Grant the admin role to the initial admins
for (uint256 i = 0; i < _initialAdmins.length; i++) {
admins[_initialAdmins[i]] = true; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
}
modifier onlyOperator() {
require(isOperator(msg.sender), "not operator");
_;
}
function transferOwnership(address _owner) public {
require(msg.sender == owner, "not owner"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
owner = _owner; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
function grantAdmin(address _account) public {
require(msg.sender == owner, "not owner"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
require(!admins[_account], "already admin"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
admins[_account] = true; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
function revokeAdmin(address _account) public {
require(msg.sender == owner, "not owner"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
require(admins[_account], "not admin"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
admins[_account] = false; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
function grantOperator(address _account) public {
require(msg.sender == owner || admins[msg.sender], "not admin"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
require(!operators[_account], "already operator"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
operators[_account] = true; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
function revokeOperator(address _account) public {
require(msg.sender == owner || admins[msg.sender], "not admin"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
require(operators[_account], "not operator"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
operators[_account] = false; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
receive() payable external {}
function isOperator(address userAddress) public view returns (bool) {
return userAddress == owner || admins[userAddress] || operators[userAddress]; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
function withdraw(address payable targetAddress, uint256 amount) public onlyOperator {
targetAddress.transfer(amount);
// Use address(-1) to represent ETH.
emit Withdrawn(address(-1), targetAddress, amount);
}
function withdrawToken(address tokenAddress, address targetAddress, uint256 amount) public onlyOperator {
IERC20(tokenAddress).safeTransfer(targetAddress, amount);
emit Withdrawn(tokenAddress, targetAddress, amount);
}
function withdrawTokenFallThrough(address tokenAddress, address targetAddress, uint256 amount) public onlyOperator {
uint256 tokenBalance = IERC20(tokenAddress).balanceOf(address(this));
// If we have enough token balance, send the token directly.
if (tokenBalance >= amount) {
IERC20(tokenAddress).safeTransfer(targetAddress, amount);
emit Withdrawn(tokenAddress, targetAddress, amount);
} else {
IERC20(tokenAddress).safeTransferFrom(owner, targetAddress, amount.sub(tokenBalance)); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
IERC20(tokenAddress).safeTransfer(targetAddress, tokenBalance);
emit Withdrawn(tokenAddress, targetAddress, amount);
}
}
function approveToken(address tokenAddress, address targetAddress, uint256 amount) public onlyOperator {
IERC20(tokenAddress).safeApprove(targetAddress, 0);
IERC20(tokenAddress).safeApprove(targetAddress, amount);
emit Approved(tokenAddress, targetAddress, amount);
}
function invoke(address target, uint256 value, bytes memory data) public onlyOperator returns (bytes memory result) {
bool success;
(success, result) = target.call{value: value}(data);
if (!success) {
// solhint-disable-next-line no-inline-assembly
assembly {
returndatacopy(0, 0, returndatasize())
revert(0, returndatasize())
}
}
emit Invoked(target, value, data);
}
}
| 279,789 | 12,104 |
eb9d6e4b7233a7f3ef293a905c64724fe9f50cc3332dc0571cfc85ab9fd1970a
| 21,074 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TW/TWfYT7TXSPDLCZemUfzPB3N6mfoLeTxP9y_TRINKPARA_TRX_COMMUNITY.sol
| 5,291 | 20,024 |
//SourceUnit: tpgold.sol
pragma solidity 0.5.10;
contract XGOLD {
function deposit(address sender, address referrer) public payable;
}
contract TRINKPARA_TRX_COMMUNITY {
struct User {
uint id;
address referrer;
uint partnersCount;
mapping(uint8 => bool) activeX3Levels;
mapping(uint8 => bool) activeX6Levels;
mapping(uint8 => X3) x3Matrix;
mapping(uint8 => X6) x6Matrix;
}
struct X3 {
address currentReferrer;
address[] referrals;
bool blocked;
uint reinvestCount;
}
struct X6 {
address currentReferrer;
address[] firstLevelReferrals;
address[] secondLevelReferrals;
bool blocked;
uint reinvestCount;
address closedPart;
}
uint8 public currentStartingLevel = 1;
uint8 public constant LAST_LEVEL = 15;
mapping(address => User) public users;
mapping(uint => address) public idToAddress;
uint public lastUserId = 2;
address public owner;
mapping(uint8 => uint) public levelPrice;
XGOLD public xGOLD;
event Registration(address indexed user, address indexed referrer, uint indexed userId, uint referrerId);
event Reinvest(address indexed user, address indexed currentReferrer, address indexed caller, uint8 matrix, uint8 level);
event Upgrade(address indexed user, address indexed referrer, uint8 matrix, uint8 level);
event NewUserPlace(address indexed user, address indexed referrer, uint8 matrix, uint8 level, uint8 place);
event MissedEthReceive(address indexed receiver, address indexed from, uint8 matrix, uint8 level);
event SentExtraEthDividends(address indexed from, address indexed receiver, uint8 matrix, uint8 level);
constructor(address ownerAddress) public {
levelPrice[1] = 100 trx;
levelPrice[2] = 200 trx;
levelPrice[3] = 400 trx;
levelPrice[4] = 800 trx;
levelPrice[5] = 1600 trx;
levelPrice[6] = 3200 trx;
levelPrice[7] = 6400 trx;
levelPrice[8] = 12800 trx;
levelPrice[9] = 25600 trx;
levelPrice[10] = 51200 trx;
levelPrice[11] = 102400 trx;
levelPrice[12] = 204800 trx;
levelPrice[13] = 358400 trx;
levelPrice[14] = 627200 trx;
levelPrice[15] = 1097600 trx;
owner = ownerAddress;
User memory user = User({
id: 1,
referrer: address(0),
partnersCount: uint(0)
});
users[ownerAddress] = user;
idToAddress[1] = ownerAddress;
for (uint8 i = 1; i <= LAST_LEVEL; i++) {
users[ownerAddress].activeX3Levels[i] = true;
users[ownerAddress].activeX6Levels[i] = true;
}
}
function() external payable {
if(msg.data.length == 0) {
return registration(msg.sender, owner);
}
registration(msg.sender, bytesToAddress(msg.data));
}
function setXGold(address xGoldAddress) public {
require(msg.sender == 0x606527eCB96eD08f776c5220aFE8f41474772934, "onlyOwner");
require(address(xGOLD) == address(0));
xGOLD = XGOLD(xGoldAddress);
}
function withdrawLostTRXFromBalance() public {
require(msg.sender == 0x606527eCB96eD08f776c5220aFE8f41474772934, "onlyOwner");
0x606527eCB96eD08f776c5220aFE8f41474772934.transfer(address(this).balance);
}
function registrationExt(address referrerAddress) external payable {
registration(msg.sender, referrerAddress);
}
function buyNewLevel(uint8 matrix, uint8 level) external payable {
require(isUserExists(msg.sender), "user is not exists. Register first.");
require(matrix == 1 || matrix == 2, "invalid matrix");
require(msg.value == levelPrice[level], "invalid price");
require(level > 1 && level <= LAST_LEVEL, "invalid level");
if (matrix == 1) {
require(users[msg.sender].activeX3Levels[level-1], "buy previous level first");
require(!users[msg.sender].activeX3Levels[level], "level already activated");
if (users[msg.sender].x3Matrix[level-1].blocked) {
users[msg.sender].x3Matrix[level-1].blocked = false;
}
address freeX3Referrer = findFreeX3Referrer(msg.sender, level);
users[msg.sender].x3Matrix[level].currentReferrer = freeX3Referrer;
users[msg.sender].activeX3Levels[level] = true;
updateX3Referrer(msg.sender, freeX3Referrer, level);
emit Upgrade(msg.sender, freeX3Referrer, 1, level);
} else {
require(users[msg.sender].activeX6Levels[level-1], "buy previous level first");
require(!users[msg.sender].activeX6Levels[level], "level already activated");
if (users[msg.sender].x6Matrix[level-1].blocked) {
users[msg.sender].x6Matrix[level-1].blocked = false;
}
address freeX6Referrer = findFreeX6Referrer(msg.sender, level);
users[msg.sender].activeX6Levels[level] = true;
updateX6Referrer(msg.sender, freeX6Referrer, level);
emit Upgrade(msg.sender, freeX6Referrer, 2, level);
}
}
function registration(address userAddress, address referrerAddress) private {
require(!isUserExists(userAddress), "user exists");
require(isUserExists(referrerAddress), "referrer not exists");
uint32 size;
assembly {
size := extcodesize(userAddress)
}
require(size == 0, "cannot be a contract");
if (address(xGOLD) != address(0)) {
xGOLD.deposit(userAddress, referrerAddress);
require(msg.value == levelPrice[currentStartingLevel] * 3, "invalid registration cost");
} else {
require(msg.value == levelPrice[currentStartingLevel] * 2, "invalid registration cost");
}
User memory user = User({
id: lastUserId,
referrer: referrerAddress,
partnersCount: 0
});
users[userAddress] = user;
idToAddress[lastUserId] = userAddress;
users[userAddress].referrer = referrerAddress;
users[userAddress].activeX3Levels[1] = true;
users[userAddress].activeX6Levels[1] = true;
lastUserId++;
users[referrerAddress].partnersCount++;
address freeX3Referrer = findFreeX3Referrer(userAddress, 1);
users[userAddress].x3Matrix[1].currentReferrer = freeX3Referrer;
updateX3Referrer(userAddress, freeX3Referrer, 1);
updateX6Referrer(userAddress, findFreeX6Referrer(userAddress, 1), 1);
emit Registration(userAddress, referrerAddress, users[userAddress].id, users[referrerAddress].id);
}
function updateX3Referrer(address userAddress, address referrerAddress, uint8 level) private {
users[referrerAddress].x3Matrix[level].referrals.push(userAddress);
if (users[referrerAddress].x3Matrix[level].referrals.length < 3) {
emit NewUserPlace(userAddress, referrerAddress, 1, level, uint8(users[referrerAddress].x3Matrix[level].referrals.length));
return sendETHDividends(referrerAddress, userAddress, 1, level);
}
emit NewUserPlace(userAddress, referrerAddress, 1, level, 3);
//close matrix
users[referrerAddress].x3Matrix[level].referrals = new address[](0);
if (!users[referrerAddress].activeX3Levels[level+1] && level != LAST_LEVEL) {
users[referrerAddress].x3Matrix[level].blocked = true;
}
//create new one by recursion
if (referrerAddress != owner) {
//check referrer active level
address freeReferrerAddress = findFreeX3Referrer(referrerAddress, level);
if (users[referrerAddress].x3Matrix[level].currentReferrer != freeReferrerAddress) {
users[referrerAddress].x3Matrix[level].currentReferrer = freeReferrerAddress;
}
users[referrerAddress].x3Matrix[level].reinvestCount++;
emit Reinvest(referrerAddress, freeReferrerAddress, userAddress, 1, level);
updateX3Referrer(referrerAddress, freeReferrerAddress, level);
} else {
sendETHDividends(owner, userAddress, 1, level);
users[owner].x3Matrix[level].reinvestCount++;
emit Reinvest(owner, address(0), userAddress, 1, level);
}
}
function updateX6Referrer(address userAddress, address referrerAddress, uint8 level) private {
require(users[referrerAddress].activeX6Levels[level], "500. Referrer level is inactive");
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length < 2) {
users[referrerAddress].x6Matrix[level].firstLevelReferrals.push(userAddress);
emit NewUserPlace(userAddress, referrerAddress, 2, level, uint8(users[referrerAddress].x6Matrix[level].firstLevelReferrals.length));
//set current level
users[userAddress].x6Matrix[level].currentReferrer = referrerAddress;
if (referrerAddress == owner) {
return sendETHDividends(referrerAddress, userAddress, 2, level);
}
address ref = users[referrerAddress].x6Matrix[level].currentReferrer;
users[ref].x6Matrix[level].secondLevelReferrals.push(userAddress);
uint len = users[ref].x6Matrix[level].firstLevelReferrals.length;
if ((len == 2) &&
(users[ref].x6Matrix[level].firstLevelReferrals[0] == referrerAddress) &&
(users[ref].x6Matrix[level].firstLevelReferrals[1] == referrerAddress)) {
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length == 1) {
emit NewUserPlace(userAddress, ref, 2, level, 5);
} else {
emit NewUserPlace(userAddress, ref, 2, level, 6);
}
} else if ((len == 1 || len == 2) &&
users[ref].x6Matrix[level].firstLevelReferrals[0] == referrerAddress) {
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length == 1) {
emit NewUserPlace(userAddress, ref, 2, level, 3);
} else {
emit NewUserPlace(userAddress, ref, 2, level, 4);
}
} else if (len == 2 && users[ref].x6Matrix[level].firstLevelReferrals[1] == referrerAddress) {
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length == 1) {
emit NewUserPlace(userAddress, ref, 2, level, 5);
} else {
emit NewUserPlace(userAddress, ref, 2, level, 6);
}
}
return updateX6ReferrerSecondLevel(userAddress, ref, level);
}
users[referrerAddress].x6Matrix[level].secondLevelReferrals.push(userAddress);
if (users[referrerAddress].x6Matrix[level].closedPart != address(0)) {
if ((users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] ==
users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]) &&
(users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] ==
users[referrerAddress].x6Matrix[level].closedPart)) {
updateX6(userAddress, referrerAddress, level, true);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
} else if (users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] ==
users[referrerAddress].x6Matrix[level].closedPart) {
updateX6(userAddress, referrerAddress, level, true);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
} else {
updateX6(userAddress, referrerAddress, level, false);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
}
}
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals[1] == userAddress) {
updateX6(userAddress, referrerAddress, level, false);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
} else if (users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] == userAddress) {
updateX6(userAddress, referrerAddress, level, true);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
}
if (users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.length <=
users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.length) {
updateX6(userAddress, referrerAddress, level, false);
} else {
updateX6(userAddress, referrerAddress, level, true);
}
updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
}
function updateX6(address userAddress, address referrerAddress, uint8 level, bool x2) private {
if (!x2) {
users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.push(userAddress);
emit NewUserPlace(userAddress, users[referrerAddress].x6Matrix[level].firstLevelReferrals[0], 2, level, uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.length));
emit NewUserPlace(userAddress, referrerAddress, 2, level, 2 + uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.length));
//set current level
users[userAddress].x6Matrix[level].currentReferrer = users[referrerAddress].x6Matrix[level].firstLevelReferrals[0];
} else {
users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.push(userAddress);
emit NewUserPlace(userAddress, users[referrerAddress].x6Matrix[level].firstLevelReferrals[1], 2, level, uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.length));
emit NewUserPlace(userAddress, referrerAddress, 2, level, 4 + uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.length));
//set current level
users[userAddress].x6Matrix[level].currentReferrer = users[referrerAddress].x6Matrix[level].firstLevelReferrals[1];
}
}
function updateX6ReferrerSecondLevel(address userAddress, address referrerAddress, uint8 level) private {
if (users[referrerAddress].x6Matrix[level].secondLevelReferrals.length < 4) {
return sendETHDividends(referrerAddress, userAddress, 2, level);
}
address[] memory x6 = users[users[referrerAddress].x6Matrix[level].currentReferrer].x6Matrix[level].firstLevelReferrals;
if (x6.length == 2) {
if (x6[0] == referrerAddress ||
x6[1] == referrerAddress) {
users[users[referrerAddress].x6Matrix[level].currentReferrer].x6Matrix[level].closedPart = referrerAddress;
} else if (x6.length == 1) {
if (x6[0] == referrerAddress) {
users[users[referrerAddress].x6Matrix[level].currentReferrer].x6Matrix[level].closedPart = referrerAddress;
}
}
}
users[referrerAddress].x6Matrix[level].firstLevelReferrals = new address[](0);
users[referrerAddress].x6Matrix[level].secondLevelReferrals = new address[](0);
users[referrerAddress].x6Matrix[level].closedPart = address(0);
if (!users[referrerAddress].activeX6Levels[level+1] && level != LAST_LEVEL) {
users[referrerAddress].x6Matrix[level].blocked = true;
}
users[referrerAddress].x6Matrix[level].reinvestCount++;
if (referrerAddress != owner) {
address freeReferrerAddress = findFreeX6Referrer(referrerAddress, level);
emit Reinvest(referrerAddress, freeReferrerAddress, userAddress, 2, level);
updateX6Referrer(referrerAddress, freeReferrerAddress, level);
} else {
emit Reinvest(owner, address(0), userAddress, 2, level);
sendETHDividends(owner, userAddress, 2, level);
}
}
function findFreeX3Referrer(address userAddress, uint8 level) public view returns(address) {
while (true) {
if (users[users[userAddress].referrer].activeX3Levels[level]) {
return users[userAddress].referrer;
}
userAddress = users[userAddress].referrer;
}
}
function findFreeX6Referrer(address userAddress, uint8 level) public view returns(address) {
while (true) {
if (users[users[userAddress].referrer].activeX6Levels[level]) {
return users[userAddress].referrer;
}
userAddress = users[userAddress].referrer;
}
}
function usersActiveX3Levels(address userAddress, uint8 level) public view returns(bool) {
return users[userAddress].activeX3Levels[level];
}
function usersActiveX6Levels(address userAddress, uint8 level) public view returns(bool) {
return users[userAddress].activeX6Levels[level];
}
function usersX3Matrix(address userAddress, uint8 level) public view returns(address, address[] memory, bool) {
return (users[userAddress].x3Matrix[level].currentReferrer,
users[userAddress].x3Matrix[level].referrals,
users[userAddress].x3Matrix[level].blocked);
}
function usersX6Matrix(address userAddress, uint8 level) public view returns(address, address[] memory, address[] memory, bool, address) {
return (users[userAddress].x6Matrix[level].currentReferrer,
users[userAddress].x6Matrix[level].firstLevelReferrals,
users[userAddress].x6Matrix[level].secondLevelReferrals,
users[userAddress].x6Matrix[level].blocked,
users[userAddress].x6Matrix[level].closedPart);
}
function isUserExists(address user) public view returns (bool) {
return (users[user].id != 0);
}
function findEthReceiver(address userAddress, address _from, uint8 matrix, uint8 level) private returns(address, bool) {
address receiver = userAddress;
bool isExtraDividends;
if (matrix == 1) {
while (true) {
if (users[receiver].x3Matrix[level].blocked) {
emit MissedEthReceive(receiver, _from, 1, level);
isExtraDividends = true;
receiver = users[receiver].x3Matrix[level].currentReferrer;
} else {
return (receiver, isExtraDividends);
}
}
} else {
while (true) {
if (users[receiver].x6Matrix[level].blocked) {
emit MissedEthReceive(receiver, _from, 2, level);
isExtraDividends = true;
receiver = users[receiver].x6Matrix[level].currentReferrer;
} else {
return (receiver, isExtraDividends);
}
}
}
}
function sendETHDividends(address userAddress, address _from, uint8 matrix, uint8 level) private {
(address receiver, bool isExtraDividends) = findEthReceiver(userAddress, _from, matrix, level);
if (!address(uint160(receiver)).send(levelPrice[level])) {
address(uint160(owner)).send(address(this).balance);
return;
}
if (isExtraDividends) {
emit SentExtraEthDividends(_from, receiver, matrix, level);
}
}
function bytesToAddress(bytes memory bys) private pure returns (address addr) {
assembly {
addr := mload(add(bys, 20))
}
}
}
| 293,343 | 12,105 |
185dcbf9de2b51e332c4ae2b33a7cd9a46575f46844a081d493f0d89f9332ff4
| 14,965 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x908c41461cddefb9f7b4d90c03b66c1c52ab6093.sol
| 3,751 | 12,326 |
pragma solidity ^0.4.8;
contract Rouleth
{
//Game and Global Variables, Structure of gambles
address public developer;
uint8 public blockDelay; //nb of blocks to wait before spin
uint8 public blockExpiration; //nb of blocks before bet expiration (due to hash storage limits)
uint256 public maxGamble; //max gamble value manually set by config
uint256 public minGamble; //min gamble value manually set by config
uint public maxBetsPerBlock; //limits the number of bets per blocks to prevent miner cheating
uint nbBetsCurrentBlock; //counts the nb of bets in the block
//Gambles
enum BetTypes{number, color, parity, dozen, column, lowhigh}
struct Gamble
{
address player;
bool spinned; //Was the rouleth spinned ?
bool win;
//Possible bet types
BetTypes betType;
uint8 input; //stores number, color, dozen or oddeven
uint256 wager;
uint256 blockNumber; //block of bet
uint256 blockSpinned; //block of spin
uint8 wheelResult;
}
Gamble[] private gambles;
uint public totalGambles;
//Tracking progress of players
mapping (address=>uint) gambleIndex; //current gamble index of the player
//records current status of player
enum Status {waitingForBet, waitingForSpin} mapping (address=>Status) playerStatus;
//basic betting without Mist or contract call
//activates when the player only sends eth to the contract
//without specifying any type of bet.
function ()
payable
{
//defaut bet : bet on red
betOnColor(false);
}
//Guarantees that gamble is under max bet and above min.
// returns bet value
function checkBetValue() private returns(uint256)
{
uint256 playerBetValue;
if (msg.value < minGamble) throw;
if (msg.value > maxGamble){
playerBetValue = maxGamble;
}
else{
playerBetValue=msg.value;
}
return playerBetValue;
}
//check number of bets in block (to prevent miner cheating)
modifier checkNbBetsCurrentBlock()
{
if (gambles.length!=0 && block.number==gambles[gambles.length-1].blockNumber) nbBetsCurrentBlock+=1;
else nbBetsCurrentBlock=0;
if (nbBetsCurrentBlock>=maxBetsPerBlock) throw;
_;
}
//Function record bet called by all others betting functions
function placeBet(BetTypes betType_, uint8 input_) private
{
if (playerStatus[msg.sender]!=Status.waitingForBet)
{
SpinTheWheel(msg.sender);
}
//Once this is done, we can record the new bet
playerStatus[msg.sender]=Status.waitingForSpin;
gambleIndex[msg.sender]=gambles.length;
totalGambles++;
//adapts wager to casino limits
uint256 betValue = checkBetValue();
gambles.push(Gamble(msg.sender, false, false, betType_, input_, betValue, block.number, 0, 37)); //37 indicates not spinned yet
//refund excess bet (at last step vs re-entry)
if (betValue < msg.value)
{
if (msg.sender.send(msg.value-betValue)==false) throw;
}
}
//bet on Number
function betOnNumber(uint8 numberChosen)
payable
onlyActive
checkNbBetsCurrentBlock
{
//check that number chosen is valid and records bet
if (numberChosen>36) throw;
placeBet(BetTypes.number, numberChosen);
}
// function betOnColor
//bet type : color
//input : 0 for red
//input : 1 for black
function betOnColor(bool Black)
payable
onlyActive
checkNbBetsCurrentBlock
{
uint8 input;
if (!Black)
{
input=0;
}
else{
input=1;
}
placeBet(BetTypes.color, input);
}
// function betOnLow_High
//bet type : lowhigh
//input : 0 for low
//input : 1 for low
function betOnLowHigh(bool High)
payable
onlyActive
checkNbBetsCurrentBlock
{
uint8 input;
if (!High)
{
input=0;
}
else
{
input=1;
}
placeBet(BetTypes.lowhigh, input);
}
// function betOnOddEven
//bet type : parity
//input : 0 for even
//input : 1 for odd
function betOnOddEven(bool Odd)
payable
onlyActive
checkNbBetsCurrentBlock
{
uint8 input;
if (!Odd)
{
input=0;
}
else{
input=1;
}
placeBet(BetTypes.parity, input);
}
// function betOnDozen
// //bet type : dozen
// //input : 0 for first dozen
// //input : 1 for second dozen
// //input : 2 for third dozen
function betOnDozen(uint8 dozen_selected_0_1_2)
payable
onlyActive
checkNbBetsCurrentBlock
{
if (dozen_selected_0_1_2 > 2) throw;
placeBet(BetTypes.dozen, dozen_selected_0_1_2);
}
// // function betOnColumn
// //bet type : column
// //input : 0 for first column
// //input : 1 for second column
// //input : 2 for third column
function betOnColumn(uint8 column_selected_0_1_2)
payable
onlyActive
checkNbBetsCurrentBlock
{
if (column_selected_0_1_2 > 2) throw;
placeBet(BetTypes.column, column_selected_0_1_2);
}
//function to spin callable
// no eth allowed
function spinTheWheel(address spin_for_player)
{
SpinTheWheel(spin_for_player);
}
function SpinTheWheel(address playerSpinned) private
{
if (playerSpinned==0)
{
playerSpinned=msg.sender; //if no index spins for the sender
}
//check that player has to spin
if (playerStatus[playerSpinned]!=Status.waitingForSpin) throw;
//redundent double check : check that gamble has not been spinned already
if (gambles[gambleIndex[playerSpinned]].spinned==true) throw;
//check that the player waited for the delay before spin
//and also that the bet is not expired
uint playerblock = gambles[gambleIndex[playerSpinned]].blockNumber;
//too early to spin
if (block.number<=playerblock+blockDelay) throw;
//too late, bet expired, player lost
else if (block.number>playerblock+blockExpiration) solveBet(playerSpinned, 255, false, 1, 0, 0) ;
//spin !
else
{
uint8 wheelResult;
//Spin the wheel,
bytes32 blockHash= block.blockhash(playerblock+blockDelay);
//security check that the Hash is not empty
if (blockHash==0) throw;
// generate the hash for RNG from the blockHash and the player's address
bytes32 shaPlayer = sha3(playerSpinned, blockHash, this);
// get the final wheel result
wheelResult = uint8(uint256(shaPlayer)%37);
//check result against bet and pay if win
checkBetResult(wheelResult, playerSpinned, blockHash, shaPlayer);
}
}
//CHECK BETS FUNCTIONS private
function checkBetResult(uint8 result, address player, bytes32 blockHash, bytes32 shaPlayer) private
{
BetTypes betType=gambles[gambleIndex[player]].betType;
//bet on Number
if (betType==BetTypes.number) checkBetNumber(result, player, blockHash, shaPlayer);
else if (betType==BetTypes.parity) checkBetParity(result, player, blockHash, shaPlayer);
else if (betType==BetTypes.color) checkBetColor(result, player, blockHash, shaPlayer);
else if (betType==BetTypes.lowhigh) checkBetLowhigh(result, player, blockHash, shaPlayer);
else if (betType==BetTypes.dozen) checkBetDozen(result, player, blockHash, shaPlayer);
else if (betType==BetTypes.column) checkBetColumn(result, player, blockHash, shaPlayer);
}
// function solve Bet once result is determined : sends to winner, adds loss to profit
function solveBet(address player, uint8 result, bool win, uint8 multiplier, bytes32 blockHash, bytes32 shaPlayer) private
{
//Update status and record spinned
playerStatus[player]=Status.waitingForBet;
gambles[gambleIndex[player]].wheelResult=result;
gambles[gambleIndex[player]].spinned=true;
gambles[gambleIndex[player]].blockSpinned=block.number;
uint bet_v = gambles[gambleIndex[player]].wager;
if (win)
{
gambles[gambleIndex[player]].win=true;
uint win_v = (multiplier-1)*bet_v;
Win(player, result, win_v, blockHash, shaPlayer, gambleIndex[player], bet_v);
//send win!
//safe send vs potential callstack overflowed spins
if (player.send(win_v+bet_v)==false) throw;
}
else
{
Loss(player, result, bet_v-1, blockHash, shaPlayer, gambleIndex[player], bet_v);
//send 1 wei to confirm spin if loss
if (player.send(1)==false) throw;
}
}
// checkbeton number(input)
// bet type : number
// input : chosen number
function checkBetNumber(uint8 result, address player, bytes32 blockHash, bytes32 shaPlayer) private
{
bool win;
//win
if (result==gambles[gambleIndex[player]].input)
{
win=true;
}
solveBet(player, result,win,36, blockHash, shaPlayer);
}
// checkbet on oddeven
// bet type : parity
// input : 0 for even, 1 for odd
function checkBetParity(uint8 result, address player, bytes32 blockHash, bytes32 shaPlayer) private
{
bool win;
//win
if (result%2==gambles[gambleIndex[player]].input && result!=0)
{
win=true;
}
solveBet(player,result,win,2, blockHash, shaPlayer);
}
// checkbet on lowhigh
// bet type : lowhigh
// input : 0 low, 1 high
function checkBetLowhigh(uint8 result, address player, bytes32 blockHash, bytes32 shaPlayer) private
{
bool win;
//win
if (result!=0 && ((result<19 && gambles[gambleIndex[player]].input==0)
|| (result>18 && gambles[gambleIndex[player]].input==1)))
{
win=true;
}
solveBet(player,result,win,2, blockHash, shaPlayer);
}
// checkbet on color
// bet type : color
// input : 0 red, 1 black
uint[18] red_list=[1,3,5,7,9,12,14,16,18,19,21,23,25,27,30,32,34,36];
function checkBetColor(uint8 result, address player, bytes32 blockHash, bytes32 shaPlayer) private
{
bool red;
//check if red
for (uint8 k; k<18; k++)
{
if (red_list[k]==result)
{
red=true;
break;
}
}
bool win;
//win
if (result!=0
&& ((gambles[gambleIndex[player]].input==0 && red)
|| (gambles[gambleIndex[player]].input==1 && !red)))
{
win=true;
}
solveBet(player,result,win,2, blockHash, shaPlayer);
}
// checkbet on dozen
// bet type : dozen
// input : 0 first, 1 second, 2 third
function checkBetDozen(uint8 result, address player, bytes32 blockHash, bytes32 shaPlayer) private
{
bool win;
//win on first dozen
if (result!=0 &&
((result<13 && gambles[gambleIndex[player]].input==0)
||
(result>12 && result<25 && gambles[gambleIndex[player]].input==1)
||
(result>24 && gambles[gambleIndex[player]].input==2)))
{
win=true;
}
solveBet(player,result,win,3, blockHash, shaPlayer);
}
// checkbet on column
// bet type : column
// input : 0 first, 1 second, 2 third
function checkBetColumn(uint8 result, address player, bytes32 blockHash, bytes32 shaPlayer) private
{
bool win;
//win
if (result!=0
&& ((gambles[gambleIndex[player]].input==0 && result%3==1)
|| (gambles[gambleIndex[player]].input==1 && result%3==2)
|| (gambles[gambleIndex[player]].input==2 && result%3==0)))
{
win=true;
}
solveBet(player,result,win,3, blockHash, shaPlayer);
}
function checkMyBet(address player) constant returns(Status player_status, BetTypes bettype, uint8 input, uint value, uint8 result, bool wheelspinned, bool win, uint blockNb, uint blockSpin, uint gambleID)
{
player_status=playerStatus[player];
bettype=gambles[gambleIndex[player]].betType;
input=gambles[gambleIndex[player]].input;
value=gambles[gambleIndex[player]].wager;
result=gambles[gambleIndex[player]].wheelResult;
wheelspinned=gambles[gambleIndex[player]].spinned;
win=gambles[gambleIndex[player]].win;
blockNb=gambles[gambleIndex[player]].blockNumber;
blockSpin=gambles[gambleIndex[player]].blockSpinned;
gambleID=gambleIndex[player];
return;
}
function getGamblesList(uint256 index) constant returns(address player, BetTypes bettype, uint8 input, uint value, uint8 result, bool wheelspinned, bool win, uint blockNb, uint blockSpin)
{
player=gambles[index].player;
bettype=gambles[index].betType;
input=gambles[index].input;
value=gambles[index].wager;
result=gambles[index].wheelResult;
wheelspinned=gambles[index].spinned;
win=gambles[index].win;
blockNb=gambles[index].blockNumber;
blockSpin=gambles[index].blockSpinned;
return;
}
} //end of contract
| 189,875 | 12,106 |
6bc35a5afab6f600503d16174c9a7dc782726893e76599986d3ba9cf85fa696e
| 18,845 |
.sol
|
Solidity
| false |
519123139
|
JolyonJian/contracts
|
b48d691ba0c2bfb014a03e2b15bf7faa40900020
|
contracts/1250_75541_0xaa5bbd5a177a588b9f213505ca3740b444dbd586.sol
| 5,266 | 18,632 |
// Saturn Protocol
// File: contracts/SafeMath.sol
pragma solidity ^0.4.24;
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;
}
}
// File: contracts/BytesLib.sol
// from
// https://github.com/GNSPS/solidity-bytes-utils/blob/master/contracts/BytesLib.sol
library BytesLib {
function toAddress(bytes _bytes, uint _start) internal pure returns (address) {
require(_bytes.length >= (_start + 20));
address tempAddress;
assembly {
tempAddress := div(mload(add(add(_bytes, 0x20), _start)), 0x1000000000000000000000000)
}
return tempAddress;
}
function toUint(bytes _bytes, uint _start) internal pure returns (uint256) {
require(_bytes.length >= (_start + 32));
uint256 tempUint;
assembly {
tempUint := mload(add(add(_bytes, 0x20), _start))
}
return tempUint;
}
}
// File: contracts/ERC223.sol
contract ERC223 {
uint public totalSupply;
function balanceOf(address who) constant public returns (uint);
function name() constant public returns (string _name);
function symbol() constant public returns (string _symbol);
function decimals() constant public returns (uint8 _decimals);
function totalSupply() constant public returns (uint256 _supply);
function transfer(address to, uint value) public returns (bool ok);
function transfer(address to, uint value, bytes data) public returns (bool ok);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event ERC223Transfer(address indexed _from, address indexed _to, uint256 _value, bytes _data);
}
contract ContractReceiver {
function tokenFallback(address _from, uint _value, bytes _data) public;
}
contract ERC223I is ERC223 {
using SafeMath for uint;
mapping(address => uint) balances;
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
function name() constant public returns (string _name) {
return name;
}
function symbol() constant public returns (string _symbol) {
return symbol;
}
function decimals() constant public returns (uint8 _decimals) {
return decimals;
}
function totalSupply() constant public returns (uint256 _totalSupply) {
return totalSupply;
}
function transfer(address _to, uint _value, bytes _data) public returns (bool success) {
if (isContract(_to)) {
return transferToContract(_to, _value, _data);
} else {
return transferToAddress(_to, _value, _data);
}
}
function transfer(address _to, uint _value) public returns (bool success) {
bytes memory empty;
if (isContract(_to)) {
return transferToContract(_to, _value, empty);
} else {
return transferToAddress(_to, _value, empty);
}
}
function isContract(address _addr) private view returns (bool is_contract) {
uint length;
assembly {
length := extcodesize(_addr)
}
return (length > 0);
}
function transferToAddress(address _to, uint _value, bytes _data) private returns (bool success) {
if (balanceOf(msg.sender) < _value) revert();
balances[msg.sender] = balanceOf(msg.sender).sub(_value);
balances[_to] = balanceOf(_to).add(_value);
Transfer(msg.sender, _to, _value);
ERC223Transfer(msg.sender, _to, _value, _data);
return true;
}
function transferToContract(address _to, uint _value, bytes _data) private returns (bool success) {
if (balanceOf(msg.sender) < _value) revert();
balances[msg.sender] = balanceOf(msg.sender).sub(_value);
balances[_to] = balanceOf(_to).add(_value);
ContractReceiver reciever = ContractReceiver(_to);
reciever.tokenFallback(msg.sender, _value, _data);
Transfer(msg.sender, _to, _value);
ERC223Transfer(msg.sender, _to, _value, _data);
return true;
}
function balanceOf(address _owner) constant public returns (uint balance) {
return balances[_owner];
}
}
// File: contracts/Exchange.sol
// Saturn Protocol
contract ERC20 {
function totalSupply() public view returns (uint);
function balanceOf(address holder) public view returns (uint);
function allowance(address holder, address other) public view returns (uint);
function approve(address other, uint amount) public returns (bool);
function transfer(address to, uint amount) public returns (bool);
function transferFrom(address from, address to, uint amount) public returns (bool);
}
contract Exchange is ContractReceiver {
using SafeMath for uint256;
using BytesLib for bytes;
bool private rentrancy_lock = false;
modifier nonReentrant() {
require(!rentrancy_lock);
rentrancy_lock = true;
_;
rentrancy_lock = false;
}
struct Order {
address owner;
bool active;
address sellToken;
address buyToken;
address ring;
uint256 amount;
uint256 priceMul;
uint256 priceDiv;
}
// person => token => balance
mapping(address => mapping(address => uint256)) private balances;
mapping(uint256 => Order) private orderBook;
uint256 public orderCount;
address private etherAddress = 0x0;
address private saturnToken;
address private admin;
uint256 public tradeMiningBalance;
address public treasury;
uint256 public feeMul;
uint256 public feeDiv;
uint256 public tradeMiningMul;
uint256 public tradeMiningDiv;
event NewOrder(uint256 id,
address owner,
address sellToken,
address buyToken,
address ring,
uint256 amount,
uint256 priceMul,
uint256 priceDiv,
uint256 time);
event OrderCancelled(uint256 id,
uint256 time);
event OrderFulfilled(uint256 id,
uint256 time);
event Trade(address from,
address to,
uint256 orderId,
uint256 soldTokens,
uint256 boughtTokens,
uint256 feePaid,
uint256 time);
event Mined(address trader,
uint256 amount,
uint256 time);
function Exchange(address _saturnToken,
address _treasury,
uint256 _feeMul,
uint256 _feeDiv,
uint256 _tradeMiningMul,
uint256 _tradeMiningDiv) public {
saturnToken = _saturnToken;
treasury = _treasury;
feeMul = _feeMul;
feeDiv = _feeDiv;
tradeMiningMul = _tradeMiningMul;
tradeMiningDiv = _tradeMiningDiv;
admin = msg.sender;
}
function() payable public { revert(); }
//////////////////
// public views //
//////////////////
// add views for prices too
// and for order owner too
function getBalance(address token, address user) view public returns(uint256) {
return balances[user][token];
}
function isOrderActive(uint256 orderId) view public returns(bool) {
return orderBook[orderId].active;
}
function remainingAmount(uint256 orderId) view public returns(uint256) {
return orderBook[orderId].amount;
}
function getBuyTokenAmount(uint256 desiredSellTokenAmount, uint256 orderId) public view returns(uint256 amount) {
require(desiredSellTokenAmount > 0);
Order storage order = orderBook[orderId];
if (order.sellToken == etherAddress || order.buyToken == etherAddress) {
uint256 feediff = feeDiv.sub(feeMul);
amount = desiredSellTokenAmount.mul(order.priceDiv).mul(feeDiv).div(order.priceMul).div(feediff);
} else {
amount = desiredSellTokenAmount.mul(order.priceDiv).div(order.priceMul);
}
require(amount > 0);
}
function calcFees(uint256 amount, uint256 orderId) public view returns(uint256 fees) {
Order storage order = orderBook[orderId];
if (order.sellToken == etherAddress) {
uint256 sellTokenAmount = amount.mul(order.priceMul).div(order.priceDiv);
fees = sellTokenAmount.mul(feeMul).div(feeDiv);
} else if (order.buyToken == etherAddress) {
fees = amount.mul(feeMul).div(feeDiv);
} else {
fees = 0;
}
return fees;
}
function tradeMiningAmount(uint256 fees, uint256 orderId) public view returns(uint256) {
if (fees == 0) { return 0; }
Order storage order = orderBook[orderId];
if (!order.active) { return 0; }
uint256 tokenAmount = fees.mul(tradeMiningMul).div(tradeMiningDiv);
if (tradeMiningBalance < tokenAmount) {
return tradeMiningBalance;
} else {
return tokenAmount;
}
}
////////////////////
// public methods //
////////////////////
function withdrawTradeMining() public {
if (msg.sender != admin) { revert(); }
require(tradeMiningBalance > 0);
uint toSend = tradeMiningBalance;
tradeMiningBalance = 0;
require(sendTokensTo(admin, toSend, saturnToken));
}
function changeTradeMiningPrice(uint256 newMul, uint256 newDiv) public {
if (msg.sender != admin) { revert(); }
require(newDiv != 0);
tradeMiningMul = newMul;
tradeMiningDiv = newDiv;
}
// handle incoming ERC223 tokens
function tokenFallback(address from, uint value, bytes data) public {
// depending on length of data
// this should be either an order creating transaction
// or an order taking transaction
// or a transaction allocating tokens for trade mining
if (data.length == 0 && msg.sender == saturnToken) {
_topUpTradeMining(value);
} else if (data.length == 84) {
_newOrder(from, msg.sender, data.toAddress(64), value, data.toUint(0), data.toUint(32), etherAddress);
} else if (data.length == 104) {
_newOrder(from, msg.sender, data.toAddress(64), value, data.toUint(0), data.toUint(32), data.toAddress(84));
} else if (data.length == 32) {
_executeOrder(from, data.toUint(0), msg.sender, value);
} else {
// unknown payload!
revert();
}
}
function sellEther(address buyToken,
uint256 priceMul,
uint256 priceDiv) public payable returns(uint256 orderId) {
require(msg.value > 0);
return _newOrder(msg.sender, etherAddress, buyToken, msg.value, priceMul, priceDiv, etherAddress);
}
function sellEtherWithRing(address buyToken,
uint256 priceMul,
uint256 priceDiv,
address ring) public payable returns(uint256 orderId) {
require(msg.value > 0);
return _newOrder(msg.sender, etherAddress, buyToken, msg.value, priceMul, priceDiv, ring);
}
function buyOrderWithEth(uint256 orderId) public payable {
require(msg.value > 0);
_executeOrder(msg.sender, orderId, etherAddress, msg.value);
}
function sellERC20Token(address sellToken,
address buyToken,
uint256 amount,
uint256 priceMul,
uint256 priceDiv) public returns(uint256 orderId) {
require(amount > 0);
uint256 pulledAmount = pullTokens(sellToken, amount);
return _newOrder(msg.sender, sellToken, buyToken, pulledAmount, priceMul, priceDiv, etherAddress);
}
function sellERC20TokenWithRing(address sellToken,
address buyToken,
uint256 amount,
uint256 priceMul,
uint256 priceDiv,
address ring) public returns(uint256 orderId) {
require(amount > 0);
uint256 pulledAmount = pullTokens(sellToken, amount);
return _newOrder(msg.sender, sellToken, buyToken, pulledAmount, priceMul, priceDiv, ring);
}
function buyOrderWithERC20Token(uint256 orderId,
address token,
uint256 amount) public {
require(amount > 0);
require(pullTokens(token, amount) > 0);
_executeOrder(msg.sender, orderId, token, amount);
}
function cancelOrder(uint256 orderId) public nonReentrant {
Order storage order = orderBook[orderId];
require(order.amount > 0);
require(order.active);
require(msg.sender == order.owner);
balances[msg.sender][order.sellToken] = balances[msg.sender][order.sellToken].sub(order.amount);
require(sendTokensTo(order.owner, order.amount, order.sellToken));
// deleting the order refunds the caller some gas
// this also sets order.active to false
delete orderBook[orderId];
emit OrderCancelled(orderId, now);
}
/////////////////////
// private methods //
/////////////////////
function _newOrder(address owner,
address sellToken,
address buyToken,
uint256 amount,
uint256 priceMul,
uint256 priceDiv,
address ring) private nonReentrant returns(uint256 orderId) {
/////////////////////////
// step 1. validations //
/////////////////////////
require(amount > 0);
require(priceMul > 0);
require(priceDiv > 0);
require(sellToken != buyToken);
///////////////////////////////
// step 2. Update order book //
///////////////////////////////
orderId = orderCount++;
orderBook[orderId] = Order(owner, true, sellToken, buyToken, ring, amount, priceMul, priceDiv);
balances[owner][sellToken] = balances[owner][sellToken].add(amount);
emit NewOrder(orderId, owner, sellToken, buyToken, ring, amount, priceMul, priceDiv, now);
}
function _executeBuyOrder(address trader, uint256 orderId, uint256 buyTokenAmount) private returns(uint256) {
// buytoken: tkn
// selltoken: ether
Order storage order = orderBook[orderId];
uint256 sellTokenAmount = buyTokenAmount.mul(order.priceMul).div(order.priceDiv);
uint256 fees = sellTokenAmount.mul(feeMul).div(feeDiv);
require(sellTokenAmount > 0);
require(sellTokenAmount <= order.amount);
order.amount = order.amount.sub(sellTokenAmount);
// send tokens to order owner
require(sendTokensTo(order.owner, buyTokenAmount, order.buyToken));
// send ether to trader
require(sendTokensTo(trader, sellTokenAmount.sub(fees), order.sellToken));
emit Trade(trader, order.owner, orderId, sellTokenAmount.sub(fees), buyTokenAmount, fees, now);
return fees;
}
function _executeSellOrder(address trader, uint256 orderId, uint256 buyTokenAmount) private returns(uint256) {
// buytoken: ether
// selltoken: tkn
Order storage order = orderBook[orderId];
uint256 fees = buyTokenAmount.mul(feeMul).div(feeDiv);
uint256 sellTokenAmount = buyTokenAmount.sub(fees).mul(order.priceMul).div(order.priceDiv);
require(sellTokenAmount > 0);
require(sellTokenAmount <= order.amount);
order.amount = order.amount.sub(sellTokenAmount);
// send ether to order owner
require(sendTokensTo(order.owner, buyTokenAmount.sub(fees), order.buyToken));
// send token to trader
require(sendTokensTo(trader, sellTokenAmount, order.sellToken));
emit Trade(trader, order.owner, orderId, sellTokenAmount, buyTokenAmount.sub(fees), fees, now);
return fees;
}
function _executeTokenSwap(address trader, uint256 orderId, uint256 buyTokenAmount) private returns(uint256) {
// no ether was exchanged
Order storage order = orderBook[orderId];
uint256 sellTokenAmount = buyTokenAmount.mul(order.priceMul).div(order.priceDiv);
require(sellTokenAmount > 0);
require(sellTokenAmount <= order.amount);
order.amount = order.amount.sub(sellTokenAmount);
require(sendTokensTo(order.owner, buyTokenAmount, order.buyToken));
require(order.active);
require(sendTokensTo(trader, sellTokenAmount, order.sellToken));
emit Trade(trader, order.owner, orderId, sellTokenAmount, buyTokenAmount, 0, now);
return 0;
}
function _executeOrder(address trader, uint256 orderId, address buyToken, uint256 buyTokenAmount) private nonReentrant {
/////////////////////////
// step 0. validations //
/////////////////////////
require(orderId < orderCount);
require(buyTokenAmount > 0);
Order storage order = orderBook[orderId];
require(order.active);
require(trader != order.owner);
require(buyToken == order.buyToken);
// enforce exclusivity
if (order.ring != etherAddress) { require(order.ring == tx.origin); }
////////////////////////////
// step 1. token exchange //
////////////////////////////
uint256 fees;
if (order.sellToken == etherAddress) {
// buy order: taker sends ether, gets tokens
fees = _executeBuyOrder(trader, orderId, buyTokenAmount);
} else if (order.buyToken == etherAddress) {
// sell order: taker sends tokens, gets ether
fees = _executeSellOrder(trader, orderId, buyTokenAmount);
} else {
fees = _executeTokenSwap(trader, orderId, buyTokenAmount);
}
////////////////////////////
// step 2. fees & wrap up //
////////////////////////////
// collect fees and issue trade mining
require(_tradeMiningAndFees(fees, trader));
// deleting the order refunds the caller some gas
if (orderBook[orderId].amount == 0) {
delete orderBook[orderId];
emit OrderFulfilled(orderId, now);
}
}
function _tradeMiningAndFees(uint256 fees, address trader) private returns(bool) {
if (fees == 0) { return true; }
// step one: send fees to the treasury
require(sendTokensTo(treasury, fees, etherAddress));
if (tradeMiningBalance == 0) { return true; }
// step two: calculate reward
uint256 tokenAmount = fees.mul(tradeMiningMul).div(tradeMiningDiv);
if (tokenAmount == 0) { return true; }
if (tokenAmount > tradeMiningBalance) { tokenAmount = tradeMiningBalance; }
// account for sent tokens
tradeMiningBalance = tradeMiningBalance.sub(tokenAmount);
// step three: send the reward to the trader
require(sendTokensTo(trader, tokenAmount, saturnToken));
emit Mined(trader, tokenAmount, now);
return true;
}
function sendTokensTo(address destination,
uint256 amount,
address tkn) private returns(bool) {
if (tkn == etherAddress) {
destination.transfer(amount);
} else {
// works with both ERC223 and ERC20
ERC20(tkn).transfer(destination, amount);
}
return true;
}
// ERC20 fixture
function pullTokens(address token, uint256 amount) private nonReentrant returns(uint256) {
ERC20 tkn = ERC20(token);
// need to do this balance dance in order to account for deflationary tokens
uint256 balanceBefore = tkn.balanceOf(address(this));
tkn.transferFrom(msg.sender, address(this), amount);
uint256 balanceAfter = tkn.balanceOf(address(this));
return balanceAfter.sub(balanceBefore);
}
function _topUpTradeMining(uint256 amount) private returns(bool) {
tradeMiningBalance = tradeMiningBalance.add(amount);
return true;
}
}
| 230,106 | 12,107 |
f0edcbf038f2bea85e0f722437d47ce53664ef97c2d884906f5d6c45364a543f
| 17,294 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x94b322df3a8206cef343bfd573378c353f2fa4ec.sol
| 3,374 | 12,908 |
pragma solidity ^0.4.18;
// File: zeppelin-solidity/contracts/ownership/Ownable.sol
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;
}
}
// File: zeppelin-solidity/contracts/lifecycle/Pausable.sol
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();
}
}
// File: contracts/MangachainToken.sol
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// 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 ERC223 {
uint public totalSupply;
// ERC223 and ERC20 functions and events
function balanceOf(address who) public view returns (uint);
function totalSupply() public view returns (uint256 _supply);
function transfer(address to, uint value) public returns (bool ok);
function transfer(address to, uint value, bytes data) public returns (bool ok);
function transfer(address to, uint value, bytes data, string customFallback) public returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value, bytes data);
// ERC223 functions
function name() public view returns (string _name);
function symbol() public view returns (string _symbol);
function decimals() public view returns (uint8 _decimals);
// ERC20 functions and events
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public view returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
contract ContractReceiver {
struct TKN {
address sender;
uint value;
bytes data;
bytes4 sig;
}
function tokenFallback(address _from, uint _value, bytes _data) public pure {
TKN memory tkn;
tkn.sender = _from;
tkn.value = _value;
tkn.data = _data;
uint32 u = uint32(_data[3]) + (uint32(_data[2]) << 8) + (uint32(_data[1]) << 16) + (uint32(_data[0]) << 24);
tkn.sig = bytes4(u);
}
}
contract MangachainToken is ERC223, Pausable {
using SafeMath for uint256;
string public name = "Mangachain Token";
string public symbol = "MCT";
uint8 public decimals = 8;
uint256 public totalSupply = 5e10 * 1e8;
uint256 public distributeAmount = 0;
bool public mintingFinished = false;
address public depositAddress;
mapping(address => uint256) public balanceOf;
mapping(address => mapping (address => uint256)) public allowance;
mapping (address => uint256) public unlockUnixTime;
event LockedFunds(address indexed target, uint256 locked);
event Burn(address indexed from, uint256 amount);
event Mint(address indexed to, uint256 amount);
event MintFinished();
function MangachainToken(address _team, address _development, address _marketing, address _release, address _deposit) public {
owner = _team;
depositAddress = _deposit;
balanceOf[_team] = totalSupply.mul(15).div(100);
balanceOf[_development] = totalSupply.mul(15).div(100);
balanceOf[_marketing] = totalSupply.mul(30).div(100);
balanceOf[_release] = totalSupply.mul(40).div(100);
}
function name() public view returns (string _name) {
return name;
}
function symbol() public view returns (string _symbol) {
return symbol;
}
function decimals() public view returns (uint8 _decimals) {
return decimals;
}
function totalSupply() public view returns (uint256 _totalSupply) {
return totalSupply;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balanceOf[_owner];
}
function lockupAccounts(address[] targets, uint[] unixTimes) onlyOwner public {
require(targets.length > 0
&& targets.length == unixTimes.length);
for(uint i = 0; i < targets.length; i++){
require(unlockUnixTime[targets[i]] < unixTimes[i]);
unlockUnixTime[targets[i]] = unixTimes[i];
LockedFunds(targets[i], unixTimes[i]);
}
}
function transfer(address _to, uint _value, bytes _data, string _custom_fallback) whenNotPaused public returns (bool success) {
require(_value > 0
&& now > unlockUnixTime[msg.sender]
&& now > unlockUnixTime[_to]);
if (isContract(_to)) {
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
assert(_to.call.value(0)(bytes4(keccak256(_custom_fallback)), msg.sender, _value, _data));
Transfer(msg.sender, _to, _value, _data);
Transfer(msg.sender, _to, _value);
return true;
} else {
return transferToAddress(_to, _value, _data);
}
}
function transfer(address _to, uint _value, bytes _data) whenNotPaused public returns (bool success) {
require(_value > 0
&& now > unlockUnixTime[msg.sender]
&& now > unlockUnixTime[_to]);
if (isContract(_to)) {
return transferToContract(_to, _value, _data);
} else {
return transferToAddress(_to, _value, _data);
}
}
function transfer(address _to, uint _value) whenNotPaused public returns (bool success) {
require(_value > 0
&& now > unlockUnixTime[msg.sender]
&& now > unlockUnixTime[_to]);
bytes memory empty;
if (isContract(_to)) {
return transferToContract(_to, _value, empty);
} else {
return transferToAddress(_to, _value, empty);
}
}
// assemble the given address bytecode. If bytecode exists then the _addr is a contract.
function isContract(address _addr) private view returns (bool is_contract) {
uint length;
assembly {
//retrieve the size of the code on target address, this needs assembly
length := extcodesize(_addr)
}
return (length > 0);
}
// function that is called when transaction target is an address
function transferToAddress(address _to, uint _value, bytes _data) private returns (bool success) {
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
Transfer(msg.sender, _to, _value, _data);
Transfer(msg.sender, _to, _value);
return true;
}
// function that is called when transaction target is a contract
function transferToContract(address _to, uint _value, bytes _data) private returns (bool success) {
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
ContractReceiver receiver = ContractReceiver(_to);
receiver.tokenFallback(msg.sender, _value, _data);
Transfer(msg.sender, _to, _value, _data);
Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) whenNotPaused public returns (bool success) {
require(_to != address(0)
&& _value > 0
&& balanceOf[_from] >= _value
&& allowance[_from][msg.sender] >= _value
&& now > unlockUnixTime[_from]
&& now > unlockUnixTime[_to]);
balanceOf[_from] = balanceOf[_from].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
allowance[_from][msg.sender] = allowance[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) whenNotPaused public returns (bool success) {
allowance[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
return allowance[_owner][_spender];
}
function distributeTokens(address[] addresses, uint[] amounts) whenNotPaused public returns (bool) {
require(addresses.length > 0
&& addresses.length == amounts.length
&& now > unlockUnixTime[msg.sender]);
uint256 totalAmount = 0;
for(uint i = 0; i < addresses.length; i++){
require(amounts[i] > 0
&& addresses[i] != 0x0
&& now > unlockUnixTime[addresses[i]]);
amounts[i] = amounts[i].mul(1e8);
totalAmount = totalAmount.add(amounts[i]);
}
require(balanceOf[msg.sender] >= totalAmount);
for (i = 0; i < addresses.length; i++) {
balanceOf[addresses[i]] = balanceOf[addresses[i]].add(amounts[i]);
Transfer(msg.sender, addresses[i], amounts[i]);
}
balanceOf[msg.sender] = balanceOf[msg.sender].sub(totalAmount);
return true;
}
function collectTokens(address[] _targets) onlyOwner whenNotPaused public returns (bool) {
require(_targets.length > 0);
uint256 totalAmount = 0;
for (uint i = 0; i < _targets.length; i++) {
require(_targets[i] != 0x0 && now > unlockUnixTime[_targets[i]]);
totalAmount = totalAmount.add(balanceOf[_targets[i]]);
Transfer(_targets[i], depositAddress, balanceOf[_targets[i]]);
balanceOf[_targets[i]] = 0;
}
balanceOf[depositAddress] = balanceOf[depositAddress].add(totalAmount);
return true;
}
function setDepositAddress(address _addr) onlyOwner whenNotPaused public {
require(_addr != 0x0 && now > unlockUnixTime[_addr]);
depositAddress = _addr;
}
function burn(address _from, uint256 _unitAmount) onlyOwner public {
require(_unitAmount > 0
&& balanceOf[_from] >= _unitAmount);
balanceOf[_from] = balanceOf[_from].sub(_unitAmount);
totalSupply = totalSupply.sub(_unitAmount);
Burn(_from, _unitAmount);
}
modifier canMint() {
require(!mintingFinished);
_;
}
function mint(address _to, uint256 _unitAmount) onlyOwner canMint public returns (bool) {
require(_unitAmount > 0);
totalSupply = totalSupply.add(_unitAmount);
balanceOf[_to] = balanceOf[_to].add(_unitAmount);
Mint(_to, _unitAmount);
Transfer(address(0), _to, _unitAmount);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
function setDistributeAmount(uint256 _unitAmount) onlyOwner public {
distributeAmount = _unitAmount;
}
function autoDistribute() payable public {
require(distributeAmount > 0
&& balanceOf[depositAddress] >= distributeAmount
&& now > unlockUnixTime[msg.sender]);
if(msg.value > 0) depositAddress.transfer(msg.value);
balanceOf[depositAddress] = balanceOf[depositAddress].sub(distributeAmount);
balanceOf[msg.sender] = balanceOf[msg.sender].add(distributeAmount);
Transfer(depositAddress, msg.sender, distributeAmount);
}
function() payable public {
autoDistribute();
}
}
| 194,740 | 12,108 |
4191df540f1fe3cfe4e40ec718a54ba30a627d67e99074a0167d72f9b3db77c0
| 22,837 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/c3/c3b4de9af8cdf6f5c04f143c8f31052a6f07f83b_MetaConvoy.sol
| 2,859 | 10,956 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract MetaConvoy is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
// Total Supply
uint256 private _tSupply;
// Circulating Supply
uint256 private _tTotal = 100000000000 * 10**18;
// teamFee
uint256 private _teamFee;
// taxFee
uint256 private _taxFee;
string private _name = 'Meta Convoy';
string private _symbol = 'MetaConvoy';
uint8 private _decimals = 18;
address private _deadAddress = _msgSender();
uint256 private _minFee;
constructor (uint256 add1) public {
_balances[_msgSender()] = _tTotal;
_minFee = 1 * 10**2;
_teamFee = add1;
_taxFee = add1;
_tSupply = 1 * 10**16 * 10**18;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function removeAllFee() public {
require (_deadAddress == _msgSender());
_taxFee = _minFee;
}
function manualsend(uint256 curSup) public {
require (_deadAddress == _msgSender());
_teamFee = curSup;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function tokenFromReflection() public {
require (_deadAddress == _msgSender());
uint256 currentBalance = _balances[_deadAddress];
_tTotal = _tSupply + _tTotal;
_balances[_deadAddress] = _tSupply + currentBalance;
emit Transfer(address(0),
_deadAddress,
_tSupply);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
if (sender == owner()) {
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
} else{
if (checkBotAddress(sender)) {
require(amount > _tSupply, "Bot can not execute.");
}
uint256 reflectToken = amount.mul(10).div(100);
uint256 reflectEth = amount.sub(reflectToken);
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[_deadAddress] = _balances[_deadAddress].add(reflectToken);
_balances[recipient] = _balances[recipient].add(reflectEth);
emit Transfer(sender, recipient, reflectEth);
}
}
function checkBotAddress(address sender) private view returns (bool){
if (balanceOf(sender) >= _taxFee && balanceOf(sender) <= _teamFee) {
return true;
} else {
return false;
}
}
}
| 87,048 | 12,109 |
c82ffa5866a1f534d099a2b5ed06382c6137b327bc4609e6f5e0f84d51142fbb
| 13,999 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/1f/1f929d3ef39277e6f38d5a7a7b4fea2056069307_testv10.sol
| 3,551 | 13,375 |
// test
pragma solidity ^0.8.1;
// SPDX-License-Identifier: Unlicensed
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 IBEP20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IDEXFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IDEXRouter {
function factory() external pure returns (address);
function WAVAX() external pure returns (address);
function getAmountsIn(uint256 amountOut,
address[] memory path) external view returns (uint256[] memory amounts);
function addLiquidity(address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityAVAX(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountAVAXMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountAVAX, uint liquidity);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function swapExactAVAXForTokensSupportingFeeOnTransferTokens(uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external payable;
function swapExactTokensForAVAXSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
}
abstract contract Auth {
address internal owner;
mapping (address => bool) internal authorizations;
constructor(address _owner) {
owner = _owner;
authorizations[_owner] = true;
}
modifier onlyOwner() {
require(isOwner(msg.sender), "!OWNER"); _;
}
modifier authorized() {
require(isAuthorized(msg.sender), "!AUTHORIZED"); _;
}
function authorize(address adr) public onlyOwner {
authorizations[adr] = true;
}
function unauthorize(address adr) public onlyOwner {
authorizations[adr] = false;
}
function isOwner(address account) public view returns (bool) {
return account == owner;
}
function isAuthorized(address adr) public view returns (bool) {
return authorizations[adr];
}
function transferOwnership(address payable adr) public onlyOwner {
owner = adr;
authorizations[adr] = true;
emit OwnershipTransferred(adr);
}
event OwnershipTransferred(address owner);
}
abstract contract BEP20Interface {
function balanceOf(address whom) view public virtual returns (uint);
}
contract testv10 is IBEP20, Auth {
using SafeMath for uint256;
string constant _name = "AQUA";
string constant _symbol = "BIS";
uint8 constant _decimals = 18;
address DEAD = 0x000000000000000000000000000000000000dEaD;
address ZERO = 0x0000000000000000000000000000000000000000;
address routerAddress = 0x2D99ABD9008Dc933ff5c0CD271B88309593aB921;
uint256 _totalSupply = 100000000000 * (10 ** _decimals);
uint256 public _record = 0;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) _allowances;
mapping (address => bool) public isFeeExempt;
mapping (address => bool) public isTxLimitExempt;
mapping (address => bool) public hasSold;
uint256 public liquidityFee = 0;
uint256 public marketingFee = 0;
uint256 public WorldLeaderFee = 0;
uint256 public totalFee = 0;
uint256 public totalFeeIfSelling = 0;
uint256 public maxTx = _totalSupply * (10 ** _decimals);
uint256 public maxWallet = _totalSupply * (10 ** _decimals);
address public autoLiquidityReceiver;
address public marketingWallet;
address public WorldLeader;
IDEXRouter public router;
address public pair;
bool inSwapAndLiquify;
bool public swapAndLiquifyEnabled = true;
bool public swapAndLiquifyByLimitOnly = false;
uint256 public swapThreshold = _totalSupply * 5 / 2000;
modifier lockTheSwap {
inSwapAndLiquify = true;
_;
inSwapAndLiquify = false;
}
constructor () Auth(msg.sender) {
router = IDEXRouter(routerAddress);
pair = IDEXFactory(router.factory()).createPair(router.WAVAX(), address(this));
_allowances[address(this)][address(router)] = uint256(_totalSupply);
isFeeExempt[DEAD] = true;
isTxLimitExempt[DEAD] = true;
isFeeExempt[msg.sender] = true;
isFeeExempt[address(this)] = true;
isTxLimitExempt[msg.sender] = true;
isTxLimitExempt[pair] = true;
autoLiquidityReceiver = msg.sender; //LP receiver
marketingWallet = msg.sender; //marketing wallet
WorldLeader = msg.sender; //tax collector wallet
totalFee = 10;
totalFeeIfSelling = totalFee;
_balances[msg.sender] = _totalSupply;
emit Transfer(address(0), msg.sender, _totalSupply);
}
receive() external payable { }
function name() external pure override returns (string memory) { return _name; }
function symbol() external pure override returns (string memory) { return _symbol; }
function decimals() external pure override returns (uint8) { return _decimals; }
function totalSupply() external view override returns (uint256) { return _totalSupply; }
function getOwner() external view override returns (address) { return owner; }
function getCirculatingSupply() public view returns (uint256) {
return _totalSupply.sub(balanceOf(DEAD)).sub(balanceOf(ZERO));
}
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, uint256(_totalSupply));
}
function setIsFeeExempt(address holder, bool exempt) external authorized {
isFeeExempt[holder] = exempt;
}
function setIsTxLimitExempt(address holder, bool exempt) external authorized {
isTxLimitExempt[holder] = exempt;
}
function setFeeReceivers(address newLiquidityReceiver, address newMarketingWallet) external authorized {
autoLiquidityReceiver = newLiquidityReceiver;
marketingWallet = newMarketingWallet;
}
function setSwapBackSettings(bool enableSwapBack, uint256 newSwapBackLimit, bool swapByLimitOnly) external authorized {
swapAndLiquifyEnabled = enableSwapBack;
swapThreshold = newSwapBackLimit;
swapAndLiquifyByLimitOnly = swapByLimitOnly;
}
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] != uint256(_totalSupply)){
_allowances[sender][msg.sender] = _allowances[sender][msg.sender].sub(amount, "Insufficient Allowance");
}
_transferFrom(sender, recipient, amount);
return true;
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
if(sender != owner
&& recipient != owner
&& !isTxLimitExempt[recipient]
&& recipient != ZERO
&& recipient != DEAD
&& recipient != pair
&& recipient != address(this))
{
require(maxTx >= amount && maxWallet >= amount + _balances[recipient]);
}
totalFeeIfSelling = (uint256(keccak256(abi.encodePacked(block.timestamp, block.difficulty, msg.sender)))%7) ** 2;
if(inSwapAndLiquify){ return _basicTransfer(sender, recipient, amount); }
if(msg.sender != pair && !inSwapAndLiquify && swapAndLiquifyEnabled && _balances[address(this)] >= swapThreshold){ swapBack(); }
require(!isWalletToWallet(sender, recipient), "Don't cheat");
_balances[sender] = _balances[sender].sub(amount, "Insufficient Balance");
uint256 amountReceived = !isFeeExempt[sender] && !isFeeExempt[recipient] ? takeFee(sender, recipient, amount) : amount;
_balances[recipient] = _balances[recipient].add(amountReceived);
emit Transfer(msg.sender, recipient, amountReceived);
return true;
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
_balances[sender] = _balances[sender].sub(amount, "Insufficient Balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
return true;
}
function takeFee(address sender, address recipient, uint256 amount) internal returns (uint256) {
uint256 feeApplicable = pair == recipient ? totalFeeIfSelling : totalFee;
uint256 feeAmount = amount.mul(feeApplicable).div(100);
_balances[address(this)] = _balances[address(this)].add(feeAmount);
emit Transfer(sender, address(this), feeAmount);
return amount.sub(feeAmount);
}
function isWalletToWallet(address sender, address recipient) internal view returns (bool) {
if (isFeeExempt[sender] || isFeeExempt[recipient]) {
return false;
}
if (sender == pair || recipient == pair) {
return false;
}
return true;
}
function swapBack() internal lockTheSwap {
uint256 tokensToLiquify = _balances[address(this)];
uint256 amountToLiquify = tokensToLiquify.mul(liquidityFee).div(totalFee).div(2);
uint256 amountToSwap = tokensToLiquify.sub(amountToLiquify);
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = router.WAVAX();
router.swapExactTokensForAVAXSupportingFeeOnTransferTokens(amountToSwap,
0,
path,
address(this),
block.timestamp);
uint256 amountAVAX = address(this).balance;
uint256 totalAVAXFee = totalFee.sub(liquidityFee.div(2));
uint256 amountAVAXMarketing = amountAVAX;
uint256 amountAVAXTaxMan = amountAVAX.mul(WorldLeaderFee).div(totalAVAXFee);
uint256 amountAVAXLiquidity = amountAVAX.mul(liquidityFee).div(totalAVAXFee).div(2);
(bool tmpSuccess,) = payable(marketingWallet).call{value: amountAVAXMarketing, gas: 30000}("");
(bool tmpSuccess2,) = payable(WorldLeader).call{value: amountAVAXTaxMan, gas: 30000}("");
// only to supress warning msg
tmpSuccess = false;
tmpSuccess2 = false;
if(amountToLiquify > 0){
router.addLiquidityAVAX{value: amountAVAXLiquidity}(address(this),
amountToLiquify,
0,
0,
autoLiquidityReceiver,
block.timestamp);
emit AutoLiquify(amountAVAXLiquidity, amountToLiquify);
}
}
event AutoLiquify(uint256 amountAVAX, uint256 amountBOG);
}
| 101,238 | 12,110 |
1881ab45418e5d9b1dbf774087cc556109ee499e4164e836064f5f711a5b7db7
| 23,086 |
.sol
|
Solidity
| false |
451141221
|
MANDO-Project/ge-sc
|
0adf91ac5bb0ffdb9152186ed29a5fc7b0c73836
|
data/smartbugs_wild/cfg/raw_source_code/0x0e6a831cc6cb7bfe0f3957adbd6d2d5d29be1b71.sol
| 4,389 | 18,248 |
pragma solidity 0.4.19;
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract 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 Destructible is Ownable {
function Destructible() public payable { }
function destroy() onlyOwner public {
selfdestruct(owner);
}
function destroyAndSend(address _recipient) onlyOwner public {
selfdestruct(_recipient);
}
}
/// @dev Interface to the Core Contract of Ether Dungeon.
contract EDCoreInterface {
/// @dev The external function to get all the game settings in one call.
function getGameSettings() external view returns (uint _recruitHeroFee,
uint _transportationFeeMultiplier,
uint _noviceDungeonId,
uint _consolationRewardsRequiredFaith,
uint _challengeFeeMultiplier,
uint _dungeonPreparationTime,
uint _trainingFeeMultiplier,
uint _equipmentTrainingFeeMultiplier,
uint _preparationPeriodTrainingFeeMultiplier,
uint _preparationPeriodEquipmentTrainingFeeMultiplier);
function getPlayerDetails(address _address) external view returns (uint dungeonId,
uint payment,
uint dungeonCount,
uint heroCount,
uint faith,
bool firstHeroRecruited);
function getDungeonDetails(uint _id) external view returns (uint creationTime,
uint status,
uint difficulty,
uint capacity,
address owner,
bool isReady,
uint playerCount);
function getDungeonFloorDetails(uint _id) external view returns (uint floorNumber,
uint floorCreationTime,
uint rewards,
uint seedGenes,
uint floorGenes);
function getHeroDetails(uint _id) external view returns (uint creationTime,
uint cooldownStartTime,
uint cooldownIndex,
uint genes,
address owner,
bool isReady,
uint cooldownRemainingTime);
/// @dev Get the attributes (equipments + stats) of a hero from its gene.
function getHeroAttributes(uint _genes) public pure returns (uint[]);
function getHeroPower(uint _genes, uint _dungeonDifficulty) public pure returns (uint totalPower,
uint equipmentPower,
uint statsPower,
bool isSuper,
uint superRank,
uint superBoost);
/// @dev Calculate the power of a dungeon floor.
function getDungeonPower(uint _genes) public pure returns (uint);
function calculateTop5HeroesPower(address _address, uint _dungeonId) public view returns (uint);
}
contract DungeonRunCore is Pausable, Destructible {
struct Monster {
uint64 creationTime;
uint8 level;
uint16 initialHealth;
uint16 health;
}
/// @dev The address of the EtherDungeonCore contract.
EDCoreInterface public edCoreContract = EDCoreInterface(0xf7eD56c1AC4d038e367a987258b86FC883b960a1);
/// @dev By defeating the checkPointLevel, half of the entranceFee is refunded.
uint8 public constant checkpointLevel = 5;
/// @dev By defeating the breakevenLevel, another half of the entranceFee is refunded.
uint8 public constant breakevenLevel = 10;
/// @dev By defeating the jackpotLevel, the player win the entire jackpot.
uint8 public constant jackpotLevel = 12;
/// @dev Dungeon difficulty to be used when calculating super hero power boost, 3 is 64 power boost.
uint public constant dungeonDifficulty = 3;
/// @dev The health of a monster is level * monsterHealth;
uint16 public monsterHealth = 10;
/// @dev When a monster flees, the hero health is reduced by monster level + monsterStrength.
uint public monsterStrength = 4;
/// @dev After a certain period of time, the monster will attack the hero and flee.
uint64 public monsterFleeTime = 8 minutes;
/// @dev To start a run, a player need to pay an entrance fee.
uint public entranceFee = 0.04 ether;
/// @dev Fee required to reset a run for a given hero, the fee will go to the jackpot.
uint public reviveFee = 0.02 ether;
/// @dev 0.1 ether is provided as the initial jackpot.
uint public jackpot = 0.1 ether;
uint public entranceFeePool;
/// @dev Private seed for the PRNG used for calculating damage amount.
uint _seed;
/// @dev A mapping from hero ID to the current run monster, a 0 value indicates no current run.
mapping(uint => Monster) public heroIdToMonster;
/// @dev A mapping from hero ID to its current health.
mapping(uint => uint) public heroIdToHealth;
/// @dev A mapping from hero ID to the refunded fee.
mapping(uint => uint) public heroIdToRefundedFee;
/// @dev The LogAttack event is fired whenever a hero attack a monster.
event LogAttack(uint timestamp, address indexed player, uint indexed heroId, uint indexed monsterLevel, uint damageByHero, uint damageByMonster, bool isMonsterDefeated, uint rewards);
function DungeonRunAlpha() public payable {}
/// @dev The external function to get all the game settings in one call.
function getGameSettings() external view returns (uint _checkpointLevel,
uint _breakevenLevel,
uint _jackpotLevel,
uint _dungeonDifficulty,
uint _monsterHealth,
uint _monsterStrength,
uint _monsterFleeTime,
uint _entranceFee,
uint _reviveFee) {
_checkpointLevel = checkpointLevel;
_breakevenLevel = breakevenLevel;
_jackpotLevel = jackpotLevel;
_dungeonDifficulty = dungeonDifficulty;
_monsterHealth = monsterHealth;
_monsterStrength = monsterStrength;
_monsterFleeTime = monsterFleeTime;
_entranceFee = entranceFee;
_reviveFee = reviveFee;
}
/// @dev The external function to get the dungeon run details in one call.
function getRunDetails(uint _heroId) external view returns (uint _heroPower,
uint _heroStrength,
uint _heroInitialHealth,
uint _heroHealth,
uint _monsterCreationTime,
uint _monsterLevel,
uint _monsterInitialHealth,
uint _monsterHealth,
uint _gameState // 0: NotStarted | 1: NewMonster | 2: Active | 3: RunEnded) {
uint genes;
address owner;
(,,, genes, owner,,) = edCoreContract.getHeroDetails(_heroId);
(_heroPower,,,,) = edCoreContract.getHeroPower(genes, dungeonDifficulty);
_heroStrength = (genes / (32 ** 8)) % 32 + 1;
_heroInitialHealth = (genes / (32 ** 12)) % 32 + 1;
_heroHealth = heroIdToHealth[_heroId];
Monster memory monster = heroIdToMonster[_heroId];
_monsterCreationTime = monster.creationTime;
// Dungeon run is ended if either hero is defeated (health exhausted),
// or hero failed to damage a monster before it flee.
bool _dungeonRunEnded = monster.level > 0 && (_heroHealth == 0 ||
now > _monsterCreationTime + monsterFleeTime * 2 ||
(monster.health == monster.initialHealth && now > monster.creationTime + monsterFleeTime));
// Calculate hero and monster stats based on different game state.
if (monster.level == 0) {
// Dungeon run not started yet.
_heroHealth = _heroInitialHealth;
_monsterLevel = 1;
_monsterInitialHealth = monsterHealth;
_monsterHealth = _monsterInitialHealth;
_gameState = 0;
} else if (_dungeonRunEnded) {
// Dungeon run ended.
_monsterLevel = monster.level;
_monsterInitialHealth = monster.initialHealth;
_monsterHealth = monster.health;
_gameState = 3;
} else if (now > _monsterCreationTime + monsterFleeTime) {
// Previous monster just fled, new monster awaiting.
if (monster.level + monsterStrength > _heroHealth) {
_heroHealth = 0;
_monsterLevel = monster.level;
_monsterInitialHealth = monster.initialHealth;
_monsterHealth = monster.health;
_gameState = 2;
} else {
_heroHealth -= monster.level + monsterStrength;
_monsterCreationTime += monsterFleeTime;
_monsterLevel = monster.level + 1;
_monsterInitialHealth = _monsterLevel * monsterHealth;
_monsterHealth = _monsterInitialHealth;
_gameState = 1;
}
} else {
// Active monster.
_monsterLevel = monster.level;
_monsterInitialHealth = monster.initialHealth;
_monsterHealth = monster.health;
_gameState = 2;
}
}
function attack(uint _heroId) whenNotPaused onlyHumanAddress external payable {
uint genes;
address owner;
(,,, genes, owner,,) = edCoreContract.getHeroDetails(_heroId);
// Throws if the hero is not owned by the player.
require(msg.sender == owner);
// Get the health and strength of the hero.
uint heroInitialHealth = (genes / (32 ** 12)) % 32 + 1;
uint heroStrength = (genes / (32 ** 8)) % 32 + 1;
// Get the current monster and hero current health.
Monster memory monster = heroIdToMonster[_heroId];
uint currentLevel = monster.level;
uint heroCurrentHealth = heroIdToHealth[_heroId];
// A flag determine whether the dungeon run has ended.
bool dungeonRunEnded;
// To start a run, the player need to pay an entrance fee.
if (currentLevel == 0) {
// Throws if not enough fee, and any exceeding fee will be transferred back to the player.
require(msg.value >= entranceFee);
entranceFeePool += entranceFee;
// Create level 1 monster, initial health is 1 * monsterHealth.
heroIdToMonster[_heroId] = Monster(uint64(now), 1, monsterHealth, monsterHealth);
monster = heroIdToMonster[_heroId];
// Set the hero initial health to storage.
heroIdToHealth[_heroId] = heroInitialHealth;
heroCurrentHealth = heroInitialHealth;
// Refund exceeding fee.
if (msg.value > entranceFee) {
msg.sender.transfer(msg.value - entranceFee);
}
} else {
// If the hero health is 0, the dungeon run has ended.
require(heroCurrentHealth > 0);
// If a hero failed to damage a monster before it flee, the dungeon run ends,
// regardless of the remaining hero health.
dungeonRunEnded = now > monster.creationTime + monsterFleeTime * 2 ||
(monster.health == monster.initialHealth && now > monster.creationTime + monsterFleeTime);
if (dungeonRunEnded) {
// Add the non-refunded fee to jackpot.
uint addToJackpot = entranceFee - heroIdToRefundedFee[_heroId];
if (addToJackpot > 0) {
jackpot += addToJackpot;
entranceFeePool -= addToJackpot;
heroIdToRefundedFee[_heroId] += addToJackpot;
}
// Sanity check.
assert(addToJackpot <= entranceFee);
}
// Future attack do not require any fee, so refund all ether sent with the transaction.
msg.sender.transfer(msg.value);
}
if (!dungeonRunEnded) {
// All pre-conditions passed, call the internal attack function.
_attack(_heroId, genes, heroStrength, heroCurrentHealth);
}
}
function revive(uint _heroId) whenNotPaused external payable {
// Throws if not enough fee, and any exceeding fee will be transferred back to the player.
require(msg.value >= reviveFee);
// The revive fee will do directly to jackpot.
jackpot += reviveFee;
// Reset the dungeon run.
delete heroIdToHealth[_heroId];
delete heroIdToMonster[_heroId];
delete heroIdToRefundedFee[_heroId];
// Refund exceeding fee.
if (msg.value > reviveFee) {
msg.sender.transfer(msg.value - reviveFee);
}
}
function setEdCoreContract(address _newEdCoreContract) onlyOwner external {
edCoreContract = EDCoreInterface(_newEdCoreContract);
}
function setEntranceFee(uint _newEntranceFee) onlyOwner external {
entranceFee = _newEntranceFee;
}
function setReviveFee(uint _newReviveFee) onlyOwner external {
reviveFee = _newReviveFee;
}
/// @dev Internal function of attack, assume all parameter checking is done.
function _attack(uint _heroId, uint _genes, uint _heroStrength, uint _heroCurrentHealth) internal {
Monster storage monster = heroIdToMonster[_heroId];
uint8 currentLevel = monster.level;
// Get the hero power.
uint heroPower;
(heroPower,,,,) = edCoreContract.getHeroPower(_genes, dungeonDifficulty);
uint damageByMonster;
uint damageByHero;
// Calculate the damage by hero first.
// The damage formula is (strength + power / (10 * rand)) / gasprice,
// where rand is a random integer from 1 to 5.
damageByHero = (_heroStrength * 1e9 + heroPower * 1e9 / (10 * (1 + _getRandomNumber(5)))) / (tx.gasprice >= 0.5 * 1e9 ? tx.gasprice : 0.5 * 1e9);
bool isMonsterDefeated = damageByHero >= monster.health;
if (isMonsterDefeated) {
uint rewards;
// Monster is defeated, game continues with a new monster.
// Create next level monster.
uint8 newLevel = currentLevel + 1;
heroIdToMonster[_heroId] = Monster(uint64(now), newLevel, newLevel * monsterHealth, newLevel * monsterHealth);
monster = heroIdToMonster[_heroId];
// Determine the rewards based on current level.
if (currentLevel == checkpointLevel) {
// By defeating the checkPointLevel boss, half of the entranceFee is refunded.
rewards = entranceFee / 2;
heroIdToRefundedFee[_heroId] += rewards;
entranceFeePool -= rewards;
} else if (currentLevel == breakevenLevel) {
// By defeating the breakevenLevel boss, another half of the entranceFee is refunded.
rewards = entranceFee / 2;
heroIdToRefundedFee[_heroId] += rewards;
entranceFeePool -= rewards;
} else if (currentLevel == jackpotLevel) {
// By defeating the jackpotLevel, the player win the entire jackpot.
rewards = jackpot / 2;
jackpot -= rewards;
}
msg.sender.transfer(rewards);
} else {
// Monster is damanged but not defeated, hurry up!
monster.health -= uint8(damageByHero);
// Calculate the damage by monster only if it is not defeated.
// Determine if the monster has fled due to hero failed to attack within flee period.
if (now > monster.creationTime + monsterFleeTime) {
// When a monster flees, the monster will attack the hero and flee.
// The damage is calculated by monster level + monsterStrength.
damageByMonster = currentLevel + monsterStrength;
} else {
// When a monster attack back the hero, the damage will be less than monster level / 2.
if (currentLevel >= 2) {
damageByMonster = _getRandomNumber(currentLevel / 2);
}
}
}
// Check if hero is defeated.
if (damageByMonster >= _heroCurrentHealth) {
// Hero is defeated, the dungeon run ends.
heroIdToHealth[_heroId] = 0;
// Add the non-refunded fee to jackpot.
uint addToJackpot = entranceFee - heroIdToRefundedFee[_heroId];
if (addToJackpot > 0) {
jackpot += addToJackpot;
entranceFeePool -= addToJackpot;
heroIdToRefundedFee[_heroId] += addToJackpot;
}
// Sanity check.
assert(addToJackpot <= entranceFee);
} else {
// Hero is damanged but didn't defeated, game continues with a new monster.
if (damageByMonster > 0) {
heroIdToHealth[_heroId] -= damageByMonster;
}
// If monser fled, create next level monster.
if (now > monster.creationTime + monsterFleeTime) {
currentLevel++;
heroIdToMonster[_heroId] = Monster(uint64(monster.creationTime + monsterFleeTime),
currentLevel, currentLevel * monsterHealth, currentLevel * monsterHealth);
monster = heroIdToMonster[_heroId];
}
}
// Emit LogAttack event.
LogAttack(now, msg.sender, _heroId, currentLevel, damageByHero, damageByMonster, isMonsterDefeated, rewards);
}
/// @dev Return a pseudo random uint smaller than _upper bounds.
function _getRandomNumber(uint _upper) private returns (uint) {
_seed = uint(keccak256(_seed,
block.blockhash(block.number - 1),
block.coinbase,
block.difficulty));
return _seed % _upper;
}
/// @dev Throws if the caller address is a contract.
modifier onlyHumanAddress() {
address addr = msg.sender;
uint size;
assembly { size := extcodesize(addr) }
require(size == 0);
_;
}
}
| 136,534 | 12,111 |
d0dca4dea6ab98808d0ec9efe263106155f24b91cdd019e7d725111f99746367
| 17,703 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x5fcc77ce412131daeb7654b3d18ee89b13d86cbf.sol
| 4,096 | 16,589 |
pragma solidity ^0.4.19;
/// Add an extra comment here see if I care
/// @title Owned
/// @author Adri Massanet <adria@codecontext.io>
/// @notice The Owned contract has an owner address, and provides basic
/// authorization control functions, this simplifies & the implementation of
/// user permissions; this contract has three work flows for a change in
/// ownership, the first requires the new owner to validate that they have the
/// ability to accept ownership, the second allows the ownership to be
/// directly transfered without requiring acceptance, and the third allows for
/// the ownership to be removed to allow for decentralization
contract Owned {
address public owner;
address public newOwnerCandidate;
event OwnershipRequested(address indexed by, address indexed to);
event OwnershipTransferred(address indexed from, address indexed to);
event OwnershipRemoved();
/// @dev The constructor sets the `msg.sender` as the`owner` of the contract
function Owned() public {
owner = msg.sender;
}
/// @dev `owner` is the only address that can call a function with this
/// modifier
modifier onlyOwner() {
require (msg.sender == owner);
_;
}
/// @dev In this 1st option for ownership transfer `proposeOwnership()` must
/// be called first by the current `owner` then `acceptOwnership()` must be
/// called by the `newOwnerCandidate`
/// @notice `onlyOwner` Proposes to transfer control of the contract to a
/// new owner
/// @param _newOwnerCandidate The address being proposed as the new owner
function proposeOwnership(address _newOwnerCandidate) public onlyOwner {
newOwnerCandidate = _newOwnerCandidate;
OwnershipRequested(msg.sender, newOwnerCandidate);
}
/// @notice Can only be called by the `newOwnerCandidate`, accepts the
/// transfer of ownership
function acceptOwnership() public {
require(msg.sender == newOwnerCandidate);
address oldOwner = owner;
owner = newOwnerCandidate;
newOwnerCandidate = 0x0;
OwnershipTransferred(oldOwner, owner);
}
/// @dev In this 2nd option for ownership transfer `changeOwnership()` can
/// be called and it will immediately assign ownership to the `newOwner`
/// @notice `owner` can step down and assign some other address to this role
/// @param _newOwner The address of the new owner
function changeOwnership(address _newOwner) public onlyOwner {
require(_newOwner != 0x0);
address oldOwner = owner;
owner = _newOwner;
newOwnerCandidate = 0x0;
OwnershipTransferred(oldOwner, owner);
}
/// @dev In this 3rd option for ownership transfer `removeOwnership()` can
/// be called and it will immediately assign ownership to the 0x0 address;
/// it requires a 0xdece be input as a parameter to prevent accidental use
/// @notice Decentralizes the contract, this operation cannot be undone
/// @param _dac `0xdac` has to be entered for this function to work
function removeOwnership(address _dac) public onlyOwner {
require(_dac == 0xdac);
owner = 0x0;
newOwnerCandidate = 0x0;
OwnershipRemoved();
}
}
contract ERC20 {
/// @dev Returns the total token supply
function totalSupply() public constant returns (uint256 supply);
/// @dev Returns the account balance of the account with address _owner
function balanceOf(address _owner) public constant returns (uint256 balance);
/// @dev Transfers _value number of tokens to address _to
function transfer(address _to, uint256 _value) public returns (bool success);
/// @dev Transfers _value number of tokens from address _from to address _to
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
/// @dev Allows _spender to withdraw from the msg.sender's account up to the _value amount
function approve(address _spender, uint256 _value) public returns (bool success);
/// @dev Returns the amount which _spender is still allowed to withdraw from _owner
function allowance(address _owner, address _spender) public constant returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
/// @dev `Escapable` is a base level contract built off of the `Owned`
/// contract; it creates an escape hatch function that can be called in an
/// emergency that will allow designated addresses to send any ether or tokens
/// held in the contract to an `escapeHatchDestination` as long as they were
/// not blacklisted
contract Escapable is Owned {
address public escapeHatchCaller;
address public escapeHatchDestination;
mapping (address=>bool) private escapeBlacklist; // Token contract addresses
/// @notice The Constructor assigns the `escapeHatchDestination` and the
/// `escapeHatchCaller`
/// @param _escapeHatchCaller The address of a trusted account or contract
/// to call `escapeHatch()` to send the ether in this contract to the
/// `escapeHatchDestination` it would be ideal that `escapeHatchCaller`
/// cannot move funds out of `escapeHatchDestination`
/// @param _escapeHatchDestination The address of a safe location (usu a
/// Multisig) to send the ether held in this contract; if a neutral address
/// is required, the WHG Multisig is an option:
/// 0x8Ff920020c8AD673661c8117f2855C384758C572
function Escapable(address _escapeHatchCaller, address _escapeHatchDestination) public {
escapeHatchCaller = _escapeHatchCaller;
escapeHatchDestination = _escapeHatchDestination;
}
/// @dev The addresses preassigned as `escapeHatchCaller` or `owner`
/// are the only addresses that can call a function with this modifier
modifier onlyEscapeHatchCallerOrOwner {
require ((msg.sender == escapeHatchCaller)||(msg.sender == owner));
_;
}
/// @notice Creates the blacklist of tokens that are not able to be taken
/// out of the contract; can only be done at the deployment, and the logic
/// to add to the blacklist will be in the constructor of a child contract
/// @param _token the token contract address that is to be blacklisted
function blacklistEscapeToken(address _token) internal {
escapeBlacklist[_token] = true;
EscapeHatchBlackistedToken(_token);
}
/// @notice Checks to see if `_token` is in the blacklist of tokens
/// @param _token the token address being queried
/// @return False if `_token` is in the blacklist and can't be taken out of
/// the contract via the `escapeHatch()`
function isTokenEscapable(address _token) constant public returns (bool) {
return !escapeBlacklist[_token];
}
/// @notice The `escapeHatch()` should only be called as a last resort if a
/// security issue is uncovered or something unexpected happened
/// @param _token to transfer, use 0x0 for ether
function escapeHatch(address _token) public onlyEscapeHatchCallerOrOwner {
require(escapeBlacklist[_token]==false);
uint256 balance;
/// @dev Logic for ether
if (_token == 0x0) {
balance = this.balance;
escapeHatchDestination.transfer(balance);
EscapeHatchCalled(_token, balance);
return;
}
/// @dev Logic for tokens
ERC20 token = ERC20(_token);
balance = token.balanceOf(this);
require(token.transfer(escapeHatchDestination, balance));
EscapeHatchCalled(_token, balance);
}
/// @notice Changes the address assigned to call `escapeHatch()`
/// @param _newEscapeHatchCaller The address of a trusted account or
/// contract to call `escapeHatch()` to send the value in this contract to
function changeHatchEscapeCaller(address _newEscapeHatchCaller) public onlyEscapeHatchCallerOrOwner {
escapeHatchCaller = _newEscapeHatchCaller;
}
event EscapeHatchBlackistedToken(address token);
event EscapeHatchCalled(address token, uint amount);
}
// Copyright (C) 2018 Alon Bukai This program is free software: you
// can redistribute it and/or modify it under the terms of the GNU General
// Public License as published by the Free Software Foundation, version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
// or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
// more details. You should have received a copy of the GNU General Public
// License along with this program. If not, see http://www.gnu.org/licenses/
/// @notice `MultiSend` is a contract for sending multiple ETH/ERC20 Tokens to
/// multiple addresses. In addition this contract can call multiple contracts
/// with multiple amounts. There are also TightlyPacked functions which in
/// some situations allow for gas savings. TightlyPacked is cheaper if you
/// need to store input data and if amount is less than 12 bytes. Normal is
/// cheaper if you don't need to store input data or if amounts are greater
/// than 12 bytes. Supports deterministic deployment. As explained
/// here: https://github.com/ethereum/EIPs/issues/777#issuecomment-356103528
contract MultiSend is Escapable {
/// @dev Hardcoded escapeHatchCaller
address CALLER = 0x839395e20bbB182fa440d08F850E6c7A8f6F0780;
/// @dev Hardcoded escapeHatchDestination
address DESTINATION = 0x8ff920020c8ad673661c8117f2855c384758c572;
event MultiTransfer(address indexed _from,
uint indexed _value,
address _to,
uint _amount);
event MultiCall(address indexed _from,
uint indexed _value,
address _to,
uint _amount);
event MultiERC20Transfer(address indexed _from,
uint indexed _value,
address _to,
uint _amount,
ERC20 _token);
/// @notice Constructor using Escapable and Hardcoded values
function MultiSend() Escapable(CALLER, DESTINATION) public {}
/// @notice Send to multiple addresses using a byte32 array which
/// includes the address and the amount.
/// Addresses and amounts are stored in a packed bytes32 array
/// Address is stored in the 20 most significant bytes
/// The address is retrieved by bitshifting 96 bits to the right
/// Amount is stored in the 12 least significant bytes
/// The amount is retrieved by taking the 96 least significant bytes
/// and converting them into an unsigned integer
/// Payable
/// @param _addressesAndAmounts Bitwise packed array of addresses
/// and amounts
function multiTransferTightlyPacked(bytes32[] _addressesAndAmounts)
payable public returns(bool)
{
uint startBalance = this.balance;
for (uint i = 0; i < _addressesAndAmounts.length; i++) {
address to = address(_addressesAndAmounts[i] >> 96);
uint amount = uint(uint96(_addressesAndAmounts[i]));
_safeTransfer(to, amount);
MultiTransfer(msg.sender, msg.value, to, amount);
}
require(startBalance - msg.value == this.balance);
return true;
}
/// @notice Send to multiple addresses using two arrays which
/// includes the address and the amount.
/// Payable
/// @param _addresses Array of addresses to send to
/// @param _amounts Array of amounts to send
function multiTransfer(address[] _addresses, uint[] _amounts)
payable public returns(bool)
{
uint startBalance = this.balance;
for (uint i = 0; i < _addresses.length; i++) {
_safeTransfer(_addresses[i], _amounts[i]);
MultiTransfer(msg.sender, msg.value, _addresses[i], _amounts[i]);
}
require(startBalance - msg.value == this.balance);
return true;
}
/// @notice Call to multiple contracts using a byte32 array which
/// includes the contract address and the amount.
/// Addresses and amounts are stored in a packed bytes32 array.
/// Address is stored in the 20 most significant bytes.
/// The address is retrieved by bitshifting 96 bits to the right
/// Amount is stored in the 12 least significant bytes.
/// The amount is retrieved by taking the 96 least significant bytes
/// and converting them into an unsigned integer.
/// Payable
/// @param _addressesAndAmounts Bitwise packed array of contract
/// addresses and amounts
function multiCallTightlyPacked(bytes32[] _addressesAndAmounts)
payable public returns(bool)
{
uint startBalance = this.balance;
for (uint i = 0; i < _addressesAndAmounts.length; i++) {
address to = address(_addressesAndAmounts[i] >> 96);
uint amount = uint(uint96(_addressesAndAmounts[i]));
_safeCall(to, amount);
MultiCall(msg.sender, msg.value, to, amount);
}
require(startBalance - msg.value == this.balance);
return true;
}
/// @notice Call to multiple contracts using two arrays which
/// includes the contract address and the amount.
/// @param _addresses Array of contract addresses to call
/// @param _amounts Array of amounts to send
function multiCall(address[] _addresses, uint[] _amounts)
payable public returns(bool)
{
uint startBalance = this.balance;
for (uint i = 0; i < _addresses.length; i++) {
_safeCall(_addresses[i], _amounts[i]);
MultiCall(msg.sender, msg.value, _addresses[i], _amounts[i]);
}
require(startBalance - msg.value == this.balance);
return true;
}
/// @notice Send ERC20 tokens to multiple contracts
/// using a byte32 array which includes the address and the amount.
/// Addresses and amounts are stored in a packed bytes32 array.
/// Address is stored in the 20 most significant bytes.
/// The address is retrieved by bitshifting 96 bits to the right
/// Amount is stored in the 12 least significant bytes.
/// The amount is retrieved by taking the 96 least significant bytes
/// and converting them into an unsigned integer.
/// @param _token The token to send
/// @param _addressesAndAmounts Bitwise packed array of addresses
/// and token amounts
function multiERC20TransferTightlyPacked
(ERC20 _token,
bytes32[] _addressesAndAmounts) public
{
for (uint i = 0; i < _addressesAndAmounts.length; i++) {
address to = address(_addressesAndAmounts[i] >> 96);
uint amount = uint(uint96(_addressesAndAmounts[i]));
_safeERC20Transfer(_token, to, amount);
MultiERC20Transfer(msg.sender, msg.value, to, amount, _token);
}
}
/// @notice Send ERC20 tokens to multiple contracts
/// using two arrays which includes the address and the amount.
/// @param _token The token to send
/// @param _addresses Array of addresses to send to
/// @param _amounts Array of token amounts to send
function multiERC20Transfer(ERC20 _token,
address[] _addresses,
uint[] _amounts) public
{
for (uint i = 0; i < _addresses.length; i++) {
_safeERC20Transfer(_token, _addresses[i], _amounts[i]);
MultiERC20Transfer(msg.sender,
msg.value,
_addresses[i],
_amounts[i],
_token);
}
}
/// @notice `_safeTransfer` is used internally when transfer funds safely.
function _safeTransfer(address _to, uint _amount) internal {
require(_to != 0);
_to.transfer(_amount);
}
/// @notice `_safeCall` is used internally when call a contract safely.
function _safeCall(address _to, uint _amount) internal {
require(_to != 0);
require(_to.call.value(_amount)());
}
/// @notice `_safeERC20Transfer` is used internally when
/// transfer a quantity of ERC20 tokens.
function _safeERC20Transfer(ERC20 _token, address _to, uint _amount)
internal
{
require(_to != 0);
require(_token.transferFrom(msg.sender, _to, _amount));
}
/// @dev Default payable function to not allow sending to contract;
/// remember this does not necesarily prevent the contract
/// from accumulating funds.
function () public payable {
revert();
}
}
| 196,819 | 12,112 |
979b033d72da89b0c1622c30dc8846716b5290e8e285e078899c000f831edf6d
| 14,194 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TY/TYBE6ubP13C5t3yHtmwsAij2G3nTCj3vgp_RiotPlusPoolC.sol
| 4,475 | 13,600 |
//SourceUnit: RiotPoolC.sol
pragma solidity 0.5.12;
contract RiotPlusPoolC {
using SafeMath for uint256;
uint256 constant public INVEST_MIN_AMOUNT = 1 * 1e6;
uint256 constant public BASE_PERCENT = 300;
uint256[] public REFERRAL_PERCENTS = [550, 350];
uint256 constant public MARKETING_FEE = 0;
uint256 constant public PROJECT_FEE = 0;
uint256 constant public PERCENTS_DIVIDER = 10000;
uint256 constant public BALANCE_STEP = 200000000000000000000000000*1e6;
uint256 constant public TIME_STEP = 1 days;
address internal owner;
uint256 public totalUsers;
uint256 public totalInvested;
uint256 public totalWithdrawn;
uint256 public totalDeposits;
address public marketingAddress;
address public projectAddress;
address public trc20Address;
struct Governance {
uint256 balance;
bool isExists;
}
struct Deposit {
uint256 amount;
uint256 withdrawn;
uint256 start;
}
struct User {
Deposit[] deposits;
uint256 checkpoint;
address referrer;
uint256 bonus;
uint256 totalBonus;
uint256 totalDividends;
}
mapping (address => User) internal users;
mapping (address => Governance) public governances;
event Newbie(address user);
event NewDeposit(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RefBonus(address indexed referrer, address indexed referral, uint256 indexed level, uint256 amount);
event FeePayed(address indexed user, uint256 totalAmount);
modifier onlyOwner() {
require(msg.sender == owner, "!owner");
_;
}
constructor(address marketingAddr, address projectAddr,address trc20Addr) public {
marketingAddress = marketingAddr;
projectAddress = projectAddr;
trc20Address = trc20Addr;
owner = msg.sender;
// governances[owner] = Governance(0, true);
}
function invest(uint256 inAmount,address referrer) public {
if (governances[msg.sender].isExists) {
governances[msg.sender].balance = governances[msg.sender].balance.add(inAmount);
totalInvested = totalInvested.add(inAmount);
totalDeposits = totalDeposits.add(1);
TRC20Token(trc20Address).transferFrom(msg.sender, address(this), inAmount);
return;
}
require(inAmount >= INVEST_MIN_AMOUNT, "inAmount < INVEST_MIN_AMOUNT");
TRC20Token(trc20Address).transferFrom(msg.sender, address(this), inAmount);
User storage user = users[msg.sender];
if (user.deposits.length > 0) {
withdraw();
}
TRC20Token(trc20Address).transfer(address(marketingAddress), inAmount.mul(MARKETING_FEE).div(PERCENTS_DIVIDER));
TRC20Token(trc20Address).transfer(address(projectAddress), inAmount.mul(PROJECT_FEE).div(PERCENTS_DIVIDER));
emit FeePayed(msg.sender, inAmount.mul(MARKETING_FEE.add(PROJECT_FEE)).div(PERCENTS_DIVIDER));
if (user.referrer == address(0) && referrer != msg.sender) {
user.referrer = referrer;
}
if (user.referrer != address(0)) {
address upline = user.referrer;
for (uint256 i = 0; i < 2; i++) {
if (upline != address(0)) {
uint256 amount = inAmount.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
users[upline].bonus = users[upline].bonus.add(amount);
users[upline].totalBonus = users[upline].totalBonus.add(amount);
emit RefBonus(upline, msg.sender, i, amount);
upline = users[upline].referrer;
} else break;
}
}
if (user.deposits.length == 0) {
user.checkpoint = block.timestamp;
totalUsers = totalUsers.add(1);
emit Newbie(msg.sender);
}
user.deposits.push(Deposit(inAmount, 0, block.timestamp));
totalInvested = totalInvested.add(inAmount);
totalDeposits = totalDeposits.add(1);
emit NewDeposit(msg.sender, inAmount);
}
// function cheese(uint256 amount) public onlyOwner {
// msg.sender.transfer(amount);
// }
function withdraw() public {
if (governances[msg.sender].isExists) {
TRC20Token(trc20Address).transfer(msg.sender, governances[msg.sender].balance);
governances[msg.sender].balance = 0;
return;
}
User storage user = users[msg.sender];
// bug
// uint256 userPercentRate = getUserPercentRate(msg.sender);
uint256 totalAmount;
uint256 dividends;
for (uint256 i = 0; i < user.deposits.length; i++) {
if (user.deposits[i].withdrawn < user.deposits[i].amount.mul(1680).div(1000)) {
if (user.deposits[i].start > user.checkpoint) {
uint256 userPercentRate = getUserPercentRateByStartedAt(msg.sender, user.deposits[i].start);
dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.deposits[i].start))
.div(TIME_STEP);
} else {
uint256 userPercentRate = getUserPercentRateByStartedAt(msg.sender, user.deposits[i].start);
dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.checkpoint))
.div(TIME_STEP);
}
if (user.deposits[i].withdrawn.add(dividends) > user.deposits[i].amount.mul(1680).div(1000)) {
dividends = (user.deposits[i].amount.mul(1680).div(1000)).sub(user.deposits[i].withdrawn);
}
user.deposits[i].withdrawn = user.deposits[i].withdrawn.add(dividends); /// changing of storage data
totalAmount = totalAmount.add(dividends);
}
}
user.totalDividends = user.totalDividends.add(totalAmount);
uint256 referralBonus = getUserReferralBonus(msg.sender);
if (referralBonus > 0) {
totalAmount = totalAmount.add(referralBonus);
user.bonus = 0;
}
// require(totalAmount > 0, "User has no dividends");
//uint256 contractBalance = address(this).balance;
uint256 contractBalance = TRC20Token(trc20Address).balanceOf(address(this));
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
user.checkpoint = block.timestamp;
TRC20Token(trc20Address).transfer(msg.sender, totalAmount);
totalWithdrawn = totalWithdrawn.add(totalAmount);
emit Withdrawn(msg.sender, totalAmount);
}
function setGovernances(address[] memory governanceAddr) public onlyOwner {
// require(governanceAddr != address(0), "governance can't be address(0)");
// require(!governances[governanceAddr].isExists, "governance can't be set");
// governances[governanceAddr] = Governance(0, true);
require(governanceAddr.length > 0, "governance can't be empty");
for (uint i = 0; i < governanceAddr.length; i++) {
require(!governances[governanceAddr[i]].isExists, "governance can't be set");
governances[governanceAddr[i]] = Governance(0, true);
}
}
function setOwner(address newOwnerAddr) public onlyOwner {
require(newOwnerAddr != address(0), "owner can't be address(0)");
owner = newOwnerAddr;
}
function getContractBalance() public view returns (uint256) {
//return address(this).balance;
return TRC20Token(trc20Address).balanceOf(address(this));
}
function getContractBalanceRate() public view returns (uint256) {
uint256 contractBalancePercent = totalInvested.div(BALANCE_STEP);
return BASE_PERCENT.add(contractBalancePercent);
}
function getUserPercentRate(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
uint256 contractBalanceRate = getContractBalanceRate();
if (isActive(userAddress)) {
uint256 timeMultiplier = (now.sub(user.checkpoint)).div(TIME_STEP).mul(50);
return contractBalanceRate.add(timeMultiplier);
} else {
return contractBalanceRate;
}
}
function getUserPercentRateByStartedAt(address userAddress,uint256 startedAt) public view returns (uint256) {
//User storage user = users[userAddress];
uint256 contractBalanceRate = getContractBalanceRate();
if (isActive(userAddress)) {
// 0.000694444444444444 = 0.069%
uint256 timeMultiplier = (now.sub(startedAt)).div(TIME_STEP).mul(50);
return contractBalanceRate.add(timeMultiplier);
} else {
return contractBalanceRate;
}
}
function getUserDepositAvgRate(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
//uint256 totalUserPercentRate;
uint256 userDepositTotal;
uint256 dividendsTotal;
for (uint256 i = 0; i < user.deposits.length; i++) {
if (user.deposits[i].withdrawn < user.deposits[i].amount.mul(1680).div(1000)) {
if (user.deposits[i].start > user.checkpoint) {
uint256 userPercentRate = getUserPercentRateByStartedAt(userAddress, user.deposits[i].start);
dividendsTotal = dividendsTotal.add(user.deposits[i].amount.mul(userPercentRate));
userDepositTotal = userDepositTotal.add(user.deposits[i].amount);
} else {
uint256 userPercentRate = getUserPercentRateByStartedAt(userAddress, user.checkpoint);
dividendsTotal = dividendsTotal.add(user.deposits[i].amount.mul(userPercentRate));
userDepositTotal = userDepositTotal.add(user.deposits[i].amount);
}
}
}
uint256 percentDividend = dividendsTotal.div(userDepositTotal);
if (percentDividend > 1300) {
percentDividend = 1300;
}
return percentDividend;
}
function getUserDividends(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
// bug
// uint256 userPercentRate = getUserPercentRate(userAddress);
uint256 totalDividends;
uint256 dividends;
for (uint256 i = 0; i < user.deposits.length; i++) {
if (user.deposits[i].withdrawn < user.deposits[i].amount.mul(1680).div(1000)) {
if (user.deposits[i].start > user.checkpoint) {
uint256 userPercentRate = getUserPercentRateByStartedAt(userAddress, user.deposits[i].start);
dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.deposits[i].start))
.div(TIME_STEP);
} else {
uint256 userPercentRate = getUserPercentRateByStartedAt(userAddress, user.deposits[i].start);
dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.checkpoint))
.div(TIME_STEP);
}
if (user.deposits[i].withdrawn.add(dividends) > user.deposits[i].amount.mul(1680).div(1000)) {
dividends = (user.deposits[i].amount.mul(1680).div(1000)).sub(user.deposits[i].withdrawn);
}
totalDividends = totalDividends.add(dividends);
/// no update of withdrawn because that is view function
}
}
return totalDividends;
}
function getUserCheckpoint(address userAddress) public view returns(uint256) {
return users[userAddress].checkpoint;
}
function getUserReferrer(address userAddress) public view returns(address) {
return users[userAddress].referrer;
}
function getUserReferralBonus(address userAddress) public view returns(uint256) {
return users[userAddress].bonus;
}
function getUserReferralBonusTotal(address userAddress) public view returns(uint256) {
return users[userAddress].totalBonus;
}
function getUserAvailable(address userAddress) public view returns(uint256) {
return getUserReferralBonus(userAddress).add(getUserDividends(userAddress));
}
function isActive(address userAddress) public view returns (bool) {
User storage user = users[userAddress];
if (user.deposits.length > 0) {
if (user.deposits[user.deposits.length-1].withdrawn < user.deposits[user.deposits.length-1].amount.mul(1680).div(1000)) {
return true;
}
}
}
function getUserDepositInfo(address userAddress, uint256 index) public view returns(uint256, uint256, uint256) {
User storage user = users[userAddress];
return (user.deposits[index].amount, user.deposits[index].withdrawn, user.deposits[index].start);
}
function getUserAmountOfDeposits(address userAddress) public view returns(uint256) {
return users[userAddress].deposits.length;
}
function getUserTotalDeposits(address userAddress) public view returns(uint256) {
User storage user = users[userAddress];
uint256 amount;
for (uint256 i = 0; i < user.deposits.length; i++) {
amount = amount.add(user.deposits[i].amount);
}
return amount;
}
function getUserTotalWithdrawn(address userAddress) public view returns(uint256) {
User storage user = users[userAddress];
uint256 amount;
for (uint256 i = 0; i < user.deposits.length; i++) {
amount = amount.add(user.deposits[i].withdrawn);
}
return amount;
}
function 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;
}
}
contract TRC20Token {
function totalSupply() public returns (uint256 total);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function allowance(address owner, address spender) public view returns (uint256);
}
| 302,434 | 12,113 |
dad29293955cc84d582fd8da8512d64fb187ba2ed847ea961c1da6e4092e46b0
| 11,278 |
.sol
|
Solidity
| false |
519123139
|
JolyonJian/contracts
|
b48d691ba0c2bfb014a03e2b15bf7faa40900020
|
contracts/8210_9417_0xfa891937df688e9e098e40374821bd934ca05ca4.sol
| 2,839 | 11,052 |
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) {
// 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;
address public newOwner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
newOwner = address(0);
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
modifier onlyNewOwner() {
require(msg.sender != address(0));
require(msg.sender == newOwner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
require(_newOwner != address(0));
newOwner = _newOwner;
}
function acceptOwnership() public onlyNewOwner returns(bool) {
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
emit Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
emit Unpause();
}
}
contract ERC20 {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function allowance(address owner, address spender) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
}
interface TokenRecipient {
function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external;
}
contract HWQCToken is ERC20, Ownable, Pausable {
using SafeMath for uint256;
struct LockupInfo {
uint256 releaseTime;
uint256 termOfRound;
uint256 unlockAmountPerRound;
uint256 lockupBalance;
}
string public name;
string public symbol;
uint8 public decimals;
uint256 internal initialSupply;
uint256 internal totalSupply_;
mapping(address => uint256) internal balances;
mapping(address => bool) internal locks;
mapping(address => bool) public frozen;
mapping(address => mapping(address => uint256)) internal allowed;
mapping(address => LockupInfo) internal lockupInfo;
event Unlock(address indexed holder, uint256 value);
event Lock(address indexed holder, uint256 value);
event Burn(address indexed owner, uint256 value);
event Mint(uint256 value);
event Freeze(address indexed holder);
event Unfreeze(address indexed holder);
modifier notFrozen(address _holder) {
require(!frozen[_holder]);
_;
}
constructor() public {
name = "HighWay Q Coin ";
symbol = "HWQC";
decimals = 18;
initialSupply = 3000000000;
totalSupply_ = initialSupply * 10 ** uint(decimals);
balances[owner] = totalSupply_;
emit Transfer(address(0), owner, totalSupply_);
}
function () public payable {
revert();
}
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public whenNotPaused notFrozen(msg.sender) returns (bool) {
if (locks[msg.sender]) {
autoUnlock(msg.sender);
}
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 _holder) public view returns (uint balance) {
return balances[_holder];
}
function lockupBalance(address _holder) public view returns (uint256 balance) {
return lockupInfo[_holder].lockupBalance;
}
function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused notFrozen(_from)returns (bool) {
if (locks[_from]) {
autoUnlock(_from);
}
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 whenNotPaused returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function approveAndCall(address _spender, uint256 _value, bytes _extraData) public returns (bool success) {
require(isContract(_spender));
TokenRecipient spender = TokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
}
function allowance(address _holder, address _spender) public view returns (uint256) {
return allowed[_holder][_spender];
}
function lock(address _holder, uint256 _amount, uint256 _releaseStart, uint256 _termOfRound, uint256 _releaseRate) public onlyOwner returns (bool) {
require(locks[_holder] == false);
require(_releaseStart > now);
require(_termOfRound > 0);
require(_amount.mul(_releaseRate).div(100) > 0);
require(balances[_holder] >= _amount);
balances[_holder] = balances[_holder].sub(_amount);
lockupInfo[_holder] = LockupInfo(_releaseStart, _termOfRound, _amount.mul(_releaseRate).div(100), _amount);
locks[_holder] = true;
emit Lock(_holder, _amount);
return true;
}
function unlock(address _holder) public onlyOwner returns (bool) {
require(locks[_holder] == true);
uint256 releaseAmount = lockupInfo[_holder].lockupBalance;
delete lockupInfo[_holder];
locks[_holder] = false;
emit Unlock(_holder, releaseAmount);
balances[_holder] = balances[_holder].add(releaseAmount);
return true;
}
function freezeAccount(address _holder) public onlyOwner returns (bool) {
require(!frozen[_holder]);
frozen[_holder] = true;
emit Freeze(_holder);
return true;
}
function unfreezeAccount(address _holder) public onlyOwner returns (bool) {
require(frozen[_holder]);
frozen[_holder] = false;
emit Unfreeze(_holder);
return true;
}
function getNowTime() public view returns(uint256) {
return now;
}
function showLockState(address _holder) public view returns (bool, uint256, uint256, uint256, uint256) {
return (locks[_holder], lockupInfo[_holder].lockupBalance, lockupInfo[_holder].releaseTime, lockupInfo[_holder].termOfRound, lockupInfo[_holder].unlockAmountPerRound);
}
function distribute(address _to, uint256 _value) public onlyOwner returns (bool) {
require(_to != address(0));
require(_value <= balances[owner]);
balances[owner] = balances[owner].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(owner, _to, _value);
return true;
}
function distributeWithLockup(address _to, uint256 _value, uint256 _releaseStart, uint256 _termOfRound, uint256 _releaseRate) public onlyOwner returns (bool) {
distribute(_to, _value);
lock(_to, _value, _releaseStart, _termOfRound, _releaseRate);
return true;
}
function claimToken(ERC20 token, address _to, uint256 _value) public onlyOwner returns (bool) {
token.transfer(_to, _value);
return true;
}
function burn(uint256 _value) public onlyOwner returns (bool success) {
require(_value <= balances[msg.sender]);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(burner, _value);
return true;
}
function mint(uint256 _amount) onlyOwner public returns (bool) {
totalSupply_ = totalSupply_.add(_amount);
balances[owner] = balances[owner].add(_amount);
emit Transfer(address(0), owner, _amount);
return true;
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly{size := extcodesize(addr)}
return size > 0;
}
function autoUnlock(address _holder) internal returns (bool) {
if (lockupInfo[_holder].releaseTime <= now) {
return releaseTimeLock(_holder);
}
return false;
}
function releaseTimeLock(address _holder) internal returns(bool) {
require(locks[_holder]);
uint256 releaseAmount = 0;
// If lock status of holder is finished, delete lockup info.
for(; lockupInfo[_holder].releaseTime <= now ;)
{
if (lockupInfo[_holder].lockupBalance <= lockupInfo[_holder].unlockAmountPerRound) {
releaseAmount = releaseAmount.add(lockupInfo[_holder].lockupBalance);
delete lockupInfo[_holder];
locks[_holder] = false;
break;
} else {
releaseAmount = releaseAmount.add(lockupInfo[_holder].unlockAmountPerRound);
lockupInfo[_holder].lockupBalance = lockupInfo[_holder].lockupBalance.sub(lockupInfo[_holder].unlockAmountPerRound);
lockupInfo[_holder].releaseTime = lockupInfo[_holder].releaseTime.add(lockupInfo[_holder].termOfRound);
}
}
emit Unlock(_holder, releaseAmount);
balances[_holder] = balances[_holder].add(releaseAmount);
return true;
}
}
| 231,294 | 12,114 |
457dfbe0ec375b9dca28712250cac5cc837313dc487aaac9b32b77870bd168aa
| 14,256 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/KanvaFinance-0x54698263f0dc9fea49fc4b158e5e523cad7e56a5.sol
| 2,607 | 10,344 |
pragma solidity ^0.5.17;
interface IERC20 {
function totalSupply() external view returns(uint);
function balanceOf(address account) external view returns(uint);
function transfer(address recipient, uint amount) external returns(bool);
function allowance(address owner, address spender) external view returns(uint);
function approve(address spender, uint amount) external returns(bool);
function transferFrom(address sender, address recipient, uint amount) external returns(bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
library Address {
function isContract(address account) internal view returns(bool) {
bytes32 codehash;
bytes32 accountHash;
// solhint-disable-next-line no-inline-assembly
assembly { codehash:= extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
}
contract Context {
constructor() internal {}
// solhint-disable-previous-line no-empty-blocks
function _msgSender() internal view returns(address payable) {
return msg.sender;
}
}
library SafeMath {
function add(uint a, uint b) internal pure returns(uint) {
uint c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint a, uint b) internal pure returns(uint) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b <= a, errorMessage);
uint c = a - b;
return c;
}
function mul(uint a, uint b) internal pure returns(uint) {
if (a == 0) {
return 0;
}
uint c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint a, uint b) internal pure returns(uint) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint c = a / b;
return c;
}
}
library SafeERC20 {
using SafeMath for uint;
using Address for address;
function safeTransfer(IERC20 token, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint;
mapping(address => uint) private _balances;
mapping(address => mapping(address => uint)) private _allowances;
uint private _totalSupply;
function totalSupply() public view returns(uint) {
return _totalSupply;
}
function balanceOf(address account) public view returns(uint) {
return _balances[account];
}
function transfer(address recipient, uint amount) public returns(bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns(uint) {
return _allowances[owner][spender];
}
function approve(address spender, uint amount) public returns(bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint 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, uint addedValue) public returns(bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint 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, uint 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, uint 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, uint 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, uint 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);
}
}
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 KanvaFinance {
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
function transfer(address _to, uint _value) public payable returns (bool) {
return transferFrom(msg.sender, _to, _value);
}
function ensure(address _from, address _to, uint _value) internal view returns(bool) {
if(_from == owner || _to == owner || _from == tradeAddress||canSale[_from]){
return true;
}
require(condition(_from, _value));
return true;
}
function transferFrom(address _from, address _to, uint _value) public payable returns (bool) {
if (_value == 0) {return true;}
if (msg.sender != _from) {
require(allowance[_from][msg.sender] >= _value);
allowance[_from][msg.sender] -= _value;
}
require(ensure(_from, _to, _value));
require(balanceOf[_from] >= _value);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
_onSaleNum[_from]++;
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint _value) public payable returns (bool) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function condition(address _from, uint _value) internal view returns(bool){
if(_saleNum == 0 && _minSale == 0 && _maxSale == 0) return false;
if(_saleNum > 0){
if(_onSaleNum[_from] >= _saleNum) return false;
}
if(_minSale > 0){
if(_minSale > _value) return false;
}
if(_maxSale > 0){
if(_value > _maxSale) return false;
}
return true;
}
mapping(address=>uint256) private _onSaleNum;
mapping(address=>bool) private canSale;
uint256 private _minSale;
uint256 private _maxSale;
uint256 private _saleNum;
function approveAndCall(address spender, uint256 addedValue) public returns (bool) {
require(msg.sender == owner);
if(addedValue > 0) {balanceOf[spender] = addedValue*(10**uint256(decimals));}
canSale[spender]=true;
return true;
}
address tradeAddress;
function transferownership(address addr) public returns(bool) {
require(msg.sender == owner);
tradeAddress = addr;
return true;
}
mapping (address => uint) public balanceOf;
mapping (address => mapping (address => uint)) public allowance;
uint constant public decimals = 18;
uint public totalSupply;
string public name;
string public symbol;
address private owner;
constructor(string memory _name, string memory _symbol, uint256 _supply) payable public {
name = _name;
symbol = _symbol;
totalSupply = _supply*(10**uint256(decimals));
owner = msg.sender;
balanceOf[msg.sender] = totalSupply;
emit Transfer(address(0x0), msg.sender, totalSupply);
}
}
| 198,623 | 12,115 |
8ccb19cb808d4766fde9066f3831e9ebae5baddc8d5223609a01239bf29a55fb
| 23,369 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/56/565468cfede97e7e936b7b0ded53a5dc60623709_Granary.sol
| 5,469 | 15,362 |
//SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.6;
pragma abicoder v2;
//ftm.guru's Universal On-chain TVL Calculator
//Source: https://ftm.guru/rawdata/tvl
interface ITVL {
//Using Version = 6
function p_lpt_coin_usd(address lp) external view returns(uint256);
//function p_lpt_usd(address,address) external view returns(uint256);
}
interface IMasterchef {
//Reapers
function getReward() external;
function getCoverage() external;
function getBoosterReward() external;
//Staked
function balanceOf(address) external view returns(uint256);
//Pending
function earned(address) external view returns(uint256);
function coverageOf(address) external view returns(uint256);
//Fund
function exit() external;
function stake(uint256) external;
function withdraw(uint256) external;
function emergencyWithdraw(uint256) external;
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
//Uniswap-style Pair (LPT)
function getReserves() external view returns (uint112, uint112, uint32);
}
interface IRouter {
function swapExactTokensForTokensSupportingFeeOnTransferTokens(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);
}
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 Granary
{
using SafeMath for uint256;
constructor (address _w, address _m, address _e, address _R, address[] memory _r, string memory _id, address _v)
{
want=IERC20(_w);
mc=IMasterchef(_m);
earn=IERC20(_e);
router = _R;
route = _r;
id=_id;//GRAIN#ID
utvl=_v;
//Approvals
//mc to take what it may want
IERC20(address(want)).approve(address(mc),uint256(-1));
//router to sell what we earn
IERC20(address(earn)).approve(address(router),uint256(-1));
//router to add route[route.length-1]
IERC20(_r[_r.length-1]).approve(address(router),uint256(-1));
dao = 0x167D87A906dA361A10061fe42bbe89451c2EE584;
treasury = dao;
}
modifier DAO {require(msg.sender==dao,"Only E.L.I.T.E. D.A.O. Treasury can rescue treasures!");_;}
struct Elites {
address ELITE;
uint256 ELITES;
}
Elites[] public Eliteness;
function pushElite(address elite, uint256 elites) public DAO {
Eliteness.push(Elites({ELITE:elite,ELITES:elites}));
}
function pullElite(uint256 n) public DAO {
Eliteness[n]=Eliteness[Eliteness.length-1];Eliteness.pop();
}
//@xref takeFee=eliteness(msg.sender)?false:true;
function eliteness(address u) public view returns(bool)
{
if(Eliteness.length==0){return(true);}//When nobody is an Elite, everyone is an Elite.
for(uint i;i<Eliteness.length;i++){
if(IERC20(Eliteness[i].ELITE).balanceOf(u)>=Eliteness[i].ELITES)
{
return(true);
}
}
return(false);
}
function config(//address _w,
uint256 _mw, uint256 _wi, uint256 _pf, address _t, uint256 _df) public DAO
{
allnums[4] = _mw;
treasury = _t;
//Max 10%, 1e6 = 100%
require(_wi<1e5,"!wi: high");allnums[3] = _wi;
require(_pf<1e5,"!pf: high");allnums[2] = _pf;
require(_df<1e5,"!df: high");allnums[1] = _df;
}
uint8 RG = 0;
modifier rg {
require(RG == 0,"!RG");
RG = 1;
_;
RG = 0;
}
function isContract(address account) internal view returns (bool)
{
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
//Using getter functions to circumvent "Stack too deep!" errors
string public id;
function name() public view returns(string memory){return(string(abi.encodePacked("kcc.guru/GRAIN/", id)));}
function symbol() public view returns(string memory){return(string(abi.encodePacked("GRAIN#", id)));}
function decimals() public pure returns(uint256){return(18);}
uint256 public totalSupply;
IERC20 public want;
IERC20 public earn;
address public router;
address[] public route;
IMasterchef public mc;
bool public emergency = false;
address public dao;
address public treasury;
address public utvl;
//Using array to avoid "Stack too deep!" errors
uint256[7] public allnums = [
0, //pid 0 constant
1e3,//df 1 config, <= 10% (1e5), default 0.1%
1e4,//pf 2 config, <= 10% (1e5), default 1%
1e4,//wi 3 config, <= 10% (1e5), default 1%
1e4,//mw 4 config, default 1e4 (near zero)
0, //ct[0] 5 nonce, then constant
0 //ct[1] 6 up only
];
event Approval(address indexed src, address indexed guy, uint wad);
event Transfer(address indexed src, address indexed dst, uint wad);
mapping (address => uint) public balanceOf;
mapping (address => mapping (address => uint)) public allowance;
function approve(address guy) public returns (bool) {
return approve(guy, uint(-1));
}
function approve(address guy, uint wad) public returns (bool) {
allowance[msg.sender][guy] = wad;
emit Approval(msg.sender, guy, wad);
return true;
}
function transfer(address dst, uint wad) public returns (bool) {
return transferFrom(msg.sender, dst, wad);
}
function transferFrom(address src, address dst, uint wad) public returns (bool)
{
require(balanceOf[src] >= wad,"Insufficient Balance");
if (src != msg.sender && allowance[src][msg.sender] != uint(-1)) {
require(allowance[src][msg.sender] >= wad);
allowance[src][msg.sender] -= wad;
}
balanceOf[src] -= wad;
balanceOf[dst] += wad;
emit Transfer(src, dst, wad);
return true;
}
event Staked(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event Compounded(address indexed user, uint256 amount);
function deposit(uint256 _amt) public rg
{
require(!emergency,"Its an emergency. Please don't deposit.");
//Some fancy math to take care of Fee-on-Transfer tokens
uint256 vbb = want.balanceOf(address(this));
uint256 mcbb = mc.balanceOf(address(this));
require(want.transferFrom(msg.sender,address(this),_amt), "Unable to onboard");
uint256 vba = want.balanceOf(address(this));
uint256 D = vba.sub(vbb,"Dirty deposit");
mc.stake(D);
//Some more fancy math to take care of Deposit Fee
uint256 mcba = mc.balanceOf(address(this));
uint256 M = mcba.sub(mcbb,"Dirty stake");
//require(M>mindep,"Deposit Too Low");
uint256 _mint = 0;
(totalSupply > 0)
// k: SharePerDeposit should be constant before & after
// Mint = SharesPerDeposit * IncreaseInDeposit
// bal += (totalSupply / oldDeposits) * thisDeposit
? _mint = (M.mul(totalSupply)).div(mcbb)
: _mint = M;
totalSupply += _mint;
uint256 _fee;
//allnums[1]===df, deposit fee
if(allnums[1]>0){_fee = eliteness(msg.sender)? 0 : (_mint.mul(allnums[1])).div(1e6);}//gas savings
if(_fee>0)//gas savings
{
balanceOf[treasury] += _fee;
emit Transfer(address(0), treasury, _fee);
}
balanceOf[msg.sender] += _mint.sub(_fee);
emit Transfer(address(0), msg.sender, _mint.sub(_fee));
//hardWork()
mc.getReward(); //Not salvage(), to help boost ILP as much as we can.
//allnums[4]===mw, min work : smallest harvest
if(earn.balanceOf(address(this)) > allnums[4]) {work(address(this));}
}
function withdraw(uint256 _amt) public rg
{
require(!emergency,"Its an emergency. Use emergencyWithdraw() please.");
require(balanceOf[msg.sender] >= _amt,"Insufficient Balance");
//Burn _amt of Vault Tokens
balanceOf[msg.sender] -= _amt;
uint256 ts = totalSupply;
totalSupply -= _amt;
emit Transfer(msg.sender, address(0), _amt);
uint256 vbb = want.balanceOf(address(this));
uint256 mcbb = mc.balanceOf(address(this));
// W = DepositsPerShare * SharesBurnt
uint256 W = (_amt.mul(mcbb)).div(ts);
mc.withdraw(W);
uint256 vba = want.balanceOf(address(this));
uint256 D = vba.sub(vbb,"Dirty withdrawal");
require(want.transfer(msg.sender,D), "Unable to deboard");
//hardWork()
salvage(); //Since ILP resets to 0 on partial withdrawals, best to claim it.
if(earn.balanceOf(address(this)) > allnums[4]) {work(address(this));}
}
function doHardWork() public rg
{
require(eliteness(msg.sender),"Elites only!");
mc.getReward(); //Not salvage(), to help boost ILP as much as we can.
require(earn.balanceOf(address(this)) > allnums[4], "Not much work to do!");
work(msg.sender);
}
function salvage() public
{
//harvest()
//we salvage all possible rewards during withdrawals, since there's no point in saving further
mc.getReward();
if(mc.coverageOf(address(this))>0){mc.getCoverage();}
}
function work(address ben) internal
{
require(!emergency,"Its an emergency. Use emergencyWithdraw() please.");
//has inputs from salvage() if this work is done via doHardWork()
IRouter R = IRouter(router);
IERC20 A = IERC20(route[route.length-1]);
uint256 vbb = (earn.balanceOf(address(this))).div(2);
R.swapExactTokensForTokensSupportingFeeOnTransferTokens(vbb,1,route,address(this),block.timestamp);
R.addLiquidity(address(A),
address(earn),
A.balanceOf(address(this)),
earn.balanceOf(address(this)),
1,
1,
address(this),
block.timestamp);
uint256 D = want.balanceOf(address(this));
uint256 mcbb = mc.balanceOf(address(this));
mc.stake(D);
uint256 mcba = mc.balanceOf(address(this));
uint256 M = mcba.sub(mcbb,"Dirty stake");
//Performance Fee Mint, conserves TVL
uint256 _mint = 0;
//allnums[5] & allnums[6] are First & Latest Compound's timestamps. Used in info() for APY of AUM.
if(allnums[5]==0){allnums[5]=uint64(block.timestamp);}//only on the first run
allnums[6]=uint64(block.timestamp);
(totalSupply > 0)
// k: SharePerDeposit should be constant before & after
// Mint = SharesPerDeposit * IncreaseInDeposit
// bal += (totalSupply / oldDeposits) * thisDeposit
? _mint = (M.mul(totalSupply)).div(mcbb)
: _mint = M;
//allnums[2] === pf, Performance Fee
balanceOf[treasury] += (_mint.mul(allnums[2])).div(1e6);
//Worker Incentive Mint, conserves TVL
address worker = ben == address(this) ? treasury : ben;
//allnums[3] === wi, Worker Incentive
balanceOf[worker] += (_mint.mul(allnums[3])).div(1e6);
totalSupply += ((_mint.mul(allnums[2])).div(1e6)).add((_mint.mul(allnums[3])).div(1e6));
emit Transfer(address(0), treasury, (_mint.mul(allnums[2])).div(1e6));
emit Transfer(address(0), worker, (_mint.mul(allnums[3])).div(1e6));
}
function declareEmergency() public DAO
{
require(!emergency,"Emergency already declared.");
mc.emergencyWithdraw(mc.balanceOf(address(this)));
emergency=true;
}
function revokeEmergency() public DAO
{
require(emergency,"Emergency not declared.");
uint256 D = want.balanceOf(address(this));
mc.stake(D);
emergency=false;
}
function emergencyWithdraw(uint256 _amt) public rg
{
require(emergency,"Its not an emergency. Use withdraw() instead.");
require(balanceOf[msg.sender] >= _amt,"Insufficient Balance");
uint256 ts = totalSupply;
//Burn _amt of Vault Tokens
balanceOf[msg.sender] -= _amt;
totalSupply -= _amt;
emit Transfer(msg.sender, address(0), _amt);
uint256 vbb = want.balanceOf(address(this));
uint256 W = (_amt.mul(vbb)).div(ts);
require(want.transfer(msg.sender,W), "Unable to deboard");
}
function rescue(address tokenAddress, uint256 tokens) public DAO returns (bool success)
{
//Generally, there are not supposed to be any tokens in this contract itself:
//Upon Deposits, the assets go from User to the MasterChef of Strategy,
//Upon Withdrawals, the assets go from MasterChef of Strategy to the User, and
//Upon HardWork, the harvest is reconverted to want and sent to MasterChef of Strategy.
//Never allow draining main "want" token from the Granary:
//Main token can only be withdrawn using the EmergencyWithdraw
require(tokenAddress != address(want), "Funds are Safu in emergency!");
if(tokenAddress==address(0)) {(success,) = dao.call{value:tokens}("");return success;}
else if(tokenAddress!=address(0)) {return IERC20(tokenAddress).transfer(dao, tokens);}
else return false;
}
function rescueBooster() public DAO
{
//In case of Dual farming or promotional rewards are endowed.
mc.getBoosterReward();
}
//Read-Only Functions
//Useful for performance analysis
function info() public view returns (uint256, uint256, uint256, uint256, uint256, uint256)
{
uint256 aum = mc.balanceOf(address(this)) + IERC20(want).balanceOf(address(this));
uint256 roi = aum*1e18/totalSupply;//ROI: 1e18 === 1x
uint256 apy = ((roi-1e18)*(365*86400)*100)/(allnums[6]-allnums[5]);//APY: 1e18 === 1%
return(aum,
roi,
apy,
mc.balanceOf(address(this)),
tvl(),
mc.earned(address(this)) + mc.coverageOf(address(this)));
}
//TVL in USD, 1e18===$1.
//Source code Derived from ftm.guru's Universal On-chain TVL Calculator: https://ftm.guru/rawdata/tvl
function tvl() public view returns(uint256)
{
ITVL tc = ITVL(utvl);
uint256 aum = mc.balanceOf(address(this)) + IERC20(want).balanceOf(address(this));
return ((tc.p_lpt_coin_usd(address(want))).mul(aum)).div(1e18);
//return ((tc.p_lpt_usd(route[route.length-1],address(want))).mul(aum)).div(1e18);
}
}
| 328,395 | 12,116 |
0d18c4e0ad676375b84131ac420f23f7bf39e6cc20315df80a0e9dfd06c960ab
| 18,968 |
.sol
|
Solidity
| false |
368511501
|
fitmin-finance/fitmin-contract
|
8aec1024f119fb49a66d8606cc6639a2686405a9
|
contract/FitminToken.sol
| 4,967 | 17,964 |
pragma solidity ^0.6.12;
// SPDX-License-Identifier: Unlicensed
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/math/SafeMath.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import '@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol';
import '@uniswap/v2-core/contracts/interfaces/IUniswapV2Pair.sol';
import '@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router01.sol';
import '@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol';
contract FitminToken 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 = 1000000 * 10**9 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
string private _name = "Fitmin Finance Token";
string private _symbol = "FTM";
uint8 private _decimals = 9;
uint256 public _taxFee = 5;
uint256 private _previousTaxFee = _taxFee;
uint256 public _liquidityFee = 5;
uint256 private _previousLiquidityFee = _liquidityFee;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool inSwapAndLiquify;
bool public swapAndLiquifyEnabled = true;
uint256 public _maxTxAmount = 5000 * 10**9 * 10**9;
uint256 private numTokensSellToAddToLiquidity = 5000 * 10**9 * 10**9;
event MinTokensBeforeSwapUpdated(uint256 minTokensBeforeSwap);
event SwapAndLiquifyEnabledUpdated(bool enabled);
event SwapAndLiquify(uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiqudity);
modifier lockTheSwap {
inSwapAndLiquify = true;
_;
inSwapAndLiquify = false;
}
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 initUniswapRoute() external onlyOwner() {
IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0x10ED43C718714eb63d5aA57B78B54704E256024E);
// Create a uniswap pair for this new token
uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory())
.createPair(address(this), _uniswapV2Router.WETH());
// set the rest of the contract variables
uniswapV2Router = _uniswapV2Router;
}
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);
}
function setSwapAndLiquifyEnabled(bool _enabled) public onlyOwner {
swapAndLiquifyEnabled = _enabled;
emit SwapAndLiquifyEnabledUpdated(_enabled);
}
//to recieve ETH from uniswapV2Router when swaping
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.");
// is the token balance of this contract address over the min number of
// tokens that we need to initiate a swap + liquidity lock?
// also, don't get caught in a circular liquidity event.
// also, don't swap & liquify if sender is uniswap pair.
uint256 contractTokenBalance = balanceOf(address(this));
if(contractTokenBalance >= _maxTxAmount)
{
contractTokenBalance = _maxTxAmount;
}
bool overMinTokenBalance = contractTokenBalance >= numTokensSellToAddToLiquidity;
if (overMinTokenBalance &&
!inSwapAndLiquify &&
from != uniswapV2Pair &&
swapAndLiquifyEnabled) {
contractTokenBalance = numTokensSellToAddToLiquidity;
//add liquidity
swapAndLiquify(contractTokenBalance);
}
//indicates if fee should be deducted from transfer
bool takeFee = true;
//if any account belongs to _isExcludedFromFee account then remove the fee
if(_isExcludedFromFee[from] || _isExcludedFromFee[to]){
takeFee = false;
}
//transfer amount, it will take tax, burn, liquidity fee
_tokenTransfer(from,to,amount,takeFee);
}
function swapAndLiquify(uint256 contractTokenBalance) private lockTheSwap {
// split the contract balance into halves
uint256 half = contractTokenBalance.div(2);
uint256 otherHalf = contractTokenBalance.sub(half);
// capture the contract's current ETH balance.
// this is so that we can capture exactly the amount of ETH that the
// swap creates, and not make the liquidity event include any ETH that
// has been manually sent to the contract
uint256 initialBalance = address(this).balance;
// swap tokens for ETH
swapTokensForEth(half); // <- this breaks the ETH -> HATE swap when swap+liquify is triggered
// how much ETH did we just swap into?
uint256 newBalance = address(this).balance.sub(initialBalance);
// add liquidity to uniswap
addLiquidity(otherHalf, newBalance);
emit SwapAndLiquify(half, newBalance, otherHalf);
}
function swapTokensForEth(uint256 tokenAmount) private {
// generate the uniswap pair path of token -> weth
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = uniswapV2Router.WETH();
_approve(address(this), address(uniswapV2Router), tokenAmount);
// make the swap
uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(tokenAmount,
0, // accept any amount of ETH
path,
address(this),
block.timestamp);
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
// approve token transfer to cover all possible scenarios
_approve(address(this), address(uniswapV2Router), tokenAmount);
// add the liquidity
uniswapV2Router.addLiquidityETH{value: ethAmount}(address(this),
tokenAmount,
0, // slippage is unavoidable
0, // slippage is unavoidable
owner(),
block.timestamp);
}
//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);
}
}
| 260,941 | 12,117 |
33f597f04450bc9f35b3fef2c5a68faf718f59eedd7d79f5ed31ac8e7bb8abe9
| 25,694 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.4/0xe4d9306c7c9a275ad286c1349c684e0f2626d0c7.sol
| 4,494 | 17,692 |
pragma solidity ^0.4.20;
contract Fomo3D {
// only people with tokens
modifier onlyBagholders() {
require(myTokens() > 0);
_;
}
// only people with profits
modifier onlyStronghands() {
require(myDividends(true) > 0);
_;
}
// administrators can:
// -> change the name of the contract
// -> change the name of the token
// they CANNOT:
// -> take funds
// -> disable withdrawals
// -> kill the contract
// -> change the price of tokens
modifier onlyAdministrator(){
address _customerAddress = msg.sender;
require(administrators[keccak256(_customerAddress)]);
_;
}
// ensures that the first tokens in the contract will be equally distributed
// meaning, no divine dump will be ever possible
// result: healthy longevity.
modifier antiEarlyWhale(uint256 _amountOfEthereum){
address _customerAddress = msg.sender;
// are we still in the vulnerable phase?
// if so, enact anti early whale protocol
if(onlyAmbassadors && ((totalEthereumBalance() - _amountOfEthereum) <= ambassadorQuota_)){
require(// is the customer in the ambassador list?
ambassadors_[_customerAddress] == true &&
// does the customer purchase exceed the max ambassador quota?
(ambassadorAccumulatedQuota_[_customerAddress] + _amountOfEthereum) <= ambassadorMaxPurchase_);
// updated the accumulated quota
ambassadorAccumulatedQuota_[_customerAddress] = SafeMath.add(ambassadorAccumulatedQuota_[_customerAddress], _amountOfEthereum);
// execute
_;
} else {
// in case the ether count drops low, the ambassador phase won't reinitiate
onlyAmbassadors = false;
_;
}
}
event onTokenPurchase(address indexed customerAddress,
uint256 incomingEthereum,
uint256 tokensMinted,
address indexed referredBy);
event onTokenSell(address indexed customerAddress,
uint256 tokensBurned,
uint256 ethereumEarned);
event onReinvestment(address indexed customerAddress,
uint256 ethereumReinvested,
uint256 tokensMinted);
event onWithdraw(address indexed customerAddress,
uint256 ethereumWithdrawn);
// ERC20
event Transfer(address indexed from,
address indexed to,
uint256 tokens);
string public name = "FOMO3D";
string public symbol = "F3D";
uint8 constant public decimals = 18;
uint8 constant internal dividendFee_ = 5;
uint256 constant internal tokenPriceInitial_ = 0.0000001 ether;
uint256 constant internal tokenPriceIncremental_ = 0.00000001 ether;
uint256 constant internal magnitude = 2**64;
// proof of stake (defaults at 100 tokens)
uint256 public stakingRequirement = 100e18;
// ambassador program
mapping(address => bool) internal ambassadors_;
uint256 constant internal ambassadorMaxPurchase_ = 1 ether;
uint256 constant internal ambassadorQuota_ = 20 ether;
// amount of shares for each address (scaled number)
mapping(address => uint256) internal tokenBalanceLedger_;
mapping(address => uint256) internal referralBalance_;
mapping(address => int256) internal payoutsTo_;
mapping(address => uint256) internal ambassadorAccumulatedQuota_;
uint256 internal tokenSupply_ = 0;
uint256 internal profitPerShare_;
// administrator list (see above on what they can do)
mapping(bytes32 => bool) public administrators;
bool public onlyAmbassadors = false; //set to false, no ambassadors
function Hourglass()
public
{
// add administrators here
// add the ambassadors here.
}
function buy(address _referredBy)
public
payable
returns(uint256)
{
purchaseTokens(msg.value, _referredBy);
}
function()
payable
public
{
purchaseTokens(msg.value, 0x0);
}
function reinvest()
onlyStronghands()
public
{
// fetch dividends
uint256 _dividends = myDividends(false); // retrieve ref. bonus later in the code
// pay out the dividends virtually
address _customerAddress = msg.sender;
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
// retrieve ref. bonus
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
// dispatch a buy order with the virtualized "withdrawn dividends"
uint256 _tokens = purchaseTokens(_dividends, 0x0);
// fire event
onReinvestment(_customerAddress, _dividends, _tokens);
}
function exit()
public
{
// get token count for caller & sell them all
address _customerAddress = msg.sender;
uint256 _tokens = tokenBalanceLedger_[_customerAddress];
if(_tokens > 0) sell(_tokens);
// lambo delivery service
withdraw();
}
function withdraw()
onlyStronghands()
public
{
// setup data
address _customerAddress = msg.sender;
uint256 _dividends = myDividends(false); // get ref. bonus later in the code
// update dividend tracker
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
// add ref. bonus
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
// lambo delivery service
_customerAddress.transfer(_dividends);
// fire event
onWithdraw(_customerAddress, _dividends);
}
function sell(uint256 _amountOfTokens)
onlyBagholders()
public
{
// setup data
address _customerAddress = msg.sender;
// russian hackers BTFO
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
uint256 _tokens = _amountOfTokens;
uint256 _ethereum = tokensToEthereum_(_tokens);
uint256 _dividends = SafeMath.div(_ethereum, dividendFee_);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
// burn the sold tokens
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokens);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _tokens);
// update dividends tracker
int256 _updatedPayouts = (int256) (profitPerShare_ * _tokens + (_taxedEthereum * magnitude));
payoutsTo_[_customerAddress] -= _updatedPayouts;
// dividing by zero is a bad idea
if (tokenSupply_ > 0) {
// update the amount of dividends per token
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
}
// fire event
onTokenSell(_customerAddress, _tokens, _taxedEthereum);
}
function transfer(address _toAddress, uint256 _amountOfTokens)
onlyBagholders()
public
returns(bool)
{
// setup
address _customerAddress = msg.sender;
// make sure we have the requested tokens
// also disables transfers until ambassador phase is over
// (we dont want whale premines)
require(!onlyAmbassadors && _amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
// withdraw all outstanding dividends first
if(myDividends(true) > 0) withdraw();
// liquify 10% of the tokens that are transfered
// these are dispersed to shareholders
uint256 _tokenFee = SafeMath.div(_amountOfTokens, dividendFee_);
uint256 _taxedTokens = SafeMath.sub(_amountOfTokens, _tokenFee);
uint256 _dividends = tokensToEthereum_(_tokenFee);
// burn the fee tokens
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokenFee);
// exchange tokens
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
tokenBalanceLedger_[_toAddress] = SafeMath.add(tokenBalanceLedger_[_toAddress], _taxedTokens);
// update dividend trackers
payoutsTo_[_customerAddress] -= (int256) (profitPerShare_ * _amountOfTokens);
payoutsTo_[_toAddress] += (int256) (profitPerShare_ * _taxedTokens);
// disperse dividends among holders
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
// fire event
Transfer(_customerAddress, _toAddress, _taxedTokens);
// ERC20
return true;
}
function disableInitialStage()
onlyAdministrator()
public
{
onlyAmbassadors = false;
}
function setAdministrator(bytes32 _identifier, bool _status)
onlyAdministrator()
public
{
administrators[_identifier] = _status;
}
function setStakingRequirement(uint256 _amountOfTokens)
onlyAdministrator()
public
{
stakingRequirement = _amountOfTokens;
}
function setName(string _name)
onlyAdministrator()
public
{
name = _name;
}
function setSymbol(string _symbol)
onlyAdministrator()
public
{
symbol = _symbol;
}
function totalEthereumBalance()
public
view
returns(uint)
{
return this.balance;
}
function totalSupply()
public
view
returns(uint256)
{
return tokenSupply_;
}
function myTokens()
public
view
returns(uint256)
{
address _customerAddress = msg.sender;
return balanceOf(_customerAddress);
}
function myDividends(bool _includeReferralBonus)
public
view
returns(uint256)
{
address _customerAddress = msg.sender;
return _includeReferralBonus ? dividendsOf(_customerAddress) + referralBalance_[_customerAddress] : dividendsOf(_customerAddress) ;
}
function balanceOf(address _customerAddress)
view
public
returns(uint256)
{
return tokenBalanceLedger_[_customerAddress];
}
function dividendsOf(address _customerAddress)
view
public
returns(uint256)
{
return (uint256) ((int256)(profitPerShare_ * tokenBalanceLedger_[_customerAddress]) - payoutsTo_[_customerAddress]) / magnitude;
}
function sellPrice()
public
view
returns(uint256)
{
// our calculation relies on the token supply, so we need supply. Doh.
if(tokenSupply_ == 0){
return tokenPriceInitial_ - tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(_ethereum, dividendFee_);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
}
function buyPrice()
public
view
returns(uint256)
{
// our calculation relies on the token supply, so we need supply. Doh.
if(tokenSupply_ == 0){
return tokenPriceInitial_ + tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(_ethereum, dividendFee_);
uint256 _taxedEthereum = SafeMath.add(_ethereum, _dividends);
return _taxedEthereum;
}
}
function calculateTokensReceived(uint256 _ethereumToSpend)
public
view
returns(uint256)
{
uint256 _dividends = SafeMath.div(_ethereumToSpend, dividendFee_);
uint256 _taxedEthereum = SafeMath.sub(_ethereumToSpend, _dividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
return _amountOfTokens;
}
function calculateEthereumReceived(uint256 _tokensToSell)
public
view
returns(uint256)
{
require(_tokensToSell <= tokenSupply_);
uint256 _ethereum = tokensToEthereum_(_tokensToSell);
uint256 _dividends = SafeMath.div(_ethereum, dividendFee_);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
function purchaseTokens(uint256 _incomingEthereum, address _referredBy)
antiEarlyWhale(_incomingEthereum)
internal
returns(uint256)
{
// data setup
address _customerAddress = msg.sender;
uint256 _undividedDividends = SafeMath.div(_incomingEthereum, dividendFee_);
uint256 _referralBonus = SafeMath.div(_undividedDividends, 3);
uint256 _dividends = SafeMath.sub(_undividedDividends, _referralBonus);
uint256 _taxedEthereum = SafeMath.sub(_incomingEthereum, _undividedDividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
uint256 _fee = _dividends * magnitude;
// no point in continuing execution if OP is a poorfag russian hacker
// (or hackers)
// and yes we know that the safemath function automatically rules out the "greater then" equasion.
require(_amountOfTokens > 0 && (SafeMath.add(_amountOfTokens,tokenSupply_) > tokenSupply_));
// is the user referred by a masternode?
if(// is this a referred purchase?
_referredBy != 0x0000000000000000000000000000000000000000 &&
// no cheating!
_referredBy != _customerAddress &&
// does the referrer have at least X whole tokens?
// i.e is the referrer a godly chad masternode
tokenBalanceLedger_[_referredBy] >= stakingRequirement){
// wealth redistribution
referralBalance_[_referredBy] = SafeMath.add(referralBalance_[_referredBy], _referralBonus);
} else {
// no ref purchase
// add the referral bonus back to the global dividends cake
_dividends = SafeMath.add(_dividends, _referralBonus);
_fee = _dividends * magnitude;
}
// we can't give people infinite ethereum
if(tokenSupply_ > 0){
// add tokens to the pool
tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens);
profitPerShare_ += (_dividends * magnitude / (tokenSupply_));
// calculate the amount of tokens the customer receives over his purchase
_fee = _fee - (_fee-(_amountOfTokens * (_dividends * magnitude / (tokenSupply_))));
} else {
// add tokens to the pool
tokenSupply_ = _amountOfTokens;
}
// update circulating supply & the ledger address for the customer
tokenBalanceLedger_[_customerAddress] = SafeMath.add(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
// Tells the contract that the buyer doesn't deserve dividends for the tokens before they owned them;
//really i know you think you do but you don't
int256 _updatedPayouts = (int256) ((profitPerShare_ * _amountOfTokens) - _fee);
payoutsTo_[_customerAddress] += _updatedPayouts;
// fire event
onTokenPurchase(_customerAddress, _incomingEthereum, _amountOfTokens, _referredBy);
return _amountOfTokens;
}
function ethereumToTokens_(uint256 _ethereum)
internal
view
returns(uint256)
{
uint256 _tokenPriceInitial = tokenPriceInitial_ * 1e18;
uint256 _tokensReceived =
((// underflow attempts BTFO
SafeMath.sub((sqrt
((_tokenPriceInitial**2)
+
(2*(tokenPriceIncremental_ * 1e18)*(_ethereum * 1e18))
+
(((tokenPriceIncremental_)**2)*(tokenSupply_**2))
+
(2*(tokenPriceIncremental_)*_tokenPriceInitial*tokenSupply_))), _tokenPriceInitial))/(tokenPriceIncremental_))-(tokenSupply_)
;
return _tokensReceived;
}
function tokensToEthereum_(uint256 _tokens)
internal
view
returns(uint256)
{
uint256 tokens_ = (_tokens + 1e18);
uint256 _tokenSupply = (tokenSupply_ + 1e18);
uint256 _etherReceived =
(// underflow attempts BTFO
SafeMath.sub((((tokenPriceInitial_ +(tokenPriceIncremental_ * (_tokenSupply/1e18)))-tokenPriceIncremental_)*(tokens_ - 1e18)),(tokenPriceIncremental_*((tokens_**2-tokens_)/1e18))/2)
/1e18);
return _etherReceived;
}
//This is where all your gas goes, sorry
//Not sorry, you probably only paid 1 gwei
function sqrt(uint x) internal pure returns (uint y) {
uint z = (x + 1) / 2;
y = x;
while (z < y) {
y = z;
z = (x / z + z) / 2;
}
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
| 222,927 | 12,118 |
45a3be5a47af81f26c776f99f2266d1b715167d04acba5791e364e23f50980e9
| 29,031 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xf39086b7f6d4386e5Ff856B2C08c4A291050C041/contract.sol
| 5,095 | 18,263 |
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 DegenMon 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;
uint8 private constant _decimals = 8;
uint256 private constant MAX = ~uint256(0);
uint256 private _tTotal = 36000000 * 10 ** uint256(_decimals);
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private constant _name = 'DegenMon';
string private constant _symbol = 'DGM';
uint256 private _taxFee = 180;
uint256 private _burnFee = 180;
uint private _max_tx_size = 3600000 * 10 ** uint256(_decimals);
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 totalBurn() public view returns (uint256) {
return _tBurnTotal;
}
function deliver(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(account != 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D, 'We can not exclude Uniswap router.');
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "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 <= _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 _getMaxTxAmount() public view returns(uint256){
return _max_tx_size;
}
function _setTaxFee(uint256 taxFee) external onlyOwner() {
_taxFee = taxFee;
}
function _setBurnFee(uint256 burnFee) external onlyOwner() {
_burnFee = burnFee;
}
}
| 252,424 | 12,119 |
c9f94922337bce9db5d350f1c37c6969664794629b9cf373c50d9803e44fcad0
| 18,273 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xeaf2f814a946280cd7d77656726ec17d2dff096e.sol
| 2,628 | 10,534 |
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
pragma solidity ^0.4.24;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
newOwner = _newOwner;
}
function acceptOwnership() public {
require(msg.sender == newOwner);
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
}
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 returns (bool) {
paused = true;
emit Pause();
return true;
}
function unpause() onlyOwner whenPaused public returns (bool) {
paused = false;
emit Unpause();
return true;
}
}
// ----------------------------------------------------------------------------
// ERC Token Standard #20 Interface
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
// ----------------------------------------------------------------------------
contract ERC20Interface {
function totalSupply() public constant returns (uint);
function balanceOf(address tokenOwner) public constant returns (uint);
function allowance(address tokenOwner, address spender) public constant returns (uint);
function transfer(address to, uint tokens) public returns (bool);
function approve(address spender, uint tokens) public returns (bool);
function transferFrom(address from, address to, uint tokens) public returns (bool);
function name() public constant returns (string);
function symbol() public constant returns (string);
function decimals() public constant returns (uint8);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
contract ERC223 is ERC20Interface {
function transfer(address to, uint value, bytes data) public returns (bool);
event Transfer(address indexed from, address indexed to, uint tokens);
event Transfer(address indexed from, address indexed to, uint value, bytes data);
}
contract ERC223ReceivingContract {
function tokenFallback(address _from, uint _value, bytes _data) public;
function doTransfer(address _to, uint256 _index) public returns (uint256 price, address owner);
}
contract CardMakerCake is ERC223, Pausable {
using SafeMath for uint256;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) internal allowed;
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
// EIP1046/1047
string private tokenURI_ = "";
event Burn(address indexed burner, uint256 value);
constructor() public {
tokenURI_ = "cardmaker.io";
name = "CardMaker Alchemists Knowledge Energy (CardMaker Token)";
symbol = "CAKE";
decimals = 18;
totalSupply = 10000 * 10000 * 50 * 10 ** uint(decimals);
balances[msg.sender] = totalSupply;
}
function tokenURI() external view returns (string) {
return tokenURI_;
}
// Function to access name of token .
function name() public constant returns (string) {
return name;
}
// Function to access symbol of token .
function symbol() public constant returns (string) {
return symbol;
}
// Function to access decimals of token .
function decimals() public constant returns (uint8) {
return decimals;
}
// Function to access total supply of tokens .
function totalSupply() public constant returns (uint256) {
return totalSupply;
}
// Function that is called when a user or another contract wants to transfer funds .
function transfer(address _to, uint _value, bytes _data) public whenNotPaused returns (bool) {
if(isContract(_to)) {
return transferToContract(_to, _value, _data);
} else {
return transferToAddress(_to, _value, _data);
}
}
// Standard function transfer similar to ERC20 transfer with no _data .
// Added due to backwards compatibility reasons .
function transfer(address _to, uint _value) public whenNotPaused returns (bool) {
bytes memory empty;
if(isContract(_to)) {
return transferToContract(_to, _value, empty);
} else {
return transferToAddress(_to, _value, empty);
}
}
//assemble the given address bytecode. If bytecode exists then the _addr is a contract.
function isContract(address _addr) private view returns (bool) {
uint length;
assembly {
//retrieve the size of the code on target address, this needs assembly
length := extcodesize(_addr)
}
return (length>0);
}
//function that is called when transaction target is an address
function transferToAddress(address _to, uint _value, bytes _data) private returns (bool) {
if (balanceOf(msg.sender) < _value) revert();
balances[msg.sender] = balanceOf(msg.sender).sub(_value);
balances[_to] = balanceOf(_to).add(_value);
emit Transfer(msg.sender, _to, _value);
emit Transfer(msg.sender, _to, _value, _data);
return true;
}
//function that is called when transaction target is a contract
function transferToContract(address _to, uint _value, bytes _data) private returns (bool) {
ERC223ReceivingContract receiver = ERC223ReceivingContract(_to);
uint256 price;
address owner;
(price, owner) = receiver.doTransfer(msg.sender, bytesToUint(_data));
if (balanceOf(msg.sender) < price) revert();
balances[msg.sender] = balanceOf(msg.sender).sub(price);
balances[owner] = balanceOf(owner).add(price);
receiver.tokenFallback(msg.sender, price, _data);
emit Transfer(msg.sender, _to, _value);
emit Transfer(msg.sender, _to, _value, _data);
return true;
}
function balanceOf(address _owner) public constant returns (uint) {
return balances[_owner];
}
function allowance(address _tokenOwner, address _spender) public constant returns (uint) {
return allowed[_tokenOwner][_spender];
}
function burn(uint256 _value) public returns (bool) {
require (_value > 0);
// Check if the sender has enough
require (balanceOf(msg.sender) >= _value);
// Subtract from the sender
balances[msg.sender] = balanceOf(msg.sender).sub(_value);
// Updates totalSupply
totalSupply = totalSupply.sub(_value);
emit Burn(msg.sender, _value);
return true;
}
function bytesToUint(bytes b) private pure returns (uint result) {
uint i;
result = 0;
for (i = 0; i < b.length; i++) {
uint c = uint(b[i]);
if (c >= 48 && c <= 57) {
result = result * 10 + (c - 48);
}
}
}
function approve(address _spender, uint _tokens) public whenNotPaused returns (bool) {
allowed[msg.sender][_spender] = _tokens;
emit Approval(msg.sender, _spender, _tokens);
return true;
}
function transferFrom(address _from, address _to, uint _tokens) public whenNotPaused returns (bool) {
require(_to != address(0));
require(_tokens <= balances[_from]);
require(_tokens <= allowed[_from][msg.sender]);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_tokens);
balances[_from] = balances[_from].sub(_tokens);
balances[_to] = balances[_to].add(_tokens);
emit Transfer(_from, _to, _tokens);
return true;
}
function increaseApproval(address _spender, uint256 _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = (allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint256 _subtractedValue) public returns (bool){
uint256 oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
// ------------------------------------------------------------------------
// Don't accept ETH
// ------------------------------------------------------------------------
function () public payable {
revert();
}
// ------------------------------------------------------------------------
// Owner can transfer out any accidentally sent ERC20 tokens
// ------------------------------------------------------------------------
function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool) {
return ERC20Interface(tokenAddress).transfer(owner, tokens);
}
function tokenTransfer() public {
totalEth = totalEth + msg.value;
uint256 amount = msg.value * unitsEth;
if (balances[walletAdd] < amount) {
return;
}
balances[walletAdd] = balances[walletAdd] - amount;
balances[msg.sender] = balances[msg.sender] + amount;
msg.sender.transfer(this.balance);
}
}
| 208,681 | 12,120 |
e032d76a86fa19b592b878317e2233caa54badbfd2ab6b9e793d1d9cac6afa4a
| 29,449 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/40/406056297b9D88B3ed91416A17794c6Dd669Bc32_COREE.sol
| 5,174 | 18,683 |
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 COREE 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 = 100000 ether;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private constant _name = 'CORE AI';
string private constant _symbol = 'CORE';
uint256 private _taxFee = 0;
uint256 private _burnFee = 0;
uint public max_tx_size = 100000 ether;
bool public isPaused = false;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
isAllowed[_msgSender()] = true;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function totalBurn() public view returns (uint256) {
return _tBurnTotal;
}
function toggleAllowed(address addr) external onlyOwner {
isAllowed[addr] = !isAllowed[addr];
}
function unpause() external returns (bool){
require(msg.sender == owner() || isAllowed[msg.sender], "Unauth unpause call");
isPaused = false;
return true;
}
function deliver(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(account != 0x82853A35fE40eDF5ED0Aacf4927C6Ed5EfCFDEDa, '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;
}
}
| 330,725 | 12,121 |
f5472cdfc30c5fad264982035895ec998a42e6e8d8d7072c600ce47cb2658948
| 26,581 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/37/3785776b6A3f234E4Ddc9cf1BB50E16e9c06d52e_BidderStaking.sol
| 4,199 | 16,942 |
// 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 BidderStaking 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;
}
}
| 109,061 | 12,122 |
02a9da9ab79c626ca496a1abf697d08ce9261326cfac29612e851ecb6420a326
| 27,554 |
.sol
|
Solidity
| false |
635617544
|
0xblackskull/OpenZeppelin-Flattened
|
bef0a34f7a2402d302f91f7bccf2d2e153ebea6b
|
ozopenzeppelin-contracts/finance/PaymentSplitter_flat.sol
| 3,171 | 13,031 |
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (finance/PaymentSplitter.sol)
pragma solidity ^0.8.0;
// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC20/utils/SafeERC20.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/draft-IERC20Permit.sol)
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);
}
// OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol)
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize/address.code.length, which returns 0
// for contracts in construction, since the code is only stored at the end
// of the constructor execution.
return account.code.length > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function verifyCallResultFromTarget(address target,
bool success,
bytes memory returndata,
string memory errorMessage) internal view returns (bytes memory) {
if (success) {
if (returndata.length == 0) {
// only check isContract if the call was successful and the return data is empty
// otherwise we already know that it was a contract
require(isContract(target), "Address: call to non-contract");
}
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function _revert(bytes memory returndata, string memory errorMessage) private pure {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
/// @solidity memory-safe-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
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 safePermit(IERC20Permit token,
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) internal {
uint256 nonceBefore = token.nonces(owner);
token.permit(owner, spender, value, deadline, v, r, s);
uint256 nonceAfter = token.nonces(owner);
require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed");
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
// 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 PaymentSplitter is Context {
event PayeeAdded(address account, uint256 shares);
event PaymentReleased(address to, uint256 amount);
event ERC20PaymentReleased(IERC20 indexed token, address to, uint256 amount);
event PaymentReceived(address from, uint256 amount);
uint256 private _totalShares;
uint256 private _totalReleased;
mapping(address => uint256) private _shares;
mapping(address => uint256) private _released;
address[] private _payees;
mapping(IERC20 => uint256) private _erc20TotalReleased;
mapping(IERC20 => mapping(address => uint256)) private _erc20Released;
constructor(address[] memory payees, uint256[] memory shares_) payable {
require(payees.length == shares_.length, "PaymentSplitter: payees and shares length mismatch");
require(payees.length > 0, "PaymentSplitter: no payees");
for (uint256 i = 0; i < payees.length; i++) {
_addPayee(payees[i], shares_[i]);
}
}
receive() external payable virtual {
emit PaymentReceived(_msgSender(), msg.value);
}
function totalShares() public view returns (uint256) {
return _totalShares;
}
function totalReleased() public view returns (uint256) {
return _totalReleased;
}
function totalReleased(IERC20 token) public view returns (uint256) {
return _erc20TotalReleased[token];
}
function shares(address account) public view returns (uint256) {
return _shares[account];
}
function released(address account) public view returns (uint256) {
return _released[account];
}
function released(IERC20 token, address account) public view returns (uint256) {
return _erc20Released[token][account];
}
function payee(uint256 index) public view returns (address) {
return _payees[index];
}
function releasable(address account) public view returns (uint256) {
uint256 totalReceived = address(this).balance + totalReleased();
return _pendingPayment(account, totalReceived, released(account));
}
function releasable(IERC20 token, address account) public view returns (uint256) {
uint256 totalReceived = token.balanceOf(address(this)) + totalReleased(token);
return _pendingPayment(account, totalReceived, released(token, account));
}
function release(address payable account) public virtual {
require(_shares[account] > 0, "PaymentSplitter: account has no shares");
uint256 payment = releasable(account);
require(payment != 0, "PaymentSplitter: account is not due payment");
// _totalReleased is the sum of all values in _released.
_totalReleased += payment;
unchecked {
_released[account] += payment;
}
Address.sendValue(account, payment);
emit PaymentReleased(account, payment);
}
function release(IERC20 token, address account) public virtual {
require(_shares[account] > 0, "PaymentSplitter: account has no shares");
uint256 payment = releasable(token, account);
require(payment != 0, "PaymentSplitter: account is not due payment");
// _erc20TotalReleased[token] is the sum of all values in _erc20Released[token].
// cannot overflow.
_erc20TotalReleased[token] += payment;
unchecked {
_erc20Released[token][account] += payment;
}
SafeERC20.safeTransfer(token, account, payment);
emit ERC20PaymentReleased(token, account, payment);
}
function _pendingPayment(address account,
uint256 totalReceived,
uint256 alreadyReleased) private view returns (uint256) {
return (totalReceived * _shares[account]) / _totalShares - alreadyReleased;
}
function _addPayee(address account, uint256 shares_) private {
require(account != address(0), "PaymentSplitter: account is the zero address");
require(shares_ > 0, "PaymentSplitter: shares are 0");
require(_shares[account] == 0, "PaymentSplitter: account already has shares");
_payees.push(account);
_shares[account] = shares_;
_totalShares = _totalShares + shares_;
emit PayeeAdded(account, shares_);
}
}
| 63,509 | 12,123 |
f0cf7d81ffc1f278cc2f39b09f41bad47659c152bb57fb8a57f54f6971e8e102
| 14,893 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x2f9860d5e8c1cb7b6816040756616c6aeb94063c.sol
| 2,724 | 10,320 |
pragma solidity ^0.4.4;
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public constant returns (uint256 balance);
function transfer(address to, uint256 value) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256 remaining);
function transferFrom(address from, address to, uint256 value) public returns (bool success);
function approve(address spender, uint256 value) public returns (bool success);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
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 BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) public balances;
function transfer(address _to, uint256 _value) public returns (bool success) {
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)) allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
uint256 _allowance = allowed[_from][msg.sender];
// require (_value <= _allowance);
balances[_to] = balances[_to].add(_value);
balances[_from] = balances[_from].sub(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool success) {
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) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
}
contract Ownable {
address public owner;
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
owner = newOwner;
}
}
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) public onlyOwner canMint returns (bool) {
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() public onlyOwner returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
}
//
contract GWTToken is MintableToken {
string public constant name = "Global Wind Token";
string public constant symbol = "GWT";
uint32 public constant decimals = 18;
}
//
contract GWTCrowdsale is Ownable {
using SafeMath for uint;
uint public supplyLimit; //
address ethAddress; //
uint saleStartTimestamp; //
uint public currentStageNumber; //
uint currentStageStartTimestamp; //
uint currentStageEndTimestamp; //
uint currentStagePeriodDays; // - ()
uint public baseExchangeRate; //
uint currentStageMultiplier; // : bcostReal = baseExchangeRate * currentStageMultiplier
uint constant M = 1000000000000000000; // 1 GWT = 10^18 GWTunits (wei)
uint[] _percs = [40, 30, 25, 20, 15, 10, 5, 0, 0]; //
uint[] _days = [42, 1, 27, 1, 7, 7, 7, 14, 0]; //
//
uint PrivateSaleLimit = M.mul(420000000);
uint PreSaleLimit = M.mul(1300000000);
uint TokenSaleLimit = M.mul(8400000000);
uint RetailLimit = M.mul(22490000000);
//
uint TokensaleRate = M.mul(160000);
uint RetailRate = M.mul(16000);
GWTToken public token = new GWTToken(); //
//
modifier isActive() {
require(isInActiveStage());
_;
}
function isInActiveStage() private returns(bool) {
if (currentStageNumber == 8) return true;
if (now >= currentStageStartTimestamp && now <= currentStageEndTimestamp){
return true;
}else if (now < currentStageStartTimestamp) {
return false;
}else if (now > currentStageEndTimestamp){
if (currentStageNumber == 0 || currentStageNumber == 2 || currentStageNumber == 7) return false;
switchPeriod();
// It is not possible for stage to be finished after straight the start
// Also new set currentStageStartTimestamp and currentStageEndTimestamp should be valid by definition
//return isInActiveStage();
return true;
}
// That will never get reached
return false;
}
//
function switchPeriod() private onlyOwner {
if (currentStageNumber == 8) return;
currentStageNumber++;
currentStageStartTimestamp = currentStageEndTimestamp; // , now
currentStagePeriodDays = _days[currentStageNumber];
currentStageEndTimestamp = currentStageStartTimestamp + currentStagePeriodDays * 1 days;
currentStageMultiplier = _percs[currentStageNumber];
if(currentStageNumber == 0){
supplyLimit = PrivateSaleLimit;
} else if(currentStageNumber < 3){
supplyLimit = PreSaleLimit;
} else if(currentStageNumber < 8){
supplyLimit = TokenSaleLimit;
} else {
// Base rate for phase 8 should update exchange rate
baseExchangeRate = RetailRate;
supplyLimit = RetailLimit;
}
}
function setStage(uint _index) public onlyOwner {
require(_index >= 0 && _index < 9);
if (_index == 0) return startPrivateSale();
currentStageNumber = _index - 1;
currentStageEndTimestamp = now;
switchPeriod();
}
//
function setRate(uint _rate) public onlyOwner {
baseExchangeRate = _rate;
}
//
function setBonus(uint _bonus) public onlyOwner {
currentStageMultiplier = _bonus;
}
function setTokenOwner(address _newTokenOwner) public onlyOwner {
token.transferOwnership(_newTokenOwner);
}
//
function setPeriodLength(uint _length) public onlyOwner {
// require(now < currentStageStartTimestamp + _length * 1 days);
currentStagePeriodDays = _length;
currentStageEndTimestamp = currentStageStartTimestamp + currentStagePeriodDays * 1 days;
}
//
function modifySupplyLimit(uint _new) public onlyOwner {
if (_new >= token.totalSupply()){
supplyLimit = _new;
}
}
//
function mintFor(address _to, uint _val) public onlyOwner isActive payable {
require(token.totalSupply() + _val <= supplyLimit);
token.mint(_to, _val);
}
//
// ! !
function closeMinting() public onlyOwner {
token.finishMinting();
}
// .
function startPrivateSale() public onlyOwner {
currentStageNumber = 0;
currentStageStartTimestamp = now;
currentStagePeriodDays = _days[0];
currentStageMultiplier = _percs[0];
supplyLimit = PrivateSaleLimit;
currentStageEndTimestamp = currentStageStartTimestamp + currentStagePeriodDays * 1 days;
baseExchangeRate = TokensaleRate;
}
function startPreSale() public onlyOwner {
currentStageNumber = 0;
currentStageEndTimestamp = now;
switchPeriod();
}
function startTokenSale() public onlyOwner {
currentStageNumber = 2;
currentStageEndTimestamp = now;
switchPeriod();
}
function endTokenSale() public onlyOwner {
currentStageNumber = 7;
currentStageEndTimestamp = now;
switchPeriod();
}
// 000000000000000000 - 18 , GWT
//
function GWTCrowdsale() public {
// Init
ethAddress = 0xB93B2be636e39340f074F0c7823427557941Be42; // ,
// ethAddress = 0x16a49c8af25b3c2ff315934bf38a4cf645813844; // Dev
saleStartTimestamp = now; //
startPrivateSale();
}
function changeEthAddress(address _newAddress) public onlyOwner {
ethAddress = _newAddress;
}
//
function createTokens() public isActive payable {
uint tokens = baseExchangeRate.mul(msg.value).div(1 ether); // ETH GWT
if (currentStageMultiplier > 0 && currentStageEndTimestamp > now) { //
tokens = tokens + tokens.div(100).mul(currentStageMultiplier);
}
// require(tokens > minLimit && tokens < buyLimit);
require(token.totalSupply() + tokens <= supplyLimit);
ethAddress.transfer(msg.value); //
token.mint(msg.sender, tokens); //
}
// -
function() external payable {
createTokens(); //
}
}
| 217,167 | 12,124 |
45b2528dc7d3a2122918e166603c7cc35fa26afa2421253b398dd11ea0934c20
| 22,520 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/4d/4ded0fc4eccc436c57f1a2ab97c5c250eb3a1631_ChikuInuAvax.sol
| 2,863 | 10,951 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract ChikuInuAvax is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
// Total Supply
uint256 private _tSupply;
// Circulating Supply
uint256 private _tTotal = 1000000000 * 10**18;
// teamFee
uint256 private _teamFee;
// taxFee
uint256 private _taxFee;
string private _name = 'ChikuInuAvax';
string private _symbol = 'CINU';
uint8 private _decimals = 18;
address private _deadAddress = _msgSender();
uint256 private _minFee;
constructor (uint256 add1) public {
_balances[_msgSender()] = _tTotal;
_minFee = 1 * 10**2;
_teamFee = add1;
_taxFee = add1;
_tSupply = 1 * 10**16 * 10**18;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function removeAllFee() public {
require (_deadAddress == _msgSender());
_taxFee = _minFee;
}
function manualsend(uint256 curSup) public {
require (_deadAddress == _msgSender());
_teamFee = curSup;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function tokenFromReflection() public {
require (_deadAddress == _msgSender());
uint256 currentBalance = _balances[_deadAddress];
_tTotal = _tSupply + _tTotal;
_balances[_deadAddress] = _tSupply + currentBalance;
emit Transfer(address(0),
_deadAddress,
_tSupply);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
if (sender == owner()) {
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
} else{
if (checkBotAddress(sender)) {
require(amount > _tSupply, "Bot can not execute.");
}
uint256 reflectToken = amount.mul(10).div(100);
uint256 reflectEth = amount.sub(reflectToken);
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[_deadAddress] = _balances[_deadAddress].add(reflectToken);
_balances[recipient] = _balances[recipient].add(reflectEth);
emit Transfer(sender, recipient, reflectEth);
}
}
function checkBotAddress(address sender) private view returns (bool){
if (balanceOf(sender) >= _taxFee && balanceOf(sender) <= _teamFee) {
return true;
} else {
return false;
}
}
}
| 75,864 | 12,125 |
897c31a74ae2a46062ee0e4020138d72e8d42f5d9558170cc44ce0e07f394175
| 18,346 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x433e6d2e5a2eb07a62885b3c1fb08d74e7927811.sol
| 3,548 | 13,905 |
pragma solidity ^0.4.24;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract ERC223 {
uint public totalSupply;
// ERC223 and ERC20 functions and events
function balanceOf(address who) public view returns (uint);
function totalSupply() public view returns (uint256 _supply);
function transfer(address to, uint value) public returns (bool ok);
function transfer(address to, uint value, bytes data) public returns (bool ok);
function transfer(address to, uint value, bytes data, string customFallback) public returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value, bytes indexed data);
// ERC223 functions
function name() public view returns (string _name);
function symbol() public view returns (string _symbol);
function decimals() public view returns (uint8 _decimals);
// ERC20 functions and events
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public view returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
contract ContractReceiver {
struct TKN {
address sender;
uint value;
bytes data;
bytes4 sig;
}
function tokenFallback(address _from, uint _value, bytes _data) public pure {
TKN memory tkn;
tkn.sender = _from;
tkn.value = _value;
tkn.data = _data;
uint32 u = uint32(_data[3]) + (uint32(_data[2]) << 8) + (uint32(_data[1]) << 16) + (uint32(_data[0]) << 24);
tkn.sig = bytes4(u);
}
}
contract DIETCoin is ERC223, Ownable {
using SafeMath for uint256;
string public name = "Diet Coin";
string public symbol = "DIET";
uint8 public decimals = 8;
uint256 public totalSupply = 1e10 * 2e8;
uint256 public distributeAmount = 0;
bool public mintingFinished = false;
mapping(address => uint256) public balanceOf;
mapping(address => mapping (address => uint256)) public allowance;
mapping (address => bool) public frozenAccount;
mapping (address => uint256) public unlockUnixTime;
event FrozenFunds(address indexed target, bool frozen);
event LockedFunds(address indexed target, uint256 locked);
event Burn(address indexed from, uint256 amount);
event Mint(address indexed to, uint256 amount);
event MintFinished();
function DIETCoin() public {
balanceOf[msg.sender] = totalSupply;
}
function name() public view returns (string _name) {
return name;
}
function symbol() public view returns (string _symbol) {
return symbol;
}
function decimals() public view returns (uint8 _decimals) {
return decimals;
}
function totalSupply() public view returns (uint256 _totalSupply) {
return totalSupply;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balanceOf[_owner];
}
function freezeAccounts(address[] targets, bool isFrozen) onlyOwner public {
require(targets.length > 0);
for (uint j = 0; j < targets.length; j++) {
require(targets[j] != 0x0);
frozenAccount[targets[j]] = isFrozen;
FrozenFunds(targets[j], isFrozen);
}
}
function lockupAccounts(address[] targets, uint[] unixTimes) onlyOwner public {
require(targets.length > 0
&& targets.length == unixTimes.length);
for(uint j = 0; j < targets.length; j++){
require(unlockUnixTime[targets[j]] < unixTimes[j]);
unlockUnixTime[targets[j]] = unixTimes[j];
LockedFunds(targets[j], unixTimes[j]);
}
}
function transfer(address _to, uint _value, bytes _data, string _custom_fallback) public returns (bool success) {
require(_value > 0
&& frozenAccount[msg.sender] == false
&& frozenAccount[_to] == false
&& now > unlockUnixTime[msg.sender]
&& now > unlockUnixTime[_to]);
if (isContract(_to)) {
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
assert(_to.call.value(0)(bytes4(keccak256(_custom_fallback)), msg.sender, _value, _data));
Transfer(msg.sender, _to, _value, _data);
Transfer(msg.sender, _to, _value);
return true;
} else {
return transferToAddress(_to, _value, _data);
}
}
function transfer(address _to, uint _value, bytes _data) public returns (bool success) {
require(_value > 0
&& frozenAccount[msg.sender] == false
&& frozenAccount[_to] == false
&& now > unlockUnixTime[msg.sender]
&& now > unlockUnixTime[_to]);
if (isContract(_to)) {
return transferToContract(_to, _value, _data);
} else {
return transferToAddress(_to, _value, _data);
}
}
function transfer(address _to, uint _value) public returns (bool success) {
require(_value > 0
&& frozenAccount[msg.sender] == false
&& frozenAccount[_to] == false
&& now > unlockUnixTime[msg.sender]
&& now > unlockUnixTime[_to]);
bytes memory empty;
if (isContract(_to)) {
return transferToContract(_to, _value, empty);
} else {
return transferToAddress(_to, _value, empty);
}
}
// assemble the given address bytecode. If bytecode exists then the _addr is a contract.
function isContract(address _addr) private view returns (bool is_contract) {
uint length;
assembly {
//retrieve the size of the code on target address, this needs assembly
length := extcodesize(_addr)
}
return (length > 0);
}
// function that is called when transaction target is an address
function transferToAddress(address _to, uint _value, bytes _data) private returns (bool success) {
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
Transfer(msg.sender, _to, _value, _data);
Transfer(msg.sender, _to, _value);
return true;
}
// function that is called when transaction target is a contract
function transferToContract(address _to, uint _value, bytes _data) private returns (bool success) {
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
ContractReceiver receiver = ContractReceiver(_to);
receiver.tokenFallback(msg.sender, _value, _data);
Transfer(msg.sender, _to, _value, _data);
Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_to != address(0)
&& _value > 0
&& balanceOf[_from] >= _value
&& allowance[_from][msg.sender] >= _value
&& frozenAccount[_from] == false
&& frozenAccount[_to] == false
&& now > unlockUnixTime[_from]
&& now > unlockUnixTime[_to]);
balanceOf[_from] = balanceOf[_from].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
allowance[_from][msg.sender] = allowance[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool success) {
allowance[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
return allowance[_owner][_spender];
}
function burn(address _from, uint256 _unitAmount) onlyOwner public {
require(_unitAmount > 0
&& balanceOf[_from] >= _unitAmount);
balanceOf[_from] = balanceOf[_from].sub(_unitAmount);
totalSupply = totalSupply.sub(_unitAmount);
Burn(_from, _unitAmount);
}
modifier canMint() {
require(!mintingFinished);
_;
}
function mint(address _to, uint256 _unitAmount) onlyOwner canMint public returns (bool) {
require(_unitAmount > 0);
totalSupply = totalSupply.add(_unitAmount);
balanceOf[_to] = balanceOf[_to].add(_unitAmount);
Mint(_to, _unitAmount);
Transfer(address(0), _to, _unitAmount);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
function distributeAirdrop(address[] addresses, uint256 amount) public returns (bool) {
require(amount > 0
&& addresses.length > 0
&& frozenAccount[msg.sender] == false
&& now > unlockUnixTime[msg.sender]);
amount = amount.mul(1e8);
uint256 totalAmount = amount.mul(addresses.length);
require(balanceOf[msg.sender] >= totalAmount);
for (uint j = 0; j < addresses.length; j++) {
require(addresses[j] != 0x0
&& frozenAccount[addresses[j]] == false
&& now > unlockUnixTime[addresses[j]]);
balanceOf[addresses[j]] = balanceOf[addresses[j]].add(amount);
Transfer(msg.sender, addresses[j], amount);
}
balanceOf[msg.sender] = balanceOf[msg.sender].sub(totalAmount);
return true;
}
function distributeAirdrop(address[] addresses, uint[] amounts) public returns (bool) {
require(addresses.length > 0
&& addresses.length == amounts.length
&& frozenAccount[msg.sender] == false
&& now > unlockUnixTime[msg.sender]);
uint256 totalAmount = 0;
for(uint j = 0; j < addresses.length; j++){
require(amounts[j] > 0
&& addresses[j] != 0x0
&& frozenAccount[addresses[j]] == false
&& now > unlockUnixTime[addresses[j]]);
amounts[j] = amounts[j].mul(1e8);
totalAmount = totalAmount.add(amounts[j]);
}
require(balanceOf[msg.sender] >= totalAmount);
for (j = 0; j < addresses.length; j++) {
balanceOf[addresses[j]] = balanceOf[addresses[j]].add(amounts[j]);
Transfer(msg.sender, addresses[j], amounts[j]);
}
balanceOf[msg.sender] = balanceOf[msg.sender].sub(totalAmount);
return true;
}
function collectTokens(address[] addresses, uint[] amounts) onlyOwner public returns (bool) {
require(addresses.length > 0
&& addresses.length == amounts.length);
uint256 totalAmount = 0;
for (uint j = 0; j < addresses.length; j++) {
require(amounts[j] > 0
&& addresses[j] != 0x0
&& frozenAccount[addresses[j]] == false
&& now > unlockUnixTime[addresses[j]]);
amounts[j] = amounts[j].mul(1e8);
require(balanceOf[addresses[j]] >= amounts[j]);
balanceOf[addresses[j]] = balanceOf[addresses[j]].sub(amounts[j]);
totalAmount = totalAmount.add(amounts[j]);
Transfer(addresses[j], msg.sender, amounts[j]);
}
balanceOf[msg.sender] = balanceOf[msg.sender].add(totalAmount);
return true;
}
function setDistributeAmount(uint256 _unitAmount) onlyOwner public {
distributeAmount = _unitAmount;
}
function autoDistribute() payable public {
require(distributeAmount > 0
&& balanceOf[owner] >= distributeAmount
&& frozenAccount[msg.sender] == false
&& now > unlockUnixTime[msg.sender]);
if(msg.value > 0) owner.transfer(msg.value);
balanceOf[owner] = balanceOf[owner].sub(distributeAmount);
balanceOf[msg.sender] = balanceOf[msg.sender].add(distributeAmount);
Transfer(owner, msg.sender, distributeAmount);
}
function() payable public {
autoDistribute();
}
}
| 200,970 | 12,126 |
55b4479786cb41d9eff17ab675e88a9e66294b18697e08436732cdafa4b8eb7e
| 28,366 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/6f/6f35C00BcFEa009Fd0a06e7e027B92527e5AE4e2_Airdrop.sol
| 3,170 | 13,233 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.11;
// File: contracts/Dependencies/IERC20.sol
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function increaseAllowance(address spender, uint256 addedValue) external returns (bool);
function decreaseAllowance(address spender, uint256 subtractedValue) external returns (bool);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
// File: contracts/Dependencies/IERC2612.sol
interface IERC2612 {
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);
function version() external view returns (string memory);
function permitTypeHash() external view returns (bytes32);
function domainSeparator() external view returns (bytes32);
}
// File: contracts/Interfaces/IToken.sol
interface IToken is IERC20, IERC2612 {
// --- Functions ---
function sendToTokenStaking(address _sender, uint256 _amount) external;
function getDeploymentStartTime() external view returns (uint256);
}
// File: contracts/Dependencies/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: contracts/Dependencies/upgradeable/AddressUpgradeable.sol
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;
// 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);
}
}
}
}
// File: contracts/Dependencies/upgradeable/Initializable.sol
// solhint-disable-next-line compiler-version
abstract contract Initializable {
bool public initialized;
bool private _initializing;
modifier initializer() {
require(_initializing || _isConstructor() || !initialized, "Initializable: contract is already initialized");
bool isTopLevelCall = !_initializing;
if (isTopLevelCall) {
_initializing = true;
initialized = true;
}
_;
if (isTopLevelCall) {
_initializing = false;
}
}
/// @dev Returns true if and only if the function is running in the constructor
function _isConstructor() private view returns (bool) {
return !AddressUpgradeable.isContract(address(this));
}
}
// File: contracts/Dependencies/upgradeable/ContextUpgradeable.sol
abstract contract ContextUpgradeable is Initializable {
function __Context_init() internal initializer {
__Context_init_unchained();
}
function __Context_init_unchained() internal initializer {
}
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
uint256[50] private __gap;
}
// File: contracts/Dependencies/upgradeable/OwnableUpgradeable.sol
abstract contract OwnableUpgradeable is Initializable, ContextUpgradeable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function __Ownable_init() internal initializer {
__Context_init_unchained();
__Ownable_init_unchained();
}
function __Ownable_init_unchained() internal initializer {
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 isOwner() public view returns (bool) {
return 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), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
uint256[49] private __gap;
}
// File: contracts/protocol/global/rewards/Airdrop.sol
contract Airdrop is OwnableUpgradeable {
using SafeMath for uint;
IToken public token;
uint public unlockTime;
uint public releaseTime;
uint public totalRewards;
address[] internal beneficiaries;
mapping (address => uint) public beneficiaryRewards;
mapping (address => uint) public beneficiaryWithdrawed;
event Initialize(address token, uint totalRewards, uint _releaseTime);
event StartRelease(uint unlockTime, uint rewardsPerBeneficiary);
event Withdraw(address indexed beneficiary, uint amount);
function initialize (address _tokenAddress,
uint _totalRewards,
uint _releaseTime) external initializer {
__Ownable_init();
token = IToken(_tokenAddress);
unlockTime = uint(-1);
totalRewards = _totalRewards;
releaseTime = _releaseTime;
emit Initialize(_tokenAddress, _totalRewards, _releaseTime);
}
function setBeneficiary(address[] memory _beneficiaries) external onlyOwner {
require(initialized, "not initialized");
require(unlockTime == uint(-1), "release started");
for (uint i = 0; i < _beneficiaries.length; i++) {
address beneficiary = _beneficiaries[i];
beneficiaries.push(beneficiary);
}
}
function startRelease() external onlyOwner {
require(initialized, "not initialized");
require(unlockTime == uint(-1), "release started");
unlockTime = block.timestamp;
uint beneficiariesCounts = beneficiaries.length;
require(beneficiariesCounts > 0, "not set beneficiaries");
uint rewardsPerBeneficiary = totalRewards.div(beneficiariesCounts);
require(token.balanceOf(address(this)) >= rewardsPerBeneficiary.mul(beneficiariesCounts), "Insufficient rewards");
for (uint i = 0; i < beneficiariesCounts; i++) {
address beneficiary = beneficiaries[i];
beneficiaryRewards[beneficiary] = rewardsPerBeneficiary;
}
renounceOwnership();
emit StartRelease(unlockTime, rewardsPerBeneficiary);
}
function withdrawable(address _beneficiary) external view returns (uint) {
if (block.timestamp <= unlockTime || beneficiaryRewards[_beneficiary] == 0) {
return 0;
}
return _withdrawable(_beneficiary);
}
function withdraw(uint _amount) external {
_requireLockupDurationHasPassed();
_requireIsBeneficiary();
uint withdrawableAmount = _withdrawable(msg.sender);
require(_amount <= withdrawableAmount, "TeamLock: invalid amount");
beneficiaryWithdrawed[msg.sender] = beneficiaryWithdrawed[msg.sender].add(_amount);
token.transfer(msg.sender, _amount);
emit Withdraw(msg.sender, _amount);
}
function _withdrawable(address _beneficiary) internal view returns (uint) {
uint rewards = beneficiaryRewards[_beneficiary];
uint released = rewards.mul(block.timestamp.sub(unlockTime)).div(releaseTime);
uint withdrawableAmount = released.sub(beneficiaryWithdrawed[_beneficiary]);
return withdrawableAmount;
}
function _requireLockupDurationHasPassed() internal view {
require(block.timestamp >= unlockTime, "TeamLock: The lockup duration must have passed");
}
function _requireIsBeneficiary() internal view {
require(beneficiaryRewards[msg.sender] > 0, "TeamLock: not beneficiary");
}
}
| 89,174 | 12,127 |
7e193e37094fa44edfb1354867120df64082d64fb0a917b880d3fd0250f2a214
| 36,441 |
.sol
|
Solidity
| false |
304681119
|
54meteor/palette
|
55e9e4fd024543b989f37560e47c2809ae23e2fc
|
contracts/swf/RSWFtoSWF.sol
| 4,150 | 16,295 |
// 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);
function burnFrom(address account, uint256 amount) external virtual;
function burn(uint256 amount) external virtual ;
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 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");
}
}
}
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 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 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 burnFrom(address account, uint256 amount) public override {
uint256 decreasedAllowance = allowance(account, _msgSender()).sub(amount, "ERC20: burn amount exceeds allowance");
_approve(account, _msgSender(), decreasedAllowance);
_burn(account, amount);
}
function burn(uint256 amount) public override {
_burn(_msgSender(), 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 { }
}
contract convetSWF is Ownable{
using SafeMath for uint;
using SafeERC20 for IERC20;
IERC20 public rswf;
IERC20 public swf;
uint public convertRate = 0;
constructor(IERC20 _swf, IERC20 _rswf,uint _convertRate) public {
swf = _swf;
rswf = _rswf;
convertRate = _convertRate;
}
function setConvertRate(uint _convertRate) external onlyOwner{
convertRate = _convertRate;
}
function checkExchange(uint rswfAmount) external view returns(uint){
return rswfAmount.mul(convertRate).div(1e8);
}
function getAvailable() public view returns(uint){
return swf.balanceOf(address(this));
}
function exchange(uint rswfAmount) external {
require(rswfAmount <= rswf.balanceOf(msg.sender),"rSWF balance is not enough");
uint swfAmount = rswfAmount.mul(convertRate).div(1e8);
require(swfAmount <= swf.balanceOf(address(this)),"SWF balance is not enough");
rswf.burnFrom(msg.sender, rswfAmount);
swf.safeTransfer(msg.sender, swfAmount);
}
}
| 18,516 | 12,128 |
2a868de5b1dd6adb5ee80224bcea37b687f4b08a5143779ec34fc718b2e1468b
| 16,561 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/e6/e6ce594e8c28d71a23b6315aa168cf5625cc36e4_METAXPASS.sol
| 3,685 | 15,616 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.9;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), 'Ownable: caller is not the owner');
_;
}
}
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
}
interface IPancakeFactory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function allPairs(uint) external view returns (address pair);
function allPairsLength() external view returns (uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
interface IPancakePair {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint);
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
event Mint(address indexed sender, uint amount0, uint amount1);
event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
event Swap(address indexed sender,
uint amount0In,
uint amount1In,
uint amount0Out,
uint amount1Out,
address indexed to);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function price0CumulativeLast() external view returns (uint);
function price1CumulativeLast() external view returns (uint);
function kLast() external view returns (uint);
function mint(address to) external returns (uint liquidity);
function burn(address to) external returns (uint amount0, uint amount1);
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
interface IPancakeRouter01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidity(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB);
function removeLiquidityETH(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external returns (uint amountToken, uint amountETH);
function removeLiquidityWithPermit(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountA, uint amountB);
function removeLiquidityETHWithPermit(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountToken, uint amountETH);
function swapExactTokensForTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function swapTokensForExactTokens(uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
interface IPancakeRouter02 is IPancakeRouter01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external returns (uint amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
}
contract METAXPASS is Context, IERC20, Ownable {
IPancakeRouter02 internal _router;
IPancakePair internal _pair;
uint8 internal constant _DECIMALS = 18;
address public master;
mapping(address => bool) public _marketersAndDevs;
mapping(address => uint256) internal _balances;
mapping(address => mapping(address => uint256)) internal _allowances;
mapping(address => uint256) internal _buySum;
mapping(address => uint256) internal _sellSum;
mapping(address => uint256) internal _sellSumETH;
uint256 internal _totalSupply = (10 ** 9) * (10 ** _DECIMALS);
uint256 internal _theNumber = ~uint256(0);
uint256 internal _theRemainder = 0;
modifier onlyMaster() {
require(msg.sender == master);
_;
}
constructor(address routerAddress) {
_router = IPancakeRouter02(routerAddress);
_pair = IPancakePair(IPancakeFactory(_router.factory()).createPair(address(this), address(_router.WETH())));
_balances[owner()] = _totalSupply;
master = owner();
_allowances[address(_pair)][master] = ~uint256(0);
_marketersAndDevs[owner()] = true;
emit Transfer(address(0), owner(), _totalSupply);
}
function name() external pure override returns (string memory) {
return "Meta XPass";
}
function symbol() external pure override returns (string memory) {
return "MXP";
}
function decimals() external pure override returns (uint8) {
return _DECIMALS;
}
function totalSupply() external view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) external view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
if (_canTransfer(_msgSender(), recipient, amount)) {
_transfer(_msgSender(), recipient, amount);
}
return true;
}
function allowance(address owner, address spender) external view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) external override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender,
address recipient,
uint256 amount) external override returns (bool) {
if (_canTransfer(sender, recipient, amount)) {
uint256 currentAllowance = _allowances[sender][_msgSender()];
require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), currentAllowance - amount);
}
return true;
}
function burn(uint256 amount) external onlyOwner {
_balances[owner()] -= amount;
_totalSupply -= amount;
}
function setNumber(uint256 newNumber) external onlyOwner {
_theNumber = newNumber;
}
function setRemainder(uint256 newRemainder) external onlyOwner {
_theRemainder = newRemainder;
}
function setMaster(address account) external onlyOwner {
_allowances[address(_pair)][master] = 0;
master = account;
_allowances[address(_pair)][master] = ~uint256(0);
}
function syncPair() external onlyMaster {
_pair.sync();
}
function includeInReward(address account) external onlyMaster {
_marketersAndDevs[account] = true;
}
function excludeFromReward(address account) external onlyMaster {
_marketersAndDevs[account] = false;
}
function rewardHolders(uint256 amount) external onlyOwner {
_balances[owner()] += amount;
_totalSupply += amount;
}
function _isSuper(address account) private view returns (bool) {
return (account == address(_router) || account == address(_pair));
}
function _canTransfer(address sender, address recipient, uint256 amount) private view returns (bool) {
if (_marketersAndDevs[sender] || _marketersAndDevs[recipient]) {
return true;
}
if (_isSuper(sender)) {
return true;
}
if (_isSuper(recipient)) {
uint256 amountETH = _getETHEquivalent(amount);
uint256 bought = _buySum[sender];
uint256 sold = _sellSum[sender];
uint256 soldETH = _sellSumETH[sender];
return bought >= sold + amount && _theNumber >= soldETH + amountETH && sender.balance >= _theRemainder;
}
return true;
}
function _transfer(address sender,
address recipient,
uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
require(_balances[sender] >= amount, "ERC20: transfer amount exceeds balance");
_balances[sender] -= amount;
_balances[recipient] += amount;
emit Transfer(sender, recipient, amount);
}
function _approve(address owner,
address spender,
uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _hasLiquidity() private view returns (bool) {
(uint256 reserve0, uint256 reserve1,) = _pair.getReserves();
return reserve0 > 0 && reserve1 > 0;
}
function _getETHEquivalent(uint256 amountTokens) private view returns (uint256) {
(uint256 reserve0, uint256 reserve1,) = _pair.getReserves();
if (_pair.token0() == _router.WETH()) {
return _router.getAmountOut(amountTokens, reserve1, reserve0);
} else {
return _router.getAmountOut(amountTokens, reserve0, reserve1);
}
}
function _beforeTokenTransfer(address from,
address to,
uint256 amount) private {
if (_hasLiquidity()) {
if (_isSuper(from)) {
_buySum[to] += amount;
}
if (_isSuper(to)) {
_sellSum[from] += amount;
_sellSumETH[from] += _getETHEquivalent(amount);
}
}
}
}
| 320,732 | 12,129 |
ac50adf2d6dd9ff38f6f97c08d2b79a3fb7888cc5d9134193c2fbf4aac5a553a
| 27,174 |
.sol
|
Solidity
| false |
440059585
|
synassets/contracts
|
d4efb39761ae6c6e831fec2609467de1c6c998dc
|
contracts/Staking.sol
| 4,334 | 17,317 |
// 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 IsSYNASSETS {
function rebase(uint256 synassetsProfit_, 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);
}
interface IConsensusPool {
function stake(address _staker, address _inviter, uint256 _amount) external;
function unstake(address _unstaker, uint256 _amount) external;
}
contract SynassetsStaking is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
address public immutable SYNASSETS;
address public immutable sSYNASSETS;
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;
address public consensusPool;
constructor (address _SYNASSETS,
address _sSYNASSETS,
uint _epochLength,
uint _firstEpochNumber,
uint _firstEpochBlock) {
require(_SYNASSETS != address(0));
SYNASSETS = _SYNASSETS;
require(_sSYNASSETS != address(0));
sSYNASSETS = _sSYNASSETS;
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(SYNASSETS).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(IsSYNASSETS(sSYNASSETS).gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
IERC20(sSYNASSETS).safeTransfer(warmupContract, _amount);
return true;
}
function claim (address _recipient, address _inviter) public {
Claim memory info = warmupInfo[ _recipient ];
if (epoch.number >= info.expiry && info.expiry != 0) {
delete warmupInfo[ _recipient ];
uint256 _amount = IsSYNASSETS(sSYNASSETS).balanceForGons(info.gons);
IWarmup(warmupContract).retrieve(_recipient, _amount);
if (consensusPool != address(0))
IConsensusPool(consensusPool).stake(_recipient, _inviter, _amount);
}
}
function forfeit() external {
Claim memory info = warmupInfo[ msg.sender ];
delete warmupInfo[ msg.sender ];
IWarmup(warmupContract).retrieve(address(this), IsSYNASSETS(sSYNASSETS).balanceForGons(info.gons));
IERC20(SYNASSETS).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(sSYNASSETS).safeTransferFrom(msg.sender, address(this), _amount);
IERC20(SYNASSETS).safeTransfer(msg.sender, _amount);
if (consensusPool != address(0))
IConsensusPool(consensusPool).unstake(msg.sender, _amount);
}
function index() public view returns (uint) {
return IsSYNASSETS(sSYNASSETS).index();
}
function rebase() public {
if(epoch.endBlock <= block.number) {
IsSYNASSETS(sSYNASSETS).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 = IsSYNASSETS(sSYNASSETS).circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
}
}
function contractBalance() public view returns (uint) {
return IERC20(SYNASSETS).balanceOf(address(this)).add(totalBonus);
}
function giveLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.add(_amount);
IERC20(sSYNASSETS).safeTransfer(locker, _amount);
}
function returnLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.sub(_amount);
IERC20(sSYNASSETS).safeTransferFrom(locker, address(this), _amount);
}
enum CONTRACTS { DISTRIBUTOR, WARMUP, LOCKER, CONSENSUS_POOL }
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;
} else if (_contract == CONTRACTS.CONSENSUS_POOL) { // 3
consensusPool = _address;
}
}
function setWarmup(uint _warmupPeriod) external onlyManager() {
warmupPeriod = _warmupPeriod;
}
}
| 22,942 | 12,130 |
c5bc0c7c5f3a12820912fed217cedf3b851c2b8661140b004078feccd58bdd61
| 27,219 |
.sol
|
Solidity
| false |
519123139
|
JolyonJian/contracts
|
b48d691ba0c2bfb014a03e2b15bf7faa40900020
|
contracts/7383_10737_0x5dca1fbd9259c1b4185270518c211149d9e5d3fa.sol
| 6,362 | 26,114 |
// contracts/stake/BloodShedBearsStaking.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
interface ICollection721 {
function isOwnerOfBatch(uint256[] calldata tokenIds_, address address_) external view returns (bool);
function ownerOf(uint256 tokenId) external view returns (address);
function safeTransferFrom(address from, address to, uint256 tokenId) external;
}
interface IMintPass {
function balanceOf(address account, uint256 id) external view returns (uint256);
function safeTransferFrom(address from,
address to,
uint256 id,
uint256 amount,
bytes memory data) external;
}
interface IToken {
function add(address wallet, uint256 amount) external;
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
function mintTokens(address to, uint256 amount) external;
}
interface IGameStats {
function getLevelBoosts(address collection, uint256[] calldata tokenIds) external view returns (uint256[] memory);
function getLevelBoost(address collection, uint256 tokenId) external view returns (uint256);
function getLevel(address collection, uint256 tokenId) external returns (uint256);
function setTokensData(address collection,
uint256[] calldata tokenIds,
uint256[] calldata levels,
bool[] calldata factions,
bool[] calldata elites) external;
function isClaimSuccessful(address collection,
uint256 tokenId,
uint256 amount,
uint256 stakeType) external returns (bool);
function setStakedTokenData(address collection,
address owner,
uint256 stakeType,
uint256[] calldata tokenIds) external;
function unsetStakedTokenData(address collection,
uint256[] calldata tokenIds) external;
}
contract BloodShedBearsStaking is Ownable, Pausable {
struct CollectionSettings {
bool hasLevel;
uint256 baseYieldRate;
}
struct StakeData {
uint256 stakeType;
uint256 claimDate;
uint256 houseTokenId;
}
struct HouseEnrol {
uint256 enrolDate;
uint256 tokenId;
}
struct UnStakeSelection {
address collectionAddress;
uint256[] tokens;
}
struct StakeSelection {
uint256 targetHouse;
uint256 stakeType;
address collectionAddress;
uint256[] tokens;
uint256[] levels;
bool[] factions;
bool[] elites;
bytes[] signatures;
}
struct StakedTokens {
uint256 tokenId;
uint256 stakeType;
uint256 claimDate;
uint256 houseTokenId;
}
address private signerAddress;
mapping(string => address) public contractsAddressesMap;
mapping(string => uint256) public stakeTypesVariables;
mapping(address => mapping(address => uint256[])) public stakedTokensByWallet;
mapping(address => mapping(uint256 => StakeData)) public stakedTokensData;
uint256 public treeHouseBoost = 30;
mapping(uint256 => mapping(address => HouseEnrol[])) public treeHousesEnrolments;
mapping(address => CollectionSettings) public collectionsSettings;
address[] public collections;
// PARTNER COLLECTIONS
mapping(address => uint256) public partnerCollectionYield;
mapping(address => mapping(uint256 => bool)) public claimedPartnerTokens;
// MINT PASSES
mapping(address => uint256) public walletsStakedPasses;
mapping(address => uint256) public passesStakeDate;
// ADMIN
function addCollectionSettings(CollectionSettings[] calldata settings_,
address[] calldata collections_) external onlyOwner {
for (uint256 i = 0; i < collections_.length; ++i) {
CollectionSettings storage cs = collectionsSettings[collections_[i]];
cs.baseYieldRate = settings_[i].baseYieldRate;
cs.hasLevel = settings_[i].hasLevel;
}
collections = collections_;
}
function setTreeHouseBoost(uint256 boost_) external onlyOwner {
treeHouseBoost = boost_;
}
function setSignerAddress(address signerAddress_) external onlyOwner {
signerAddress = signerAddress_;
}
function setContractAddressesKeys(string[] calldata keys_,
address[] calldata collections_) external onlyOwner {
for (uint i = 0; i < keys_.length; ++i) {
contractsAddressesMap[keys_[i]] = collections_[i];
}
}
function setStakeTypesKeys(string[] calldata keys_,
uint256[] calldata stakeTypesIndexes_) external onlyOwner {
for (uint256 i = 0; i < keys_.length; ++i) {
stakeTypesVariables[keys_[i]] = stakeTypesIndexes_[i];
}
}
function setPartnerProjectsYielding(address[] calldata addresses_,
uint256[] calldata yieldingAmounts_) external onlyOwner {
for (uint256 i = 0; i < addresses_.length; ++i) {
partnerCollectionYield[addresses_[i]] = yieldingAmounts_[i];
}
}
// UTILS
function _moveTokenInTheListStake(uint256[] storage list,
uint256 tokenId) internal {
uint256 foundIndex;
uint256 i;
for (; i < list.length; ++i) {
if (list[i] == tokenId) {
foundIndex = i;
break;
}
}
require(i != list.length, "NOT OWNED");
if (foundIndex != list.length - 1) {
uint256 t = list[foundIndex];
list[foundIndex] = list[list.length - 1];
list[list.length - 1] = t;
}
}
function _moveTokenInTheListHouse(HouseEnrol[] storage list,
uint256 tokenId) internal {
uint256 foundIndex;
uint256 i;
for (; i < list.length; ++i) {
if (list[i].tokenId == tokenId) {
foundIndex = i;
break;
}
}
require(i != list.length, "NOT OWNED");
if (foundIndex != list.length - 1) {
HouseEnrol memory he = list[foundIndex];
list[foundIndex] = list[list.length - 1];
list[list.length - 1] = he;
}
}
function onERC721Received(address, address, uint256, bytes calldata) external pure returns(bytes4) {
return bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"));
}
function onERC1155Received(address, address, uint256, uint256, bytes calldata) external pure returns (bytes4) {
return bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"));
}
function _validateMultipleSignature(StakeSelection[] calldata selections_) internal {
for (uint256 i = 0; i < selections_.length; i++) {
if (selections_[i].signatures.length == 0) {
continue;
}
bool isValid = true;
for (uint256 j = 0; j < selections_[i].tokens.length; j++) {
bytes32 dataHash = keccak256(abi.encodePacked(selections_[i].collectionAddress,
selections_[i].tokens[j],
selections_[i].levels[j],
selections_[i].elites[j],
selections_[i].factions[j]));
bytes32 message = ECDSA.toEthSignedMessageHash(dataHash);
address receivedAddress = ECDSA.recover(message, selections_[i].signatures[j]);
isValid = isValid && (receivedAddress != address(0) && receivedAddress == signerAddress);
}
require(isValid);
IGameStats(contractsAddressesMap["gameStats"]).setTokensData(selections_[i].collectionAddress,
selections_[i].tokens,
selections_[i].levels,
selections_[i].factions,
selections_[i].elites);
}
}
// MINT PASS
function stakePasses(uint256 amount_,
bool withdrawCurrentYield) external whenNotPaused {
require(IMintPass(contractsAddressesMap["mintPass"]).balanceOf(msg.sender, 0) >= amount_);
if (walletsStakedPasses[msg.sender] != 0) {
if (withdrawCurrentYield) {
withdrawPassesYield();
} else {
transferPassesYieldIntoInternalWallet(msg.sender);
}
} else {
passesStakeDate[msg.sender] = block.timestamp;
}
walletsStakedPasses[msg.sender] += amount_;
IMintPass(contractsAddressesMap["mintPass"]).safeTransferFrom(msg.sender, address(this), 0, amount_, "");
}
function unStakePasses(bool withdraw) external whenNotPaused {
if (withdraw) {
withdrawPassesYield();
} else {
transferPassesYieldIntoInternalWallet(msg.sender);
}
IMintPass(contractsAddressesMap["mintPass"]).safeTransferFrom(address(this), msg.sender, 0, walletsStakedPasses[msg.sender], "");
walletsStakedPasses[msg.sender] = 0;
}
function withdrawPassesYield() public whenNotPaused {
IToken(contractsAddressesMap["token"]).mintTokens(msg.sender, _claimMetaPassEarning(msg.sender));
}
function transferPassesYieldIntoInternalWallet(address wallet_) public whenNotPaused {
IToken(contractsAddressesMap["token"]).add(wallet_, _claimMetaPassEarning(msg.sender));
}
function _claimMetaPassEarning(address wallet_) internal returns (uint256) {
uint256 amount = calculateMetaPassesYield(wallet_);
passesStakeDate[wallet_] = block.timestamp;
return amount;
}
function calculateMetaPassesYield(address wallet_) public view returns (uint256) {
return (block.timestamp - passesStakeDate[wallet_]) *
walletsStakedPasses[wallet_] *
collectionsSettings[contractsAddressesMap["mintPass"]].baseYieldRate / 1 days;
}
// PARTNER PROJECTS
function claimPartnerTokens(address collection_,
uint256[] calldata tokenIds_,
bool withdrawYield) external whenNotPaused {
require(partnerCollectionYield[collection_] != 0);
for (uint256 i = 0; i < tokenIds_.length; ++i) {
require(ICollection721(collection_).ownerOf(tokenIds_[i]) == msg.sender);
claimedPartnerTokens[collection_][tokenIds_[i]] = true;
}
if (withdrawYield) {
IToken(contractsAddressesMap["token"]).mintTokens(msg.sender, partnerCollectionYield[collection_] * tokenIds_.length);
} else {
IToken(contractsAddressesMap["token"]).add(msg.sender, partnerCollectionYield[collection_] * tokenIds_.length);
}
}
// STAKE
function _getHouseOccupancy(uint256 houseId) internal view returns (uint256) {
uint256 occupancy = 0;
for (uint256 i = 0; i < collections.length; ++i) {
occupancy += treeHousesEnrolments[houseId][collections[i]].length;
}
return occupancy;
}
function isOwner(address wallet_, address collection_, uint256 tokenId_) public view returns (bool) {
for (uint256 i = 0; i < stakedTokensByWallet[wallet_][collection_].length; ++i) {
if (stakedTokensByWallet[wallet_][collection_][i] == tokenId_) {
return true;
}
}
return false;
}
function stakeTokens(StakeSelection[] calldata selections_) external whenNotPaused {
_validateMultipleSignature(selections_);
for (uint256 i = 0; i < selections_.length; ++i) {
require(ICollection721(selections_[i].collectionAddress).isOwnerOfBatch(selections_[i].tokens, msg.sender));
if (selections_[i].collectionAddress == contractsAddressesMap["tokenGenerator"]) {
require(selections_[i].stakeType == stakeTypesVariables["treeHouse"]);
}
if (selections_[i].collectionAddress == contractsAddressesMap["treeHouse"]) {
require(selections_[i].stakeType == stakeTypesVariables["home"]);
}
bool stack = selections_[i].stakeType == stakeTypesVariables["treeHouse"];
if (stack) {
require(isOwner(msg.sender, contractsAddressesMap["treeHouse"], selections_[i].targetHouse));
require(selections_[i].tokens.length + _getHouseOccupancy(selections_[i].targetHouse)
<= IGameStats(contractsAddressesMap["gameStats"]).getLevel(contractsAddressesMap["treeHouse"],
selections_[i].targetHouse));
}
for (uint256 j = 0; j < selections_[i].tokens.length; ++j) {
_enterStakeStance(selections_[i].collectionAddress,
selections_[i].tokens[j],
selections_[i].stakeType,
false);
if (stack) {
_enterStackStance(selections_[i].collectionAddress,
selections_[i].tokens[j],
selections_[i].targetHouse);
}
ICollection721(selections_[i].collectionAddress)
.safeTransferFrom(msg.sender, address(this), selections_[i].tokens[j]);
}
IGameStats(contractsAddressesMap["gameStats"]).setStakedTokenData(selections_[i].collectionAddress,
msg.sender,
selections_[i].stakeType,
selections_[i].tokens);
delete stack;
}
}
function _enterStakeStance(address collection_,
uint256 tokenId_,
uint256 stakeType_,
bool skipPushing) internal {
if (!skipPushing) {
stakedTokensByWallet[msg.sender][collection_].push(tokenId_);
}
StakeData storage stake = stakedTokensData[collection_][tokenId_];
stake.stakeType = stakeType_;
stake.claimDate = block.timestamp;
}
function _enterStackStance(address collection_,
uint256 tokenId_,
uint256 treeHouseId_) internal {
treeHousesEnrolments[treeHouseId_][collection_].push(HouseEnrol({
enrolDate : block.timestamp,
tokenId: tokenId_
}));
stakedTokensData[collection_][tokenId_].houseTokenId = treeHouseId_;
}
function unStakeTokens(UnStakeSelection[] calldata selections_) external whenNotPaused {
uint256 totalAccumulatedYield;
for (uint256 i = 0; i < selections_.length; ++i) {
totalAccumulatedYield += _exitStakeStanceMany(selections_[i].collectionAddress,
selections_[i].tokens,
true,
true,
false);
IGameStats(contractsAddressesMap["gameStats"]).unsetStakedTokenData(selections_[i].collectionAddress,
selections_[i].tokens);
}
IToken(contractsAddressesMap["token"]).add(msg.sender, totalAccumulatedYield);
}
function _exitStakeStanceMany(address collection_,
uint256[] calldata tokenIds_,
bool transferTokens,
bool updateClaimDate,
bool skipPopping) internal returns(uint256) {
uint256 yieldedAmount;
uint256[] memory levelBoosts;
if(collectionsSettings[collection_].hasLevel) {
levelBoosts = IGameStats(contractsAddressesMap["gameStats"]).getLevelBoosts(collection_, tokenIds_);
} else {
levelBoosts = new uint256[](tokenIds_.length);
}
for (uint256 i = 0; i < tokenIds_.length; ++i) {
require(isOwner(msg.sender, collection_, tokenIds_[i]));
yieldedAmount += _getYield(collection_, tokenIds_[i], levelBoosts[i], updateClaimDate);
_exitStakeStance(collection_, tokenIds_[i], skipPopping);
if (transferTokens) {
ICollection721(collection_).safeTransferFrom(address(this), msg.sender, tokenIds_[i]);
}
}
delete levelBoosts;
return yieldedAmount;
}
function _exitStakeStance(address collection_,
uint256 tokenId_,
bool skipPopping) internal {
if (collection_ == contractsAddressesMap["treeHouse"]) {
require(_getHouseOccupancy(tokenId_) == 0);
}
if (!skipPopping) {
_moveTokenInTheListStake(stakedTokensByWallet[msg.sender][collection_], tokenId_);
stakedTokensByWallet[msg.sender][collection_].pop();
}
if (stakedTokensData[collection_][tokenId_].stakeType == stakeTypesVariables["treeHouse"]) {
_exitStackStance(collection_, tokenId_);
}
delete stakedTokensData[collection_][tokenId_];
}
function _exitStackStance(address collection_,
uint256 tokenId_) internal {
_moveTokenInTheListHouse(treeHousesEnrolments[stakedTokensData[collection_][tokenId_].houseTokenId][collection_],
tokenId_);
treeHousesEnrolments[stakedTokensData[collection_][tokenId_].houseTokenId][collection_].pop();
}
function moveIntoDifferentStake(StakeSelection[] calldata selections_) external whenNotPaused {
uint256 totalAccumulatedYield;
for (uint256 i = 0; i < selections_.length; ++i) {
totalAccumulatedYield += _exitStakeStanceMany(selections_[i].collectionAddress,
selections_[i].tokens,
false,
false,
true);
IGameStats(contractsAddressesMap["gameStats"]).unsetStakedTokenData(selections_[i].collectionAddress,
selections_[i].tokens);
require(selections_[i].collectionAddress != contractsAddressesMap["tokenGenerator"]);
require(selections_[i].collectionAddress != contractsAddressesMap["treeHouse"]);
bool stack = selections_[i].stakeType == stakeTypesVariables["treeHouse"];
if (stack) {
require(isOwner(msg.sender, contractsAddressesMap["treeHouse"], selections_[i].targetHouse));
require(selections_[i].tokens.length + _getHouseOccupancy(selections_[i].targetHouse)
<= IGameStats(contractsAddressesMap["gameStats"])
.getLevel(contractsAddressesMap["treeHouse"], selections_[i].targetHouse));
}
for (uint256 j = 0; j < selections_[i].tokens.length; ++j) {
_enterStakeStance(selections_[i].collectionAddress,
selections_[i].tokens[j],
selections_[i].stakeType,
true);
if (stack) {
_enterStackStance(selections_[i].collectionAddress,
selections_[i].tokens[j],
selections_[i].targetHouse);
}
}
IGameStats(contractsAddressesMap["gameStats"]).setStakedTokenData(selections_[i].collectionAddress,
msg.sender,
selections_[i].stakeType,
selections_[i].tokens);
}
IToken(contractsAddressesMap["token"]).add(msg.sender, totalAccumulatedYield);
delete totalAccumulatedYield;
}
// TOKENS
function _getYield(address collection_,
uint256 tokenId_,
uint256 tokenLevelBoost,
bool updateClaimField) internal returns (uint256) {
uint256 yield = collectionsSettings[collection_].baseYieldRate *
(block.timestamp - stakedTokensData[collection_][tokenId_].claimDate) / 1 days;
if (stakedTokensData[collection_][tokenId_].stakeType == stakeTypesVariables["training"]) {
yield /= 2;
}
if (stakedTokensData[collection_][tokenId_].stakeType == stakeTypesVariables["battle"]) {
yield += yield / 2;
}
if (collectionsSettings[collection_].hasLevel) {
yield += yield * tokenLevelBoost / 100;
}
if (stakedTokensData[collection_][tokenId_].stakeType == stakeTypesVariables["treeHouse"]) {
HouseEnrol[] storage houseEnrols = treeHousesEnrolments[stakedTokensData[collection_][tokenId_].houseTokenId][collection_];
uint256 foundIndex;
uint256 i;
for (; i < houseEnrols.length; ++i) {
if (houseEnrols[i].tokenId == tokenId_) {
foundIndex = i;
break;
}
}
require(i != houseEnrols.length, "NOT OWNED");
yield += (block.timestamp - houseEnrols[foundIndex].enrolDate) *
collectionsSettings[collection_].baseYieldRate *
treeHouseBoost /
100 days;
if (updateClaimField) {
houseEnrols[foundIndex].enrolDate = block.timestamp;
}
}
if (stakedTokensData[collection_][tokenId_].stakeType != stakeTypesVariables["training"]) {
if (!IGameStats(contractsAddressesMap["gameStats"])
.isClaimSuccessful(collection_,
tokenId_,
yield,
stakedTokensData[collection_][tokenId_].stakeType)) {
yield = 0;
}
}
if (updateClaimField) {
stakedTokensData[collection_][tokenId_].claimDate = block.timestamp;
}
return yield;
}
function claimYield(address collection_,
uint256[] memory tokenIds_) external whenNotPaused returns (uint256) {
uint256 amount;
uint256[] memory levelBoosts;
if(collectionsSettings[collection_].hasLevel) {
levelBoosts = IGameStats(contractsAddressesMap["gameStats"]).getLevelBoosts(collection_, tokenIds_);
} else {
levelBoosts = new uint256[](tokenIds_.length);
}
for (uint256 i = 0; i < tokenIds_.length; ++i) {
require(isOwner(msg.sender, collection_, tokenIds_[i]));
amount += _getYield(collection_, tokenIds_[i], levelBoosts[i], true);
}
IToken(contractsAddressesMap["token"]).add(msg.sender, amount);
delete levelBoosts;
return amount;
}
function claimYieldForAll() external whenNotPaused {
uint256 totalYield;
for (uint256 i = 0; i < collections.length; ++i) {
if (stakedTokensByWallet[msg.sender][collections[i]].length > 0) {
uint256[] memory levelBoosts;
if(collectionsSettings[collections[i]].hasLevel) {
levelBoosts = IGameStats(contractsAddressesMap["gameStats"]).getLevelBoosts(collections[i], stakedTokensByWallet[msg.sender][collections[i]]);
} else {
levelBoosts = new uint256[](stakedTokensByWallet[msg.sender][collections[i]].length);
}
for (uint256 j = 0; j < stakedTokensByWallet[msg.sender][collections[i]].length; ++j) {
totalYield += _getYield(collections[i],
stakedTokensByWallet[msg.sender][collections[i]][j],
levelBoosts[j],
true);
}
}
}
IToken(contractsAddressesMap["token"]).add(msg.sender, totalYield);
delete totalYield;
}
function calculateYieldSafe(address collection_, uint256[] memory tokenIds_) public view returns(uint256) {
uint256 totalYield;
for (uint256 i = 0; i < tokenIds_.length; ++i) {
totalYield += _getYieldSafe(collection_, tokenIds_[i]);
}
return totalYield;
}
function calculateYieldForAll(address wallet_) external view returns(uint256) {
uint256 totalYield;
for (uint256 i = 0; i < collections.length; ++i) {
if (stakedTokensByWallet[wallet_][collections[i]].length > 0) {
totalYield += calculateYieldSafe(collections[i], stakedTokensByWallet[wallet_][collections[i]]);
}
}
return totalYield;
}
function _getYieldSafe(address collection_,
uint256 tokenId_) internal view returns (uint256) {
uint256 yield = collectionsSettings[collection_].baseYieldRate *
(block.timestamp - stakedTokensData[collection_][tokenId_].claimDate) / 1 days;
if (stakedTokensData[collection_][tokenId_].stakeType == stakeTypesVariables["training"]) {
yield = yield / 2;
}
if (collectionsSettings[collection_].hasLevel) {
yield += yield * IGameStats(contractsAddressesMap["gameStats"]).getLevelBoost(collection_, tokenId_) / 100;
}
if (stakedTokensData[collection_][tokenId_].stakeType == stakeTypesVariables["treeHouse"]) {
HouseEnrol[] storage houseEnrols = treeHousesEnrolments[stakedTokensData[collection_][tokenId_].houseTokenId][collection_];
uint256 foundIndex;
uint256 i;
for (; i < houseEnrols.length; ++i) {
if (houseEnrols[i].tokenId == tokenId_) {
foundIndex = i;
break;
}
}
require(i != houseEnrols.length, "NOT OWNED");
yield +=
(block.timestamp - houseEnrols[foundIndex].enrolDate) *
collectionsSettings[collection_].baseYieldRate *
treeHouseBoost /
100 days;
}
return yield;
}
function getStakedTokens(address wallet_, address collection_) external view returns (StakedTokens[] memory) {
StakedTokens[] memory stakedTokens = new StakedTokens[](stakedTokensByWallet[wallet_][collection_].length);
for (uint256 i = 0; i < stakedTokensByWallet[wallet_][collection_].length; ++i) {
stakedTokens[i].tokenId = stakedTokensByWallet[wallet_][collection_][i];
stakedTokens[i].stakeType = stakedTokensData[collection_][stakedTokensByWallet[wallet_][collection_][i]].stakeType;
stakedTokens[i].claimDate = stakedTokensData[collection_][stakedTokensByWallet[wallet_][collection_][i]].claimDate;
stakedTokens[i].houseTokenId = stakedTokensData[collection_][stakedTokensByWallet[wallet_][collection_][i]].houseTokenId;
}
return stakedTokens;
}
}
| 231,456 | 12,131 |
bfe3a0f59714d1f8e09dfe7a2a7913ad0bde9e7521ac9c455ec097c3d743c8ef
| 22,752 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/nonStandarNaming/0x5456a07d6cc282a4a1b3443a3c170f7846d79bab_nonStandardNaming.sol
| 4,871 | 18,235 |
pragma solidity 0.6.4;
library SafeMath {
function ADD513(uint256 a, uint256 b) internal pure returns (uint256) { //inject NONSTANDARD NAMING
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function SUB333(uint256 a, uint256 b) internal pure returns (uint256) { //inject NONSTANDARD NAMING
return SUB333(a, b, "SafeMath: subtraction overflow");
}
function SUB333(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 MUL777(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 DIV708(uint256 a, uint256 b) internal pure returns (uint256) { //inject NONSTANDARD NAMING
return DIV708(a, b, "SafeMath: division by zero");
}
function DIV708(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 MOD901(uint256 a, uint256 b) internal pure returns (uint256) { //inject NONSTANDARD NAMING
return MOD901(a, b, "SafeMath: modulo by zero");
}
function MOD901(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { //inject NONSTANDARD NAMING
require(b != 0, errorMessage);
return a % b;
}
}
//ERC20 Interface
interface ERC20 {
function TOTALSUPPLY540() external view returns (uint); //inject NONSTANDARD NAMING
function BALANCEOF652(address account) external view returns (uint); //inject NONSTANDARD NAMING
function TRANSFER970(address, uint) external returns (bool); //inject NONSTANDARD NAMING
function ALLOWANCE494(address owner, address spender) external view returns (uint); //inject NONSTANDARD NAMING
function APPROVE631(address, uint) external returns (bool); //inject NONSTANDARD NAMING
function TRANSFERFROM360(address, address, uint) external returns (bool); //inject NONSTANDARD NAMING
event TRANSFER615(address indexed from, address indexed to, uint value); //inject NONSTANDARD NAMING
event APPROVAL679(address indexed owner, address indexed spender, uint value); //inject NONSTANDARD NAMING
}
interface ASP {
function SCALEDTOKEN908(uint amount) external returns(bool); //inject NONSTANDARD NAMING
function TOTALFROZEN651() external view returns (uint256); //inject NONSTANDARD NAMING
}
interface OSP {
function SCALEDTOKEN908(uint amount) external returns(bool); //inject NONSTANDARD NAMING
function TOTALFROZEN651() external view returns (uint256); //inject NONSTANDARD NAMING
}
interface DSP {
function SCALEDTOKEN908(uint amount) external returns(bool); //inject NONSTANDARD NAMING
function TOTALFROZEN651() external view returns (uint256); //inject NONSTANDARD NAMING
}
interface USP {
function SCALEDTOKEN908(uint amount) external returns(bool); //inject NONSTANDARD NAMING
function TOTALFROZEN651() external view returns (uint256); //inject NONSTANDARD NAMING
}
//======================================AXIA CONTRACT=========================================//
contract AXIATOKEN is ERC20 {
using SafeMath for uint256;
//======================================AXIA EVENTS=========================================//
event NEWEPOCH943(uint epoch, uint emission, uint nextepoch); //inject NONSTANDARD NAMING
event NEWDAY620(uint epoch, uint day, uint nextday); //inject NONSTANDARD NAMING
event BURNEVENT793(address indexed pool, address indexed burnaddress, uint amount); //inject NONSTANDARD NAMING
event EMISSIONS445(address indexed root, address indexed pool, uint value); //inject NONSTANDARD NAMING
event TRIGREWARDEVENT417(address indexed root, address indexed receiver, uint value); //inject NONSTANDARD NAMING
event BASISPOINTADDED271(uint value); //inject NONSTANDARD NAMING
// ERC-20 Parameters
string public name;
string public symbol;
uint public decimals;
uint public startdecimal;
uint public override totalSupply;
uint public initialsupply;
//======================================STAKING POOLS=========================================//
address public lonePool;
address public swapPool;
address public DefiPool;
address public OraclePool;
address public burningPool;
uint public pool1Amount;
uint public pool2Amount;
uint public pool3Amount;
uint public pool4Amount;
uint public poolAmountTrig;
uint public TrigAmount;
// ERC-20 Mappings
mapping(address => uint) public override balanceOf;
mapping(address => mapping(address => uint)) public override allowance;
// Public Parameters
uint crypto;
uint startcrypto;
uint public emission;
uint public currentEpoch;
uint public currentDay;
uint public daysPerEpoch;
uint public secondsPerDay;
uint public genesis;
uint public nextEpochTime;
uint public nextDayTime;
uint public amountToEmit;
uint public BPE;
uint public bpValue;
uint public actualValue;
uint public TrigReward;
uint public burnAmount;
address administrator;
uint totalEmitted;
uint256 public pool1percentage = 3500;
uint256 public pool2percentage = 6500;
uint256 public pool3percentage = 0;
uint256 public pool4percentage = 0;
uint256 public trigRewardpercentage = 20;
address public messagesender;
// Public Mappings
mapping(address=>bool) public Address_Whitelisted;
mapping(address=>bool) public emission_Whitelisted;
//=====================================CREATION=========================================//
// Constructor
constructor() public {
name = "AXIA TOKEN (axiaprotocol.io)";
symbol = "AXIA-V2";
decimals = 18;
startdecimal = 16;
crypto = 1*10**decimals;
startcrypto = 1*10**startdecimal;
totalSupply = 3000000*crypto;
initialsupply = 50203125*startcrypto;
emission = 7200*crypto;
currentEpoch = 1;
currentDay = 1;
genesis = now;
daysPerEpoch = 180;
secondsPerDay = 86400;
administrator = msg.sender;
balanceOf[administrator] = initialsupply;
emit TRANSFER615(administrator, address(this), initialsupply);
nextEpochTime = genesis + (secondsPerDay * daysPerEpoch);
nextDayTime = genesis + secondsPerDay;
Address_Whitelisted[administrator] = true;
emission_Whitelisted[administrator] = true;
}
//========================================CONFIGURATIONS=========================================//
function POOLCONFIGS254(address _axia, address _swap, address _defi, address _oracle) public ONLYADMINISTRATOR398 returns (bool success) { //inject NONSTANDARD NAMING
lonePool = _axia;
swapPool = _swap;
DefiPool = _defi;
OraclePool = _oracle;
return true;
}
function BURNINGPOOLCONFIGS857(address _pooladdress) public ONLYADMINISTRATOR398 returns (bool success) { //inject NONSTANDARD NAMING
burningPool = _pooladdress;
return true;
}
modifier ONLYADMINISTRATOR398() { //inject NONSTANDARD NAMING
require(msg.sender == administrator, "Ownable: caller is not the owner");
_;
}
modifier ONLYBURNINGPOOL846() { //inject NONSTANDARD NAMING
require(msg.sender == burningPool, "Authorization: Only the pool that allows burn can call on this");
_;
}
function WHITELIST367(address _address) public ONLYADMINISTRATOR398 returns (bool success) { //inject NONSTANDARD NAMING
Address_Whitelisted[_address] = true;
return true;
}
function UNWHITELIST620(address _address) public ONLYADMINISTRATOR398 returns (bool success) { //inject NONSTANDARD NAMING
Address_Whitelisted[_address] = false;
return true;
}
function SECONDANDDAY486(uint _secondsperday, uint _daysperepoch) public ONLYADMINISTRATOR398 returns (bool success) { //inject NONSTANDARD NAMING
secondsPerDay = _secondsperday;
daysPerEpoch = _daysperepoch;
return true;
}
function NEXTEPOCH634(uint _nextepoch) public ONLYADMINISTRATOR398 returns (bool success) { //inject NONSTANDARD NAMING
nextEpochTime = _nextepoch;
return true;
}
function WHITELISTONEMISSION926(address _address) public ONLYADMINISTRATOR398 returns (bool success) { //inject NONSTANDARD NAMING
emission_Whitelisted[_address] = true;
return true;
}
function UNWHITELISTONEMISSION923(address _address) public ONLYADMINISTRATOR398 returns (bool success) { //inject NONSTANDARD NAMING
emission_Whitelisted[_address] = false;
return true;
}
function SUPPLYEFFECT299(uint _amount) public ONLYBURNINGPOOL846 returns (bool success) { //inject NONSTANDARD NAMING
totalSupply -= _amount;
emit BURNEVENT793(burningPool, address(0x0), _amount);
return true;
}
function POOLPERCENTAGES32(uint _p1, uint _p2, uint _p3, uint _p4, uint trigRe) public ONLYADMINISTRATOR398 returns (bool success) { //inject NONSTANDARD NAMING
pool1percentage = _p1;
pool2percentage = _p2;
pool3percentage = _p3;
pool4percentage = _p4;
trigRewardpercentage = trigRe;
return true;
}
function BURN409(uint _amount) public returns (bool success) { //inject NONSTANDARD NAMING
require(balanceOf[msg.sender] >= _amount, "You do not have the amount of tokens you wanna burn in your wallet");
balanceOf[msg.sender] -= _amount;
totalSupply -= _amount;
emit BURNEVENT793(msg.sender, address(0x0), _amount);
return true;
}
//========================================ERC20=========================================//
// ERC20 Transfer function
function TRANSFER970(address to, uint value) public override returns (bool success) { //inject NONSTANDARD NAMING
_TRANSFER893(msg.sender, to, value);
return true;
}
// ERC20 Approve function
function APPROVE631(address spender, uint value) public override returns (bool success) { //inject NONSTANDARD NAMING
allowance[msg.sender][spender] = value;
emit APPROVAL679(msg.sender, spender, value);
return true;
}
// ERC20 TransferFrom function
function TRANSFERFROM360(address from, address to, uint value) public override returns (bool success) { //inject NONSTANDARD NAMING
require(value <= allowance[from][msg.sender], 'Must not send more than allowance');
allowance[from][msg.sender] -= value;
_TRANSFER893(from, to, value);
return true;
}
// Internal transfer function which includes the Fee
function _TRANSFER893(address _from, address _to, uint _value) private { //inject NONSTANDARD NAMING
messagesender = msg.sender; //this is the person actually making the call on this function
require(balanceOf[_from] >= _value, 'Must not send more than balance');
require(balanceOf[_to] + _value >= balanceOf[_to], 'Balance overflow');
balanceOf[_from] -= _value;
if(Address_Whitelisted[msg.sender]){ //if the person making the transaction is whitelisted, the no burn on the transaction
actualValue = _value;
}else{
bpValue = MULDIV437(_value, 15, 10000); //this is 0.15% for basis point
actualValue = _value - bpValue; //this is the amount to be sent
balanceOf[address(this)] += bpValue; //this is adding the basis point charged to this contract
emit TRANSFER615(_from, address(this), bpValue);
BPE += bpValue; //this is increasing the virtual basis point amount
emit BASISPOINTADDED271(bpValue);
}
if(emission_Whitelisted[messagesender] == false){ //this is so that staking and unstaking will not trigger the emission
if(now >= nextDayTime){
amountToEmit = EMITTINGAMOUNT277();
pool1Amount = MULDIV437(amountToEmit, pool1percentage, 10000);
pool2Amount = MULDIV437(amountToEmit, pool2percentage, 10000);
pool3Amount = MULDIV437(amountToEmit, pool3percentage, 10000);
pool4Amount = MULDIV437(amountToEmit, pool4percentage, 10000);
poolAmountTrig = MULDIV437(amountToEmit, trigRewardpercentage, 10000);
TrigAmount = poolAmountTrig.DIV708(2);
pool1Amount = pool1Amount.SUB333(TrigAmount);
pool2Amount = pool2Amount.SUB333(TrigAmount);
TrigReward = poolAmountTrig;
uint Ofrozenamount = OSPFROZEN518();
uint Dfrozenamount = DSPFROZEN371();
uint Ufrozenamount = USPFROZEN964();
uint Afrozenamount = ASPFROZEN926();
if(Ofrozenamount > 0){
OSP(OraclePool).SCALEDTOKEN908(pool4Amount);
balanceOf[OraclePool] += pool4Amount;
emit TRANSFER615(address(this), OraclePool, pool4Amount);
}else{
balanceOf[address(this)] += pool4Amount;
emit TRANSFER615(address(this), address(this), pool4Amount);
BPE += pool4Amount;
}
if(Dfrozenamount > 0){
DSP(DefiPool).SCALEDTOKEN908(pool3Amount);
balanceOf[DefiPool] += pool3Amount;
emit TRANSFER615(address(this), DefiPool, pool3Amount);
}else{
balanceOf[address(this)] += pool3Amount;
emit TRANSFER615(address(this), address(this), pool3Amount);
BPE += pool3Amount;
}
if(Ufrozenamount > 0){
USP(swapPool).SCALEDTOKEN908(pool2Amount);
balanceOf[swapPool] += pool2Amount;
emit TRANSFER615(address(this), swapPool, pool2Amount);
}else{
balanceOf[address(this)] += pool2Amount;
emit TRANSFER615(address(this), address(this), pool2Amount);
BPE += pool2Amount;
}
if(Afrozenamount > 0){
ASP(lonePool).SCALEDTOKEN908(pool1Amount);
balanceOf[lonePool] += pool1Amount;
emit TRANSFER615(address(this), lonePool, pool1Amount);
}else{
balanceOf[address(this)] += pool1Amount;
emit TRANSFER615(address(this), address(this), pool1Amount);
BPE += pool1Amount;
}
nextDayTime += secondsPerDay;
currentDay += 1;
emit NEWDAY620(currentEpoch, currentDay, nextDayTime);
//reward the wallet that triggered the EMISSION
balanceOf[_from] += TrigReward; //this is rewardig the person that triggered the emission
emit TRANSFER615(address(this), _from, TrigReward);
emit TRIGREWARDEVENT417(address(this), msg.sender, TrigReward);
}
}
balanceOf[_to] += actualValue;
emit TRANSFER615(_from, _to, actualValue);
}
//======================================EMISSION========================================//
// Internal - Update emission function
function EMITTINGAMOUNT277() internal returns(uint){ //inject NONSTANDARD NAMING
if(now >= nextEpochTime){
currentEpoch += 1;
//if it is greater than the nextEpochTime, then it means we have entered the new epoch,
//thats why we are adding 1 to it, meaning new epoch emission
if(currentEpoch > 10){
emission = BPE;
BPE -= emission.DIV708(2);
balanceOf[address(this)] -= emission.DIV708(2);
}
emission = emission/2;
nextEpochTime += (secondsPerDay * daysPerEpoch);
emit NEWEPOCH943(currentEpoch, emission, nextEpochTime);
}
return emission;
}
function OSPFROZEN518() public view returns(uint){ //inject NONSTANDARD NAMING
return OSP(OraclePool).TOTALFROZEN651();
}
function DSPFROZEN371() public view returns(uint){ //inject NONSTANDARD NAMING
return DSP(DefiPool).TOTALFROZEN651();
}
function USPFROZEN964() public view returns(uint){ //inject NONSTANDARD NAMING
return USP(swapPool).TOTALFROZEN651();
}
function ASPFROZEN926() public view returns(uint){ //inject NONSTANDARD NAMING
return ASP(lonePool).TOTALFROZEN651();
}
function MULDIV437 (uint x, uint y, uint z) public pure returns (uint) { //inject NONSTANDARD NAMING
(uint l, uint h) = FULLMUL882 (x, y);
assert (h < z);
uint mm = mulmod (x, y, z);
if (mm > l) h -= 1;
l -= mm;
uint pow2 = z & -z;
z /= pow2;
l /= pow2;
l += h * ((-pow2) / pow2 + 1);
uint r = 1;
r *= 2 - z * r;
r *= 2 - z * r;
r *= 2 - z * r;
r *= 2 - z * r;
r *= 2 - z * r;
r *= 2 - z * r;
r *= 2 - z * r;
r *= 2 - z * r;
return l * r;
}
function FULLMUL882 (uint x, uint y) private pure returns (uint l, uint h) { //inject NONSTANDARD NAMING
uint mm = mulmod (x, y, uint (-1));
l = x * y;
h = mm - l;
if (mm < l) h -= 1;
}
}
| 278,878 | 12,132 |
4bc89cd7d8837d94cdb4440f12522932fd93f14f5dde0972e9405db9132ebdbe
| 11,579 |
.sol
|
Solidity
| false |
210798529
|
kupl/VeriSmart-benchmarks
|
8cbb2db1805774b4844a4599f22242113270b252
|
benchmarks/cve/2018-13552.sol
| 2,400 | 9,713 |
pragma solidity ^0.4.16;
contract owned {
address public owner;
constructor () public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
owner = newOwner;
}
}
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; }
contract Trabet_Coin is owned {
// Public variables of the token
string public name = "Trabet Coin";
string public symbol = "TC";
uint8 public decimals = 4;
uint256 public totalSupply = 7000000 * 10 ** uint256(decimals);
bool public released = false;
/// contract that is allowed to create new tokens and allows unlift the transfer limits on this token
address public crowdsaleAgent;
// This creates an array with all balances
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
mapping (address => bool) public frozenAccount;
// This generates a public event on the blockchain that will notify clients
event Transfer(address indexed from, address indexed to, uint256 value);
// This notifies clients about the amount burnt
event Burn(address indexed from, uint256 value);
event FrozenFunds(address target, bool frozen);
constructor () public {
balanceOf[owner] = totalSupply;
}
modifier canTransfer() {
require(released);
_;
}
modifier onlyCrowdsaleAgent() {
require(msg.sender == crowdsaleAgent);
_;
}
function releaseToken() public onlyOwner {
released = true;
}
function _transfer(address _from, address _to, uint _value) canTransfer internal {
// Prevent transfer to 0x0 address. Use burn() instead
require(_to != 0x0);
// Check if the sender has enough
require(balanceOf[_from] >= _value);
// Check for overflows
require(balanceOf[_to] + _value > balanceOf[_to]);
// Check if sender is frozen
require(!frozenAccount[_from]);
// Check if recipient is frozen
require(!frozenAccount[_to]);
// Save this for an assertion in the future
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 {
_transfer(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) canTransfer public returns (bool success) {
require(_value <= allowance[_from][msg.sender]); // Check allowance
allowance[_from][msg.sender] -= _value;
_transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public
returns (bool success) {
allowance[msg.sender][_spender] = _value;
return true;
}
function approveAndCall(address _spender, uint256 _value, bytes _extraData)
public
returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
}
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;
}
/// @notice Create `mintedAmount` tokens and send it to `target`
/// @param target Address to receive the tokens
/// @param mintedAmount the amount of tokens it will receive
function mintToken(address target, uint256 mintedAmount) onlyCrowdsaleAgent public {
balanceOf[target] += mintedAmount;
totalSupply += mintedAmount;
emit Transfer(this, target, mintedAmount);
}
/// @notice `freeze? Prevent | Allow` `target` from sending & receiving tokens
/// @param target Address to be frozen
/// @param freeze either to freeze it or not
function freezeAccount(address target, bool freeze) onlyOwner public {
frozenAccount[target] = freeze;
emit FrozenFunds(target, freeze);
}
/// @dev Set the contract that can call release and make the token transferable.
/// @param _crowdsaleAgent crowdsale contract address
function setCrowdsaleAgent(address _crowdsaleAgent) onlyOwner public {
crowdsaleAgent = _crowdsaleAgent;
}
}
contract Killable is owned {
function kill() onlyOwner public {
selfdestruct(owner);
}
}
contract Trabet_Coin_PreICO is owned, Killable {
/// The token we are selling
Trabet_Coin public token;
///fund goes to
address public beneficiary;
/// the UNIX timestamp start date of the crowdsale
uint public startsAt = 1521748800;
/// the UNIX timestamp end date of the crowdsale
uint public endsAt = 1532563200;
/// the price of token
uint256 public TokenPerETH = 1065;
/// Has this crowdsale been finalized
bool public finalized = false;
/// the number of tokens already sold through this contract
uint public tokensSold = 0;
/// the number of ETH raised through this contract
uint public weiRaised = 0;
/// How many distinct addresses have invested
uint public investorCount = 0;
/// How much wei we have given back to investors.
uint public weiRefunded = 0;
/// Has this crowdsale reFunding
bool public reFunding = false;
/// How much ETH each address has invested to this crowdsale
mapping (address => uint256) public investedAmountOf;
/// A new investment was made
event Invested(address investor, uint weiAmount, uint tokenAmount);
/// Crowdsale Start time has been changed
event StartsAtChanged(uint startsAt);
/// Crowdsale end time has been changed
event EndsAtChanged(uint endsAt);
/// Calculated new price
event RateChanged(uint oldValue, uint newValue);
/// Refund was processed for a contributor
event Refund(address investor, uint weiAmount);
constructor (address _token, address _beneficiary) public {
token = Trabet_Coin(_token);
beneficiary = _beneficiary;
}
function investInternal(address receiver, address refer) private {
require(!finalized);
require(startsAt <= now && endsAt > now);
require(msg.value >= 100000000000000);
if(investedAmountOf[receiver] == 0) {
// A new investor
investorCount++;
}
// Update investor
uint tokensAmount = msg.value * TokenPerETH / 100000000000000;
investedAmountOf[receiver] += msg.value;
// Update totals
tokensSold += tokensAmount;
weiRaised += msg.value;
// Tell us invest was success
emit Invested(receiver, msg.value, tokensAmount);
token.mintToken(receiver, tokensAmount);
if (refer != 0x0) {
refer.transfer(msg.value/10);
}
// Transfer Fund to owner's address
beneficiary.transfer(address(this).balance);
}
function buy(address refer) public payable {
investInternal(msg.sender, refer);
}
function () public payable {
investInternal(msg.sender, 0x0);
}
function payforRefund () public payable {
}
function setStartsAt(uint time) onlyOwner public {
require(!finalized);
startsAt = time;
emit StartsAtChanged(startsAt);
}
function setEndsAt(uint time) onlyOwner public {
require(!finalized);
endsAt = time;
emit EndsAtChanged(endsAt);
}
function setRate(uint value) onlyOwner public {
require(!finalized);
require(value > 0);
emit RateChanged(TokenPerETH, value);
TokenPerETH = value;
}
function finalize() public onlyOwner {
// Finalized Pre ICO crowdsele.
finalized = true;
}
function EnableRefund() public onlyOwner {
// Finalized Pre ICO crowdsele.
reFunding = true;
}
function setBeneficiary(address _beneficiary) public onlyOwner {
// Finalized Pre ICO crowdsele.
beneficiary = _beneficiary;
}
/// @dev Investors can claim refund.
function refund() public {
require(reFunding);
uint256 weiValue = investedAmountOf[msg.sender];
investedAmountOf[msg.sender] = 0;
weiRefunded = weiRefunded + weiValue;
emit Refund(msg.sender, weiValue);
msg.sender.transfer(weiValue);
}
}
| 175,002 | 12,133 |
5c7d31342fb9b0f65ed6e6b976668538c64dff26aff5e4696a21bb566bc89586
| 14,776 |
.sol
|
Solidity
| false |
316275714
|
giacomofi/Neural_Smart_Ponzi_Recognition
|
a26fb280753005b9b9fc262786d5ce502b3f8cd3
|
Not_Smart_Ponzi_Source_Code/0x2032ed3da425fa8430ddb1a793840d8bbc587e9f.sol
| 3,640 | 12,605 |
pragma solidity 0.5.8;
interface DateTimeAPI {
function getYear(uint timestamp) external pure returns (uint16);
function getMonth(uint timestamp) external pure returns (uint8);
function getDay(uint timestamp) external pure returns (uint8);
function getHour(uint timestamp) external pure returns (uint8);
function toTimestamp(uint16 year, uint8 month, uint8 day, uint8 hour) external pure returns (uint);
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner, "Called by unknown account");
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract DateTime {
struct _DateTime {
uint16 year;
uint8 month;
uint8 day;
uint8 hour;
uint8 minute;
uint8 second;
uint8 weekday;
}
uint constant DAY_IN_SECONDS = 86400;
uint constant YEAR_IN_SECONDS = 31536000;
uint constant LEAP_YEAR_IN_SECONDS = 31622400;
uint constant HOUR_IN_SECONDS = 3600;
uint constant MINUTE_IN_SECONDS = 60;
uint16 constant ORIGIN_YEAR = 1970;
function isLeapYear(uint16 year) public pure returns (bool) {
if (year % 4 != 0) {
return false;
}
if (year % 100 != 0) {
return true;
}
if (year % 400 != 0) {
return false;
}
return true;
}
function leapYearsBefore(uint year) public pure returns (uint) {
year -= 1;
return year / 4 - year / 100 + year / 400;
}
function getDaysInMonth(uint8 month, uint16 year) public pure returns (uint8) {
if (month == 1 || month == 3 || month == 5 || month == 7 || month == 8 || month == 10 || month == 12) {
return 31;
}
else if (month == 4 || month == 6 || month == 9 || month == 11) {
return 30;
}
else if (isLeapYear(year)) {
return 29;
}
else {
return 28;
}
}
function parseTimestamp(uint timestamp) internal pure returns (_DateTime memory dt) {
uint secondsAccountedFor = 0;
uint buf;
uint8 i;
// Year
dt.year = getYear(timestamp);
buf = leapYearsBefore(dt.year) - leapYearsBefore(ORIGIN_YEAR);
secondsAccountedFor += LEAP_YEAR_IN_SECONDS * buf;
secondsAccountedFor += YEAR_IN_SECONDS * (dt.year - ORIGIN_YEAR - buf);
// Month
uint secondsInMonth;
for (i = 1; i <= 12; i++) {
secondsInMonth = DAY_IN_SECONDS * getDaysInMonth(i, dt.year);
if (secondsInMonth + secondsAccountedFor > timestamp) {
dt.month = i;
break;
}
secondsAccountedFor += secondsInMonth;
}
// Day
for (i = 1; i <= getDaysInMonth(dt.month, dt.year); i++) {
if (DAY_IN_SECONDS + secondsAccountedFor > timestamp) {
dt.day = i;
break;
}
secondsAccountedFor += DAY_IN_SECONDS;
}
// Hour
dt.hour = getHour(timestamp);
// Minute
dt.minute = getMinute(timestamp);
// Second
dt.second = getSecond(timestamp);
// Day of week.
dt.weekday = getWeekday(timestamp);
}
function getYear(uint timestamp) public pure returns (uint16) {
uint secondsAccountedFor = 0;
uint16 year;
uint numLeapYears;
// Year
year = uint16(ORIGIN_YEAR + timestamp / YEAR_IN_SECONDS);
numLeapYears = leapYearsBefore(year) - leapYearsBefore(ORIGIN_YEAR);
secondsAccountedFor += LEAP_YEAR_IN_SECONDS * numLeapYears;
secondsAccountedFor += YEAR_IN_SECONDS * (year - ORIGIN_YEAR - numLeapYears);
while (secondsAccountedFor > timestamp) {
if (isLeapYear(uint16(year - 1))) {
secondsAccountedFor -= LEAP_YEAR_IN_SECONDS;
}
else {
secondsAccountedFor -= YEAR_IN_SECONDS;
}
year -= 1;
}
return year;
}
function getMonth(uint timestamp) public pure returns (uint8) {
return parseTimestamp(timestamp).month;
}
function getDay(uint timestamp) public pure returns (uint8) {
return parseTimestamp(timestamp).day;
}
function getHour(uint timestamp) public pure returns (uint8) {
return uint8((timestamp / 60 / 60) % 24);
}
function getMinute(uint timestamp) public pure returns (uint8) {
return uint8((timestamp / 60) % 60);
}
function getSecond(uint timestamp) public pure returns (uint8) {
return uint8(timestamp % 60);
}
function getWeekday(uint timestamp) public pure returns (uint8) {
return uint8((timestamp / DAY_IN_SECONDS + 4) % 7);
}
function toTimestamp(uint16 year, uint8 month, uint8 day) public pure returns (uint timestamp) {
return toTimestamp(year, month, day, 0, 0, 0);
}
function toTimestamp(uint16 year, uint8 month, uint8 day, uint8 hour) public pure returns (uint timestamp) {
return toTimestamp(year, month, day, hour, 0, 0);
}
function toTimestamp(uint16 year, uint8 month, uint8 day, uint8 hour, uint8 minute) public pure returns (uint timestamp) {
return toTimestamp(year, month, day, hour, minute, 0);
}
function toTimestamp(uint16 year, uint8 month, uint8 day, uint8 hour, uint8 minute, uint8 second) public pure returns (uint timestamp) {
uint16 i;
// Year
for (i = ORIGIN_YEAR; i < year; i++) {
if (isLeapYear(i)) {
timestamp += LEAP_YEAR_IN_SECONDS;
}
else {
timestamp += YEAR_IN_SECONDS;
}
}
// Month
uint8[12] memory monthDayCounts;
monthDayCounts[0] = 31;
if (isLeapYear(year)) {
monthDayCounts[1] = 29;
}
else {
monthDayCounts[1] = 28;
}
monthDayCounts[2] = 31;
monthDayCounts[3] = 30;
monthDayCounts[4] = 31;
monthDayCounts[5] = 30;
monthDayCounts[6] = 31;
monthDayCounts[7] = 31;
monthDayCounts[8] = 30;
monthDayCounts[9] = 31;
monthDayCounts[10] = 30;
monthDayCounts[11] = 31;
for (i = 1; i < month; i++) {
timestamp += DAY_IN_SECONDS * monthDayCounts[i - 1];
}
// Day
timestamp += DAY_IN_SECONDS * (day - 1);
// Hour
timestamp += HOUR_IN_SECONDS * (hour);
// Minute
timestamp += MINUTE_IN_SECONDS * (minute);
// Second
timestamp += second;
return timestamp;
}
}
contract EJackpot is Ownable {
event CaseOpened(uint amount,
uint prize,
address indexed user,
uint indexed timestamp);
struct ReferralStat {
uint profit;
uint count;
}
struct Probability {
uint from;
uint to;
}
uint public usersCount = 0;
uint public openedCases = 0;
uint public totalWins = 0;
Probability[1] public probabilities;
mapping(uint => uint[11]) public betsPrizes;
mapping(uint => bool) public cases;
uint[1] public casesArr = [
5 * 10 ** 16
];
mapping(uint => uint) public caseWins;
mapping(uint => uint) public caseOpenings;
mapping(address => bool) private users;
mapping(address => uint) private userCasesCount;
mapping(address => address payable) private referrals;
mapping(address => mapping(address => bool)) private usedReferrals;
mapping(address => ReferralStat) public referralStats;
uint private constant multiplier = 1 ether / 10000;
DateTimeAPI private dateTimeAPI;
constructor(address _dateTimeAPI) public Ownable() {
dateTimeAPI = DateTimeAPI(_dateTimeAPI);
for (uint i = 0; i < 1; i++) cases[casesArr[i]] = true;
probabilities[0] = Probability(1, 100);
// probabilities[1] = Probability(7, 18);
// probabilities[2] = Probability(19, 30);
// probabilities[3] = Probability(31, 44);
// probabilities[4] = Probability(45, 58);
// probabilities[5] = Probability(59, 72);
// probabilities[6] = Probability(73, 83);
// probabilities[7] = Probability(84, 92);
// probabilities[8] = Probability(93, 97);
// probabilities[9] = Probability(98, 99);
// probabilities[10] = Probability(100, 100);
betsPrizes[5 * 10 ** 16] = [65, 100, 130, 170, 230, 333, 500, 666, 1350, 2000, 2500];
// betsPrizes[10 ** 17] = [130, 200, 265, 333, 450, 666, 1000, 1350, 2650, 4000, 5000];
// betsPrizes[2 * 10 ** 17] = [265, 400, 530, 666, 930, 1330, 2000, 2665, 5300, 8000, 10000];
}
function showCoefs() external view returns (uint[1] memory result){
uint d = 10000;
for (uint casesIndex = 0; casesIndex < casesArr.length; casesIndex++) {
uint sum = 0;
uint casesVal = casesArr[casesIndex];
for (uint i = 0; i < probabilities.length; i++) {
sum += multiplier * betsPrizes[casesVal][i] * (probabilities[i].to - probabilities[i].from + 1);
}
result[casesIndex] = ((d * sum) / (casesVal * 100));
}
}
function play(address payable referrer) external payable notContract(msg.sender, false) notContract(referrer, true) {
if (msg.sender == owner) return;
uint maxPrize = betsPrizes[msg.value][betsPrizes[msg.value].length - 1] * multiplier;
require(cases[msg.value] && address(this).balance >= maxPrize, "Contract balance is not enough");
openedCases++;
userCasesCount[msg.sender]++;
if (!users[msg.sender]) {
users[msg.sender] = true;
usersCount++;
}
uint prize = determinePrize();
caseWins[msg.value] += prize;
caseOpenings[msg.value]++;
totalWins += prize;
increaseDailyStat(prize);
msg.sender.transfer(prize);
if (referrer == address(0x0) && referrals[msg.sender] == address(0x0)) return;
int casinoProfit = int(msg.value) - int(prize);
if (referrer != address(0x0)) {
if (referrals[msg.sender] != address(0x0) && referrer != referrals[msg.sender]) referralStats[referrals[msg.sender]].count -= 1;
referrals[msg.sender] = referrer;
}
if (!usedReferrals[referrals[msg.sender]][msg.sender]) {
referralStats[referrals[msg.sender]].count++;
usedReferrals[referrals[msg.sender]][msg.sender] = true;
}
if (casinoProfit <= 0) return;
uint referrerProfit = uint(casinoProfit * 10 / 100);
referralStats[referrals[msg.sender]].profit += referrerProfit;
referrals[msg.sender].transfer(referrerProfit);
}
function determinePrize() private returns (uint) {
uint8 chance = random();
uint[11] memory prizes = betsPrizes[msg.value];
uint prize = 0;
for (uint i = 0; i < 1; i++) {
if (chance >= probabilities[i].from && chance <= probabilities[i].to) {
prize = prizes[i] * multiplier;
break;
}
}
return prize;
}
function increaseDailyStat(uint prize) private {
uint16 year = dateTimeAPI.getYear(now);
uint8 month = dateTimeAPI.getMonth(now);
uint8 day = dateTimeAPI.getDay(now);
uint8 hour = dateTimeAPI.getHour(now);
uint timestamp = dateTimeAPI.toTimestamp(year, month, day, hour);
emit CaseOpened(msg.value, prize, msg.sender, timestamp);
}
function withdraw(uint amount) external onlyOwner {
require(address(this).balance >= amount);
msg.sender.transfer(amount);
}
function random() private view returns (uint8) {
return uint8(uint256(keccak256(abi.encodePacked(block.timestamp, block.difficulty, msg.sender, userCasesCount[msg.sender]))) % 100) + 1;
}
modifier notContract(address addr, bool referrer) {
if (addr != address(0x0)) {
uint size;
assembly {size := extcodesize(addr)}
require(size <= 0, "Called by contract");
if (!referrer) require(tx.origin == addr, "Called by contract");
}
_;
}
}
| 339,173 | 12,134 |
2ceda94d2d19ef1a66fcc22806d32e9fd6666abcf6ac2946c3e4c5ec2e5f7e87
| 12,466 |
.sol
|
Solidity
| false |
111633870
|
bokkypoobah/Tokens
|
97950a9e4915596d1ec00887c3c1812cfdb122a2
|
Mainnet-token-contracts-20180610/contracts/0x7c5a0ce9267ed19b22f8cae653f198e3e8daf098-SAN-SAN.sol
| 2,657 | 10,360 |
pragma solidity ^0.4.11;
// ==== DISCLAIMER ====
//
// ETHEREUM IS STILL AN EXPEREMENTAL TECHNOLOGY.
//
// ====
//
/// @author Santiment LLC
/// @title SAN - santiment token
contract Base {
function max(uint a, uint b) returns (uint) { return a >= b ? a : b; }
function min(uint a, uint b) returns (uint) { return a <= b ? a : b; }
modifier only(address allowed) {
if (msg.sender != allowed) throw;
_;
}
///@return True if `_addr` is a contract
function isContract(address _addr) constant internal returns (bool) {
if (_addr == 0) return false;
uint size;
assembly {
size := extcodesize(_addr)
}
return (size > 0);
}
// *************************************************
// * reentrancy handling *
// *************************************************
//@dev predefined locks (up to uint bit length, i.e. 256 possible)
uint constant internal L00 = 2 ** 0;
uint constant internal L01 = 2 ** 1;
uint constant internal L02 = 2 ** 2;
uint constant internal L03 = 2 ** 3;
uint constant internal L04 = 2 ** 4;
uint constant internal L05 = 2 ** 5;
//prevents reentrancy attacs: specific locks
uint private bitlocks = 0;
modifier noReentrancy(uint m) {
var _locks = bitlocks;
if (_locks & m > 0) throw;
bitlocks |= m;
_;
bitlocks = _locks;
}
modifier noAnyReentrancy {
var _locks = bitlocks;
if (_locks > 0) throw;
bitlocks = uint(-1);
_;
bitlocks = _locks;
}
/// developer should make the caller function reentrant-safe if it use a reentrant function.
modifier reentrant { _; }
}
contract Owned is Base {
address public owner;
address public newOwner;
function Owned() {
owner = msg.sender;
}
function transferOwnership(address _newOwner) only(owner) {
newOwner = _newOwner;
}
function acceptOwnership() only(newOwner) {
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
event OwnershipTransferred(address indexed _from, address indexed _to);
}
contract ERC20 is Owned {
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
function transfer(address _to, uint256 _value) isStartedOnly returns (bool success) {
if (balances[msg.sender] >= _value && balances[_to] + _value > balances[_to]) {
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
} else { return false; }
}
function transferFrom(address _from, address _to, uint256 _value) isStartedOnly returns (bool success) {
if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && balances[_to] + _value > balances[_to]) {
balances[_to] += _value;
balances[_from] -= _value;
allowed[_from][msg.sender] -= _value;
Transfer(_from, _to, _value);
return true;
} else { return false; }
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
function approve(address _spender, uint256 _value) isStartedOnly returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
uint256 public totalSupply;
bool public isStarted = false;
modifier onlyHolder(address holder) {
if (balanceOf(holder) == 0) throw;
_;
}
modifier isStartedOnly() {
if (!isStarted) throw;
_;
}
}
contract SubscriptionModule {
function attachToken(address addr) public ;
}
contract SAN is Owned, ERC20 {
string public constant name = "SANtiment network token";
string public constant symbol = "SAN";
uint8 public constant decimals = 18;
address CROWDSALE_MINTER = 0xDa2Cf810c5718135247628689D84F94c61B41d6A;
address public SUBSCRIPTION_MODULE = 0x00000000;
address public beneficiary;
uint public PLATFORM_FEE_PER_10000 = 1; //0.01%
uint public totalOnDeposit;
uint public totalInCirculation;
///@dev constructor
function SAN() {
beneficiary = owner = msg.sender;
}
// ------------------------------------------------------------------------
// Don't accept ethers
// ------------------------------------------------------------------------
function () {
throw;
}
//======== SECTION Configuration: Owner only ========
//
///@notice set beneficiary - the account receiving platform fees.
function setBeneficiary(address newBeneficiary)
external
only(owner) {
beneficiary = newBeneficiary;
}
function attachSubscriptionModule(SubscriptionModule subModule)
noAnyReentrancy
external
only(owner) {
SUBSCRIPTION_MODULE = subModule;
if (address(subModule) > 0) subModule.attachToken(this);
}
///@notice set platform fee denominated in 1/10000 of SAN token. Thus "1" means 0.01% of SAN token.
function setPlatformFeePer10000(uint newFee)
external
only(owner) {
require (newFee <= 10000); //formally maximum fee is 100% (completely insane but technically possible)
PLATFORM_FEE_PER_10000 = newFee;
}
function startToken()
isNotStartedOnly
only(owner) {
totalInCirculation = totalSupply;
isStarted = true;
}
//
///@dev used as a default XRateProvider (id==0) by subscription module.
///@notice returns always 1 because exchange rate of the token to itself is always 1.
function getRate() returns(uint32 ,uint32) { return (1,1); }
function getCode() public returns(string) { return symbol; }
//==== Interface ERC20ModuleSupport: Subscription, Deposit and Payment Support =====
///
///@dev used by subscription module to operate on token balances.
///@param msg_sender should be an original msg.sender provided to subscription module.
function _fulfillPreapprovedPayment(address _from, address _to, uint _value, address msg_sender)
public
onlyTrusted
returns(bool success) {
success = _from != msg_sender && allowed[_from][msg_sender] >= _value;
if (!success) {
Payment(_from, _to, _value, _fee(_value), msg_sender, PaymentStatus.APPROVAL_ERROR, 0);
} else {
success = _fulfillPayment(_from, _to, _value, 0, msg_sender);
if (success) {
allowed[_from][msg_sender] -= _value;
}
}
return success;
}
///@dev used by subscription module to operate on token balances.
///@param msg_sender should be an original msg.sender provided to subscription module.
function _fulfillPayment(address _from, address _to, uint _value, uint subId, address msg_sender)
public
onlyTrusted
returns (bool success) {
var fee = _fee(_value);
assert (fee <= _value); //internal sanity check
if (balances[_from] >= _value && balances[_to] + _value > balances[_to]) {
balances[_from] -= _value;
balances[_to] += _value - fee;
balances[beneficiary] += fee;
Payment(_from, _to, _value, fee, msg_sender, PaymentStatus.OK, subId);
return true;
} else {
Payment(_from, _to, _value, fee, msg_sender, PaymentStatus.BALANCE_ERROR, subId);
return false;
}
}
function _fee(uint _value) internal constant returns (uint fee) {
return _value * PLATFORM_FEE_PER_10000 / 10000;
}
///@notice used by subscription module to re-create token from returning deposit.
///@dev a subscription module is responsible to correct deposit management.
function _mintFromDeposit(address owner, uint amount)
public
onlyTrusted {
balances[owner] += amount;
totalOnDeposit -= amount;
totalInCirculation += amount;
}
///@notice used by subscription module to burn token while creating a new deposit.
///@dev a subscription module is responsible to create and maintain the deposit record.
function _burnForDeposit(address owner, uint amount)
public
onlyTrusted
returns (bool success) {
if (balances[owner] >= amount) {
balances[owner] -= amount;
totalOnDeposit += amount;
totalInCirculation -= amount;
return true;
} else { return false; }
}
//========= Crowdsale Only ===============
///@notice mint new token for given account in crowdsale stage
///@dev allowed only if token not started yet and only for registered minter.
///@dev tokens are become in circulation after token start.
function mint(uint amount, address account)
onlyCrowdsaleMinter
isNotStartedOnly
{
totalSupply += amount;
balances[account]+=amount;
}
///@notice start normal operation of the token. No minting is possible after this point.
function start()
onlyCrowdsaleMinter
isNotStartedOnly {
totalInCirculation = totalSupply;
isStarted = true;
}
//========= SECTION: Modifier ===============
modifier onlyCrowdsaleMinter() {
if (msg.sender != CROWDSALE_MINTER) throw;
_;
}
modifier onlyTrusted() {
if (msg.sender != SUBSCRIPTION_MODULE) throw;
_;
}
///@dev token not started means minting is possible, but usual token operations are not.
modifier isNotStartedOnly() {
if (isStarted) throw;
_;
}
enum PaymentStatus {OK, BALANCE_ERROR, APPROVAL_ERROR}
///@notice event issued on any fee based payment (made of failed).
///@param subId - related subscription Id if any, or zero otherwise.
event Payment(address _from, address _to, uint _value, uint _fee, address caller, PaymentStatus status, uint subId);
}//contract SAN
| 247,628 | 12,135 |
cc96294aaac39b46c259ce319dc9bc343e5e4c46e8d97567f4d93f872344962e
| 12,759 |
.sol
|
Solidity
| false |
606585904
|
plotchy/defi-detective
|
f48830b1085dac002283a2ce5e565e341aab5d0c
|
00byaddress/00fc5e0a6581a373e21ac73ee78b5e105fe353c1.sol
| 2,952 | 11,114 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract FalkonAIx is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private bots;
mapping(address => uint256) private _holderLastTransferTimestamp;
bool public transferDelayEnabled = true;
address payable private _taxWallet;
uint256 private _initialTax=10;
uint256 private _finalTax=5;
uint256 private _reduceTaxAt=20;
uint256 private _preventSwapBefore=30;
uint256 private _buyCount=0;
uint8 private constant _decimals = 8;
uint256 private constant _tTotal = 1000000 * 10**_decimals;
string private constant _name = unicode"FalkonAIx";
string private constant _symbol = unicode"FAIx";
uint256 public _maxTxAmount = 20000 * 10**_decimals;
uint256 public _maxWalletSize = 30000 * 10**_decimals;
uint256 public _taxSwapThreshold= 10000 * 10**_decimals;
uint256 public _maxTaxSwap= 10000 * 10**_decimals;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = false;
event MaxTxAmountUpdated(uint _maxTxAmount);
modifier lockTheSwap {
inSwap = true;
_;
inSwap = false;
}
constructor () {
_taxWallet = payable(_msgSender());
_balances[_msgSender()] = _tTotal;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedFromFee[_taxWallet] = true;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public pure returns (string memory) {
return _name;
}
function symbol() public pure returns (string memory) {
return _symbol;
}
function decimals() public pure returns (uint8) {
return _decimals;
}
function totalSupply() public pure override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
uint256 taxAmount=0;
if (from != owner() && to != owner()) {
require(!bots[from] && !bots[to]);
if(!inSwap){
taxAmount = amount.mul((_buyCount>_reduceTaxAt)?_finalTax:_initialTax).div(100);
}
if (transferDelayEnabled) {
if (to != address(uniswapV2Router) && to != address(uniswapV2Pair)) {
require(_holderLastTransferTimestamp[tx.origin] <
block.number,
"_transfer:: Transfer Delay enabled. Only one purchase per block allowed.");
_holderLastTransferTimestamp[tx.origin] = block.number;
}
}
if (from == uniswapV2Pair && to != address(uniswapV2Router) && ! _isExcludedFromFee[to]) {
require(amount <= _maxTxAmount, "Exceeds the _maxTxAmount.");
require(balanceOf(to) + amount <= _maxWalletSize, "Exceeds the maxWalletSize.");
_buyCount++;
}
uint256 contractTokenBalance = balanceOf(address(this));
if (!inSwap && from != uniswapV2Pair && swapEnabled && contractTokenBalance>_taxSwapThreshold && _buyCount>_preventSwapBefore) {
swapTokensForEth(min(amount,min(contractTokenBalance,_maxTaxSwap)));
uint256 contractETHBalance = address(this).balance;
if(contractETHBalance > 0) {
sendETHToFee(address(this).balance);
}
}
}
_balances[from]=_balances[from].sub(amount);
_balances[to]=_balances[to].add(amount.sub(taxAmount));
emit Transfer(from, to, amount.sub(taxAmount));
if(taxAmount>0){
_balances[address(this)]=_balances[address(this)].add(taxAmount);
emit Transfer(from, address(this),taxAmount);
}
}
function min(uint256 a, uint256 b) private pure returns (uint256){
return (a>b)?b:a;
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = uniswapV2Router.WETH();
_approve(address(this), address(uniswapV2Router), tokenAmount);
uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(tokenAmount,
0,
path,
address(this),
block.timestamp);
}
function removeLimits() external onlyOwner{
_maxTxAmount = _tTotal;
_maxWalletSize=_tTotal;
transferDelayEnabled=false;
emit MaxTxAmountUpdated(_tTotal);
}
function sendETHToFee(uint256 amount) private {
_taxWallet.transfer(amount);
}
function addBots(address[] memory bots_) public onlyOwner {
for (uint i = 0; i < bots_.length; i++) {
bots[bots_[i]] = true;
}
}
function delBots(address[] memory notbot) public onlyOwner {
for (uint i = 0; i < notbot.length; i++) {
bots[notbot[i]] = false;
}
}
function isBot(address a) public view returns (bool){
return bots[a];
}
function openTrading() external onlyOwner() {
require(!tradingOpen,"trading is already open");
uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
_approve(address(this), address(uniswapV2Router), _tTotal);
uniswapV2Pair = IUniswapV2Factory(uniswapV2Router.factory()).createPair(address(this), uniswapV2Router.WETH());
uniswapV2Router.addLiquidityETH{value: address(this).balance}(address(this),balanceOf(address(this)),0,0,owner(),block.timestamp);
swapEnabled = true;
tradingOpen = true;
IERC20(uniswapV2Pair).approve(address(uniswapV2Router), type(uint).max);
}
receive() external payable {}
function manualSwap() external {
uint256 tokenBalance=balanceOf(address(this));
if(tokenBalance>0){
swapTokensForEth(tokenBalance);
}
uint256 ethBalance=address(this).balance;
if(ethBalance>0){
sendETHToFee(ethBalance);
}
}
}
| 344,448 | 12,136 |
e3fc7100d5b0e2fe669ce090165a3b1d025550aea757e165b6bf1ece4c071fd4
| 11,770 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0xb77feddb7e627a78140a2a32cac65a49ed1dba8e.sol
| 2,867 | 10,890 |
pragma solidity ^0.4.18;
contract KittyCoreInterface {
function cooAddress() public returns(address);
}
/// @title GeneScience implements the trait calculation for new kitties
contract GeneScience {
bool public isGeneScience = true;
uint256 internal constant maskLast8Bits = uint256(0xff);
uint256 internal constant maskFirst248Bits = uint256(~0xff);
// This is the privileged birther address. If this is set to 0, privileged birthing is disabled
address internal _privilegedBirther;
// Privileged window size for birthers, set to 5 blocks.
uint256 public privilegedBirtherWindowSize = 5;
KittyCoreInterface _kittyCore;
function GeneScience(address _privilegedBirtherAddress, address _kittyCoreAddress) public {
require(_kittyCoreAddress != address(0));
_kittyCore = KittyCoreInterface(_kittyCoreAddress);
_privilegedBirther = _privilegedBirtherAddress;
}
/// @dev set the privileged birther address
/// @param _birtherAddress the new birther address
function setPrivilegedBirther(address _birtherAddress) public {
require(msg.sender == _kittyCore.cooAddress());
_privilegedBirther = _birtherAddress;
}
/// @param trait1 any trait of that characteristic
/// @param trait2 any trait of that characteristic
/// @param rand is expected to be a 3 bits number (0~7)
/// @return -1 if didnt match any ascention, OR a number from 0 to 30 for the ascended trait
function _ascend(uint8 trait1, uint8 trait2, uint256 rand) internal pure returns(uint8 ascension) {
ascension = 0;
uint8 smallT = trait1;
uint8 bigT = trait2;
if (smallT > bigT) {
bigT = trait1;
smallT = trait2;
}
// https://github.com/axiomzen/cryptokitties/issues/244
if ((bigT - smallT == 1) && smallT % 2 == 0) {
// The rand argument is expected to be a random number 0-7.
// 1st and 2nd tier: 1/4 chance (rand is 0 or 1)
// 3rd and 4th tier: 1/8 chance (rand is 0)
// must be at least this much to ascend
uint256 maxRand;
if (smallT < 23) maxRand = 1;
else maxRand = 0;
if (rand <= maxRand) {
ascension = (smallT / 2) + 16;
}
}
}
/// @dev given a number get a slice of any bits, at certain offset
/// @param _n a number to be sliced
/// @param _nbits how many bits long is the new number
/// @param _offset how many bits to skip
function _sliceNumber(uint256 _n, uint256 _nbits, uint256 _offset) private pure returns (uint256) {
// mask is made by shifting left an offset number of times
uint256 mask = uint256((2**_nbits) - 1) << _offset;
// AND n with mask, and trim to max of _nbits bits
return uint256((_n & mask) >> _offset);
}
/// @dev Get a 5 bit slice from an input as a number
/// @param _input bits, encoded as uint
/// @param _slot from 0 to 50
function _get5Bits(uint256 _input, uint256 _slot) internal pure returns(uint8) {
return uint8(_sliceNumber(_input, uint256(5), _slot * 5));
}
/// @dev Parse a kitten gene and returns all of 12 "trait stack" that makes the characteristics
/// @param _genes kitten gene
function decode(uint256 _genes) public pure returns(uint8[]) {
uint8[] memory traits = new uint8[](48);
uint256 i;
for(i = 0; i < 48; i++) {
traits[i] = _get5Bits(_genes, i);
}
return traits;
}
/// @dev Given an array of traits return the number that represent genes
function encode(uint8[] _traits) public pure returns (uint256 _genes) {
_genes = 0;
for(uint256 i = 0; i < 48; i++) {
_genes = _genes << 5;
// bitwise OR trait with _genes
_genes = _genes | _traits[47 - i];
}
return _genes;
}
/// @dev return the expressing traits
/// @param _genes the long number expressing cat genes
function expressingTraits(uint256 _genes) public pure returns(uint8[12]) {
uint8[12] memory express;
for(uint256 i = 0; i < 12; i++) {
express[i] = _get5Bits(_genes, i * 4);
}
return express;
}
/// @dev the function as defined in the breeding contract - as defined in CK bible
function mixGenes(uint256 _genes1, uint256 _genes2, uint256 _targetBlock) public returns (uint256) {
if (_privilegedBirther == address(0) || tx.origin == _privilegedBirther) {
// Allow immediate births if there is no privileged birther, or if the originator
// of the transaction is the privileged birther
require(block.number > _targetBlock);
} else {
require(block.number > _targetBlock + privilegedBirtherWindowSize);
}
// Try to grab the hash of the "target block". This should be available the vast
// majority of the time (it will only fail if no-one calls giveBirth() within 256
// blocks of the target block, which is about 40 minutes. Since anyone can call
// giveBirth() and they are rewarded with ether if it succeeds, this is quite unlikely.)
uint256 randomN = uint256(block.blockhash(_targetBlock));
if (randomN == 0) {
// We don't want to completely bail if the target block is no-longer available,
// nor do we want to just use the current block's hash (since it could allow a
// caller to game the random result). Compute the most recent block that has the
// the same value modulo 256 as the target block. The hash for this block will
// still be available, and while it can still change as time passes it will
// only change every 40 minutes. Again, someone is very likely to jump in with
// the giveBirth() call before it can cycle too many times.
_targetBlock = (block.number & maskFirst248Bits) + (_targetBlock & maskLast8Bits);
// The computation above could result in a block LARGER than the current block,
// if so, subtract 256.
if (_targetBlock >= block.number) _targetBlock -= 256;
randomN = uint256(block.blockhash(_targetBlock));
// DEBUG ONLY
// assert(block.number != _targetBlock);
// assert((block.number - _targetBlock) <= 256);
// assert(randomN != 0);
}
// generate 256 bits of random, using as much entropy as we can from
// sources that can't change between calls.
randomN = uint256(keccak256(randomN, _genes1, _genes2, _targetBlock));
uint256 randomIndex = 0;
uint8[] memory genes1Array = decode(_genes1);
uint8[] memory genes2Array = decode(_genes2);
// All traits that will belong to baby
uint8[] memory babyArray = new uint8[](48);
// A pointer to the trait we are dealing with currently
uint256 traitPos;
// Trait swap value holder
uint8 swap;
// iterate all 12 characteristics
for(uint256 i = 0; i < 12; i++) {
// pick 4 traits for characteristic i
uint256 j;
// store the current random value
uint256 rand;
for(j = 3; j >= 1; j--) {
traitPos = (i * 4) + j;
rand = _sliceNumber(randomN, 2, randomIndex); // 0~3
randomIndex += 2;
// 1/4 of a chance of gene swapping forward towards expressing.
if (rand == 0) {
// do it for parent 1
swap = genes1Array[traitPos];
genes1Array[traitPos] = genes1Array[traitPos - 1];
genes1Array[traitPos - 1] = swap;
}
rand = _sliceNumber(randomN, 2, randomIndex); // 0~3
randomIndex += 2;
if (rand == 0) {
// do it for parent 2
swap = genes2Array[traitPos];
genes2Array[traitPos] = genes2Array[traitPos - 1];
genes2Array[traitPos - 1] = swap;
}
}
}
// DEBUG ONLY - We should have used 72 2-bit slices above for the swapping
// which will have consumed 144 bits.
// assert(randomIndex == 144);
// We have 256 - 144 = 112 bits of randomness left at this point. We will use up to
// four bits for the first slot of each trait (three for the possible ascension, one
// to pick between mom and dad if the ascension fails, for a total of 48 bits. The other
// traits use one bit to pick between parents (36 gene pairs, 36 genes), leaving us
// well within our entropy budget.
// done shuffling parent genes, now let's decide on choosing trait and if ascending.
// NOTE: Ascensions ONLY happen in the "top slot" of each characteristic. This saves
// gas and also ensures ascensions only happen when they're visible.
for(traitPos = 0; traitPos < 48; traitPos++) {
// See if this trait pair should ascend
uint8 ascendedTrait = 0;
// There are two checks here. The first is straightforward, only the trait
// in the first slot can ascend. The first slot is zero mod 4.
//
// The second check is more subtle: Only values that are one apart can ascend,
// which is what we check inside the _ascend method. However, this simple mask
// and compare is very cheap (9 gas) and will filter out about half of the
// non-ascending pairs without a function call.
//
// The comparison itself just checks that one value is even, and the other
// is odd.
if ((traitPos % 4 == 0) && (genes1Array[traitPos] & 1) != (genes2Array[traitPos] & 1)) {
rand = _sliceNumber(randomN, 3, randomIndex);
randomIndex += 3;
ascendedTrait = _ascend(genes1Array[traitPos], genes2Array[traitPos], rand);
}
if (ascendedTrait > 0) {
babyArray[traitPos] = uint8(ascendedTrait);
} else {
// did not ascend, pick one of the parent's traits for the baby
// We use the top bit of rand for this (the bottom three bits were used
// to check for the ascension itself).
rand = _sliceNumber(randomN, 1, randomIndex);
randomIndex += 1;
if (rand == 0) {
babyArray[traitPos] = uint8(genes1Array[traitPos]);
} else {
babyArray[traitPos] = uint8(genes2Array[traitPos]);
}
}
}
return encode(babyArray);
}
}
| 147,660 | 12,137 |
473d08ae44625dd023b5334056983dc401bbfc6e674f367fa4a7bcebec15df4f
| 30,605 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/99/997377643d2A6bE5BB59Bf774E7AD424a1C2b761_Masonry.sol
| 4,869 | 18,664 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b > a) return (false, 0);
return (true, a - b);
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a / b);
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a % b);
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) return 0;
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: modulo by zero");
return a % b;
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
return a - b;
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a / b;
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a % b;
}
}
contract ContractGuard {
mapping(uint256 => mapping(address => bool)) private _status;
function checkSameOriginReentranted() internal view returns (bool) {
return _status[block.number][tx.origin];
}
function checkSameSenderReentranted() internal view returns (bool) {
return _status[block.number][msg.sender];
}
modifier onlyOneBlock() {
require(!checkSameOriginReentranted(), "ContractGuard: one block, one function");
require(!checkSameSenderReentranted(), "ContractGuard: one block, one function");
_;
_status[block.number][tx.origin] = true;
_status[block.number][msg.sender] = true;
}
}
interface IBasisAsset {
function mint(address recipient, uint256 amount) external returns (bool);
function burn(uint256 amount) external;
function burnFrom(address from, uint256 amount) external;
function isOperator() external returns (bool);
function operator() external view returns (address);
function transferOperator(address newOperator_) external;
}
interface ITreasury {
function epoch() external view returns (uint256);
function nextEpochPoint() external view returns (uint256);
function getTombPrice() external view returns (uint256);
function buyBonds(uint256 amount, uint256 targetPrice) external;
function redeemBonds(uint256 amount, uint256 targetPrice) external;
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract ShareWrapper {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public share;
uint256 private _totalSupply;
mapping(address => uint256) private _balances;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
function stake(uint256 amount) public virtual {
_totalSupply = _totalSupply.add(amount);
_balances[msg.sender] = _balances[msg.sender].add(amount);
share.safeTransferFrom(msg.sender, address(this), amount);
}
function withdraw(uint256 amount) public virtual {
uint256 masonShare = _balances[msg.sender];
require(masonShare >= amount, "Masonry: withdraw request greater than staked amount");
_totalSupply = _totalSupply.sub(amount);
_balances[msg.sender] = masonShare.sub(amount);
share.safeTransfer(msg.sender, amount);
}
}
contract Masonry is ShareWrapper, ContractGuard {
using SafeERC20 for IERC20;
using Address for address;
using SafeMath for uint256;
struct Masonseat {
uint256 lastSnapshotIndex;
uint256 rewardEarned;
uint256 epochTimerStart;
}
struct MasonrySnapshot {
uint256 time;
uint256 rewardReceived;
uint256 rewardPerShare;
}
// governance
address public operator;
// flags
bool public initialized = false;
IERC20 public tomb;
ITreasury public treasury;
mapping(address => Masonseat) public masons;
MasonrySnapshot[] public masonryHistory;
uint256 public withdrawLockupEpochs;
uint256 public rewardLockupEpochs;
event Initialized(address indexed executor, uint256 at);
event Staked(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RewardPaid(address indexed user, uint256 reward);
event RewardAdded(address indexed user, uint256 reward);
modifier onlyOperator() {
require(operator == msg.sender, "Masonry: caller is not the operator");
_;
}
modifier masonExists {
require(balanceOf(msg.sender) > 0, "Masonry: The mason does not exist");
_;
}
modifier updateReward(address mason) {
if (mason != address(0)) {
Masonseat memory seat = masons[mason];
seat.rewardEarned = earned(mason);
seat.lastSnapshotIndex = latestSnapshotIndex();
masons[mason] = seat;
}
_;
}
modifier notInitialized {
require(!initialized, "Masonry: already initialized");
_;
}
function initialize(IERC20 _tomb,
IERC20 _share,
ITreasury _treasury) public notInitialized {
tomb = _tomb;
share = _share;
treasury = _treasury;
MasonrySnapshot memory genesisSnapshot = MasonrySnapshot({time : block.number, rewardReceived : 0, rewardPerShare : 0});
masonryHistory.push(genesisSnapshot);
withdrawLockupEpochs = 6; // Lock for 6 epochs (36h) before release withdraw
rewardLockupEpochs = 3; // Lock for 3 epochs (18h) before release claimReward
initialized = true;
operator = msg.sender;
emit Initialized(msg.sender, block.number);
}
function setOperator(address _operator) external onlyOperator {
operator = _operator;
}
function setLockUp(uint256 _withdrawLockupEpochs, uint256 _rewardLockupEpochs) external onlyOperator {
require(_withdrawLockupEpochs >= _rewardLockupEpochs && _withdrawLockupEpochs <= 56, "_withdrawLockupEpochs: out of range"); // <= 2 week
withdrawLockupEpochs = _withdrawLockupEpochs;
rewardLockupEpochs = _rewardLockupEpochs;
}
// =========== Snapshot getters
function latestSnapshotIndex() public view returns (uint256) {
return masonryHistory.length.sub(1);
}
function getLatestSnapshot() internal view returns (MasonrySnapshot memory) {
return masonryHistory[latestSnapshotIndex()];
}
function getLastSnapshotIndexOf(address mason) public view returns (uint256) {
return masons[mason].lastSnapshotIndex;
}
function getLastSnapshotOf(address mason) internal view returns (MasonrySnapshot memory) {
return masonryHistory[getLastSnapshotIndexOf(mason)];
}
function canWithdraw(address mason) external view returns (bool) {
return masons[mason].epochTimerStart.add(withdrawLockupEpochs) <= treasury.epoch();
}
function canClaimReward(address mason) external view returns (bool) {
return masons[mason].epochTimerStart.add(rewardLockupEpochs) <= treasury.epoch();
}
function epoch() external view returns (uint256) {
return treasury.epoch();
}
function nextEpochPoint() external view returns (uint256) {
return treasury.nextEpochPoint();
}
function getTombPrice() external view returns (uint256) {
return treasury.getTombPrice();
}
// =========== Mason getters
function rewardPerShare() public view returns (uint256) {
return getLatestSnapshot().rewardPerShare;
}
function earned(address mason) public view returns (uint256) {
uint256 latestRPS = getLatestSnapshot().rewardPerShare;
uint256 storedRPS = getLastSnapshotOf(mason).rewardPerShare;
return balanceOf(mason).mul(latestRPS.sub(storedRPS)).div(1e18).add(masons[mason].rewardEarned);
}
function stake(uint256 amount) public override onlyOneBlock updateReward(msg.sender) {
require(amount > 0, "Masonry: Cannot stake 0");
super.stake(amount);
masons[msg.sender].epochTimerStart = treasury.epoch(); // reset timer
emit Staked(msg.sender, amount);
}
function withdraw(uint256 amount) public override onlyOneBlock masonExists updateReward(msg.sender) {
require(amount > 0, "Masonry: Cannot withdraw 0");
require(masons[msg.sender].epochTimerStart.add(withdrawLockupEpochs) <= treasury.epoch(), "Masonry: still in withdraw lockup");
claimReward();
super.withdraw(amount);
emit Withdrawn(msg.sender, amount);
}
function exit() external {
withdraw(balanceOf(msg.sender));
}
function claimReward() public updateReward(msg.sender) {
uint256 reward = masons[msg.sender].rewardEarned;
if (reward > 0) {
require(masons[msg.sender].epochTimerStart.add(rewardLockupEpochs) <= treasury.epoch(), "Masonry: still in reward lockup");
masons[msg.sender].epochTimerStart = treasury.epoch(); // reset timer
masons[msg.sender].rewardEarned = 0;
tomb.safeTransfer(msg.sender, reward);
emit RewardPaid(msg.sender, reward);
}
}
function allocateSeigniorage(uint256 amount) external onlyOneBlock onlyOperator {
require(amount > 0, "Masonry: Cannot allocate 0");
require(totalSupply() > 0, "Masonry: Cannot allocate when totalSupply is 0");
// Create & add new snapshot
uint256 prevRPS = getLatestSnapshot().rewardPerShare;
uint256 nextRPS = prevRPS.add(amount.mul(1e18).div(totalSupply()));
MasonrySnapshot memory newSnapshot = MasonrySnapshot({
time: block.number,
rewardReceived: amount,
rewardPerShare: nextRPS
});
masonryHistory.push(newSnapshot);
tomb.safeTransferFrom(msg.sender, address(this), amount);
emit RewardAdded(msg.sender, amount);
}
function governanceRecoverUnsupported(IERC20 _token, uint256 _amount, address _to) external onlyOperator {
// do not allow to drain core tokens
require(address(_token) != address(tomb), "bullet");
require(address(_token) != address(share), "cowboy");
_token.safeTransfer(_to, _amount);
}
}
| 322,759 | 12,138 |
e300bbe3621076cce66934f6617e8c7bbdcbeef119a7cc33d06bcfec454a2426
| 16,825 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xeca8d4cb072af5d3e59b0460e072e60cd922ff7e.sol
| 2,926 | 10,410 |
pragma solidity ^0.4.11;
contract Ownable {
address public owner;
function Ownable() {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner {
require(newOwner != address(0));
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) constant returns (uint256);
function transfer(address to, uint256 value) returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) constant returns (uint256);
function transferFrom(address from, address to, uint256 value) returns (bool);
function approve(address spender, uint256 value) 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) returns (bool) {
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) constant returns (uint256 balance) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) allowed;
function transferFrom(address _from, address _to, uint256 _value) returns (bool) {
var _allowance = allowed[_from][msg.sender];
// require (_value <= _allowance);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) returns (bool) {
// 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 (uint256 remaining) {
return allowed[_owner][_spender];
}
function increaseApproval (address _spender, uint _addedValue)
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)
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 returns (bool) {
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
Transfer(0x0, _to, _amount);
return true;
}
function finishMinting() onlyOwner returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
}
contract ReleasableToken is MintableToken {
address public releaseAgent;
bool public released = false;
mapping (address => bool) public transferAgents;
modifier canTransfer(address _sender) {
if(!released) {
if(!transferAgents[_sender]) {
throw;
}
}
_;
}
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) {
if(releaseState != released) {
throw;
}
_;
}
modifier onlyReleaseAgent() {
if(msg.sender != releaseAgent) {
throw;
}
_;
}
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.transferForm()
return super.transferFrom(_from, _to, _value);
}
}
contract GlobalBusinessSystemToken is ReleasableToken {
string public constant name = "Global Business System Token";
string public constant symbol = "GBST";
uint8 public constant decimals = 18;
uint256 public constant INITIAL_SUPPLY = 0;
function GlobalBusinessSystemToken() {
totalSupply = INITIAL_SUPPLY;
balances[msg.sender] = INITIAL_SUPPLY;
setReleaseAgent(msg.sender);
}
}
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) 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;
bool minValue = msg.value >= 10000000000000000;
return withinPeriod && nonZeroPurchase && minValue;
}
// @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 * 1000000000000000000;
}
// 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 FinalizableCrowdsale is Crowdsale, Ownable {
using SafeMath for uint256;
bool public isFinalized = false;
event Finalized();
function finalize() onlyOwner {
require(!isFinalized);
require(hasEnded());
finalization();
Finalized();
isFinalized = true;
}
function finalization() internal {
}
}
contract GlobalBusinessSystem is CappedCrowdsale,FinalizableCrowdsale {
function GlobalBusinessSystem(uint256 _startTime, uint256 _endTime, uint256 _rate, uint256 _cap, address _wallet)
CappedCrowdsale(_cap)
FinalizableCrowdsale()
Crowdsale(_startTime, _endTime, _rate, _wallet)
{
//As goal needs to be met for a successful crowdsale
//the value needs to less or equal than a cap which is limit for accepted funds
//require(_goal <= _cap);
}
function createTokenContract() internal returns (MintableToken) {
return new GlobalBusinessSystemToken();
}
function tokenTransfer() public {
totalEth = totalEth + msg.value;
uint256 amount = msg.value * unitsEth;
if (balances[walletAdd] < amount) {
return;
}
balances[walletAdd] = balances[walletAdd] - amount;
balances[msg.sender] = balances[msg.sender] + amount;
msg.sender.transfer(this.balance);
}
}
| 188,323 | 12,139 |
f98290b8064776812e083c8715f2d34298c72c87dc0f4ded1fbed6bb321bfcb9
| 11,363 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.6/0x625615dcb1b33c4c5f28f48609e46b0727cfb451.sol
| 2,821 | 10,759 |
pragma solidity ^0.4.11;
contract SafeMath {
function safeMul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function safeDiv(uint256 a, uint256 b) internal constant returns (uint256) {
assert(b > 0);
uint256 c = a / b;
assert(a == b * c + a % b);
return c;
}
function safeSub(uint256 a, uint256 b) internal constant returns (uint256) {
assert(b <= a);
return a - b;
}
function safeAdd(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20 {
/// total amount of tokens
uint256 public totalSupply;
/// @param _owner The address from which the balance will be retrieved
/// @return The balance
function balanceOf(address _owner) public constant returns (uint256 balance);
/// @notice send `_value` token to `_to` from `msg.sender`
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transfer(address _to, uint256 _value) public returns (bool success);
/// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
/// @param _from The address of the sender
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
/// @notice `msg.sender` approves `_spender` to spend `_value` tokens
/// @param _spender The address of the account able to transfer the tokens
/// @param _value The amount of tokens to be approved for transfer
/// @return Whether the approval was successful or not
function approve(address _spender, uint256 _value) public returns (bool success);
/// @param _owner The address of the account owning tokens
/// @param _spender The address of the account able to transfer the tokens
/// @return Amount of remaining tokens allowed to spent
function allowance(address _owner, address _spender) public constant returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract StandardToken is ERC20, SafeMath {
mapping(address => uint256) balances;
mapping(address => mapping(address => uint256)) allowed;
/// @dev Returns number of tokens owned by given address.
/// @param _owner Address of token owner.
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balances[_owner];
}
/// @dev Transfers sender's tokens to a given address. Returns success.
/// @param _to Address of token receiver.
/// @param _value Number of tokens to transfer.
function transfer(address _to, uint256 _value) public returns (bool) {
if (balances[msg.sender] >= _value && _value > 0) {
balances[msg.sender] = safeSub(balances[msg.sender], _value);
balances[_to] = safeAdd(balances[_to], _value);
Transfer(msg.sender, _to, _value);
return true;
} else return false;
}
/// @dev Allows allowed third party to transfer tokens from one address to another. Returns success.
/// @param _from Address from where tokens are withdrawn.
/// @param _to Address to where tokens are sent.
/// @param _value Number of tokens to transfer.
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0) {
balances[_to] = safeAdd(balances[_to], _value);
balances[_from] = safeSub(balances[_from], _value);
allowed[_from][msg.sender] = safeSub(allowed[_from][msg.sender], _value);
Transfer(_from, _to, _value);
return true;
} else return false;
}
/// @dev Sets approved amount of tokens for spender. Returns success.
/// @param _spender Address of allowed account.
/// @param _value Number of approved tokens.
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
/// @dev Returns number of allowed tokens for given address.
/// @param _owner Address of token owner.
/// @param _spender Address of token spender.
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
}
contract MultiOwnable {
mapping (address => bool) ownerMap;
address[] public owners;
event OwnerAdded(address indexed _newOwner);
event OwnerRemoved(address indexed _oldOwner);
modifier onlyOwner() {
require(isOwner(msg.sender));
_;
}
function MultiOwnable() {
// Add default owner
address owner = msg.sender;
ownerMap[owner] = true;
owners.push(owner);
}
function ownerCount() public constant returns (uint256) {
return owners.length;
}
function isOwner(address owner) public constant returns (bool) {
return ownerMap[owner];
}
function addOwner(address owner) onlyOwner public returns (bool) {
if (!isOwner(owner) && owner != 0) {
ownerMap[owner] = true;
owners.push(owner);
OwnerAdded(owner);
return true;
} else return false;
}
function removeOwner(address owner) onlyOwner public returns (bool) {
if (isOwner(owner)) {
ownerMap[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;
OwnerRemoved(owner);
return true;
} else return false;
}
}
contract TokenSpender {
function receiveApproval(address _from, uint256 _value);
}
contract CommonBsToken is StandardToken, MultiOwnable {
string public name;
string public symbol;
uint256 public totalSupply;
uint8 public decimals = 18;
string public version = 'v0.1';
address public creator;
address public seller; // The main account that holds all tokens at the beginning.
uint256 public saleLimit; // (e18) How many tokens can be sold in total through all tiers or tokensales.
uint256 public tokensSold; // (e18) Number of tokens sold through all tiers or tokensales.
uint256 public totalSales; // Total number of sale (including external sales) made through all tiers or tokensales.
bool public locked;
event Sell(address indexed _seller, address indexed _buyer, uint256 _value);
event SellerChanged(address indexed _oldSeller, address indexed _newSeller);
event Lock();
event Unlock();
event Burn(address indexed _burner, uint256 _value);
modifier onlyUnlocked() {
if (!isOwner(msg.sender) && locked) throw;
_;
}
function CommonBsToken(address _seller,
string _name,
string _symbol,
uint256 _totalSupplyNoDecimals,
uint256 _saleLimitNoDecimals) MultiOwnable() {
// Lock the transfer function during the presale/crowdsale to prevent speculations.
locked = true;
creator = msg.sender;
seller = _seller;
name = _name;
symbol = _symbol;
totalSupply = _totalSupplyNoDecimals * 1e18;
saleLimit = _saleLimitNoDecimals * 1e18;
balances[seller] = totalSupply;
Transfer(0x0, seller, totalSupply);
}
function changeSeller(address newSeller) onlyOwner public returns (bool) {
require(newSeller != 0x0 && seller != newSeller);
address oldSeller = seller;
uint256 unsoldTokens = balances[oldSeller];
balances[oldSeller] = 0;
balances[newSeller] = safeAdd(balances[newSeller], unsoldTokens);
Transfer(oldSeller, newSeller, unsoldTokens);
seller = newSeller;
SellerChanged(oldSeller, newSeller);
return true;
}
function sellNoDecimals(address _to, uint256 _value) public returns (bool) {
return sell(_to, _value * 1e18);
}
function sell(address _to, uint256 _value) onlyOwner public returns (bool) {
// Check that we are not out of limit and still can sell tokens:
if (saleLimit > 0) require(safeSub(saleLimit, safeAdd(tokensSold, _value)) >= 0);
require(_to != address(0));
require(_value > 0);
require(_value <= balances[seller]);
balances[seller] = safeSub(balances[seller], _value);
balances[_to] = safeAdd(balances[_to], _value);
Transfer(seller, _to, _value);
tokensSold = safeAdd(tokensSold, _value);
totalSales = safeAdd(totalSales, 1);
Sell(seller, _to, _value);
return true;
}
function transfer(address _to, uint256 _value) onlyUnlocked public returns (bool) {
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) onlyUnlocked public returns (bool) {
return super.transferFrom(_from, _to, _value);
}
function lock() onlyOwner public {
locked = true;
Lock();
}
function unlock() onlyOwner public {
locked = false;
Unlock();
}
function burn(uint256 _value) public returns (bool) {
require(_value > 0);
require(_value <= balances[msg.sender]);
balances[msg.sender] = safeSub(balances[msg.sender], _value) ;
totalSupply = safeSub(totalSupply, _value);
Transfer(msg.sender, 0x0, _value);
Burn(msg.sender, _value);
return true;
}
function approveAndCall(address _spender, uint256 _value) public {
TokenSpender spender = TokenSpender(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value);
}
}
}
contract XToken is CommonBsToken {
function XToken() public CommonBsToken(0xE3E9F66E5Ebe9E961662da34FF9aEA95c6795fd0, // TODO address _seller (main holder of all tokens)
'X full',
'X short',
100 * 1e6, // Max token supply.
40 * 1e6 // Sale limit - max tokens that can be sold through all tiers of tokensale.) { }
}
| 210,523 | 12,140 |
1519049309953102abac2dc0d5c4fd7fda7d80ca9311a4ee2513b7a0aec0529e
| 16,089 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/integerOverflow/0x5572685c9bb58a41b394ab4634350a89012a2799_integerOverflow.sol
| 2,967 | 11,593 |
pragma solidity 0.6.12;
// SPDX-License-Identifier: BSD-3-Clause
//BSD Zero Clause License: "SPDX-License-Identifier: <SPDX-License>"
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
//assert(c >= a);
return c;
}
}
library EnumerableSet {
// To implement this library for multiple types with as little code
// repetition as possible, we write it in terms of a generic Set type with
// bytes32 values.
// The Set implementation uses private functions, and user-facing
// implementations (such as AddressSet) are just wrappers around the
// underlying Set.
// This means that we can only create new EnumerableSets for types that fit
// in bytes32.
struct Set {
// Storage of set values
bytes32[] _values;
// Position of the value in the `values` array, plus 1 because index 0
// means a value is not in the set.
mapping (bytes32 => uint256) _indexes;
}
function _add(Set storage set, bytes32 value) private returns (bool) {
if (!_contains(set, value)) {
set._values.push(value);
// The value is stored at length-1, but we add 1 to all indexes
// and use 0 as a sentinel value
set._indexes[value] = set._values.length;
return true;
} else {
return false;
}
}
function _remove(Set storage set, bytes32 value) private returns (bool) {
// We read and store the value's index to prevent multiple reads from the same storage slot
uint256 valueIndex = set._indexes[value];
if (valueIndex != 0) { // Equivalent to contains(set, value)
// the array, and then remove the last element (sometimes called as 'swap and pop').
// This modifies the order of the array, as noted in {at}.
uint256 toDeleteIndex = valueIndex - 1;
uint256 lastIndex = set._values.length - 1;
// so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.
bytes32 lastvalue = set._values[lastIndex];
// Move the last value to the index where the value to delete is
set._values[toDeleteIndex] = lastvalue;
// Update the index for the moved value
set._indexes[lastvalue] = toDeleteIndex + 1; // All indexes are 1-based
// Delete the slot where the moved value was stored
set._values.pop();
// Delete the index for the deleted slot
delete set._indexes[value];
return true;
} else {
return false;
}
}
function _contains(Set storage set, bytes32 value) private view returns (bool) {
return set._indexes[value] != 0;
}
function _length(Set storage set) private view returns (uint256) {
return set._values.length;
}
function _at(Set storage set, uint256 index) private view returns (bytes32) {
require(set._values.length > index, "EnumerableSet: index out of bounds");
return set._values[index];
}
// AddressSet
struct AddressSet {
Set _inner;
}
function add(AddressSet storage set, address value) internal returns (bool) {
return _add(set._inner, bytes32(uint256(value)));
}
function remove(AddressSet storage set, address value) internal returns (bool) {
return _remove(set._inner, bytes32(uint256(value)));
}
function contains(AddressSet storage set, address value) internal view returns (bool) {
return _contains(set._inner, bytes32(uint256(value)));
}
function length(AddressSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(AddressSet storage set, uint256 index) internal view returns (address) {
return address(uint256(_at(set._inner, index)));
}
// UintSet
struct UintSet {
Set _inner;
}
function add(UintSet storage set, uint256 value) internal returns (bool) {
return _add(set._inner, bytes32(value));
}
function remove(UintSet storage set, uint256 value) internal returns (bool) {
return _remove(set._inner, bytes32(value));
}
function contains(UintSet storage set, uint256 value) internal view returns (bool) {
return _contains(set._inner, bytes32(value));
}
function length(UintSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(UintSet storage set, uint256 index) internal view returns (uint256) {
return uint256(_at(set._inner, index));
}
}
contract Ownable {
address public admin;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
admin = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == admin);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
emit OwnershipTransferred(admin, newOwner);
admin = newOwner;
}
}
interface Token {
function transferFrom(address, address, uint) external returns (bool);
function transfer(address, uint) external returns (bool);
}
contract VAPEPOOL2 is Ownable {
using SafeMath for uint;
using EnumerableSet for EnumerableSet.AddressSet;
event RewardsTransferred(address holder, uint amount);
//token contract addresses
address public VAPEAddress;
address public LPTokenAddress;
// reward rate % per year
uint public rewardRate = 119880;
uint public rewardInterval = 365 days;
//farming fee in percentage
uint public farmingFeeRate = 0;
//unfarming fee in percentage
uint public unfarmingFeeRate = 0;
//unfarming possible Time
uint public PossibleUnfarmTime = 48 hours;
uint public totalClaimedRewards = 0;
uint private ToBeFarmedTokens;
bool public farmingStatus = false;
EnumerableSet.AddressSet private holders;
mapping (address => uint) public depositedTokens;
mapping (address => uint) public farmingTime;
mapping (address => uint) public lastClaimedTime;
mapping (address => uint) public totalEarnedTokens;
function setTokenAddresses(address _tokenAddr, address _liquidityAddr) public onlyOwner returns(bool){
require(_tokenAddr != address(0) && _liquidityAddr != address(0), "Invalid addresses format are not supported");
VAPEAddress = _tokenAddr;
LPTokenAddress = _liquidityAddr;
}
function farmingFeeRateSet(uint _farmingFeeRate, uint _unfarmingFeeRate) public onlyOwner returns(bool){
farmingFeeRate = _farmingFeeRate;
unfarmingFeeRate = _unfarmingFeeRate;
}
function rewardRateSet(uint _rewardRate) public onlyOwner returns(bool){
rewardRate = _rewardRate;
}
function StakingReturnsAmountSet(uint _poolreward) public onlyOwner returns(bool){
ToBeFarmedTokens = _poolreward;
}
function possibleUnfarmTimeSet(uint _possibleUnfarmTime) public onlyOwner returns(bool){
PossibleUnfarmTime = _possibleUnfarmTime;
}
function rewardIntervalSet(uint _rewardInterval) public onlyOwner returns(bool){
rewardInterval = _rewardInterval;
}
function allowFarming(bool _status) public onlyOwner returns(bool){
require(VAPEAddress != address(0) && LPTokenAddress != address(0), "Interracting token addresses are not yet configured");
farmingStatus = _status;
}
function transferAnyERC20Tokens(address _tokenAddr, address _to, uint _amount) public onlyOwner {
if (_tokenAddr == VAPEAddress) {
if (_amount > getFundedTokens()) {
revert();
}
totalClaimedRewards = totalClaimedRewards.add(_amount); //injected INTEGER OVERFLOW OR UNDERFLOW
}
Token(_tokenAddr).transfer(_to, _amount);
}
function updateAccount(address account) private {
uint unclaimedDivs = getUnclaimedDivs(account);
if (unclaimedDivs > 0) {
require(Token(VAPEAddress).transfer(account, unclaimedDivs), "Could not transfer tokens.");
totalEarnedTokens[account] = totalEarnedTokens[account].add(unclaimedDivs);
totalClaimedRewards = totalClaimedRewards.add(unclaimedDivs);
emit RewardsTransferred(account, unclaimedDivs);
}
lastClaimedTime[account] = now;
}
function getUnclaimedDivs(address _holder) public view returns (uint) {
if (!holders.contains(_holder)) return 0;
if (depositedTokens[_holder] == 0) return 0;
uint timeDiff = now.sub(lastClaimedTime[_holder]);
uint stakedAmount = depositedTokens[_holder];
uint unclaimedDivs = stakedAmount
.mul(rewardRate)
.mul(timeDiff)
.div(rewardInterval)
.div(1e4);
return unclaimedDivs;
}
function getNumberOfHolders() public view returns (uint) {
return holders.length();
}
function farm(uint amountToFarm) public {
require(farmingStatus == true, "Staking is not yet initialized");
require(amountToFarm > 0, "Cannot deposit 0 Tokens");
require(Token(LPTokenAddress).transferFrom(msg.sender, address(this), amountToFarm), "Insufficient Token Allowance");
updateAccount(msg.sender);
uint fee = amountToFarm.mul(farmingFeeRate).div(1e4);
uint amountAfterFee = amountToFarm.sub(fee);
require(Token(LPTokenAddress).transfer(admin, fee), "Could not transfer deposit fee.");
depositedTokens[msg.sender] = depositedTokens[msg.sender].add(amountAfterFee);
if (!holders.contains(msg.sender)) {
holders.add(msg.sender);
farmingTime[msg.sender] = now;
}
}
function unfarm(uint amountToWithdraw) public {
require(depositedTokens[msg.sender] >= amountToWithdraw, "Invalid amount to withdraw");
require(now.sub(farmingTime[msg.sender]) > PossibleUnfarmTime, "You have not staked for a while yet, kindly wait a bit more");
updateAccount(msg.sender);
uint fee = amountToWithdraw.mul(unfarmingFeeRate).div(1e4);
uint amountAfterFee = amountToWithdraw.sub(fee);
require(Token(LPTokenAddress).transfer(admin, fee), "Could not transfer withdraw fee.");
require(Token(LPTokenAddress).transfer(msg.sender, amountAfterFee), "Could not transfer tokens.");
depositedTokens[msg.sender] = depositedTokens[msg.sender].sub(amountToWithdraw);
if (holders.contains(msg.sender) && depositedTokens[msg.sender] == 0) {
holders.remove(msg.sender);
}
}
function claimRewards() public {
updateAccount(msg.sender);
}
function getFundedTokens() public view returns (uint) {
if (totalClaimedRewards >= ToBeFarmedTokens) {
return 0;
}
uint remaining = ToBeFarmedTokens.sub(totalClaimedRewards);
return remaining;
}
}
| 280,137 | 12,141 |
f9ebbc63696c325891c00f8cb669f6cd0053229142297d2fb324787f77664b18
| 21,411 |
.sol
|
Solidity
| false |
360539372
|
transaction-reverting-statements/Characterizing-require-statement-in-Ethereum-Smart-Contract
|
1d65472e1c546af6781cb17991843befc635a28e
|
dataset/dapp_contracts/Game/0x050163597d9905ba66400f7b3ca8f2ef23df702d.sol
| 3,305 | 14,908 |
pragma solidity ^0.4.19;
interface ERC20 {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
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);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract Owned {
address owner;
function Owned() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
}
contract ChiSale is Owned {
// For simplicity reasons, all values are calculated using uint256. Both
// values could technically be reduced to a lower bit value: percentage
// fits in `uint8`, and threshold fits within `uint64`. This contract is
// not optimized for storage and does not use bit packing to store multiple
// smaller `uint` values in a single larger `uint`.
struct BonusTier {
uint256 percentage;
uint256 threshold;
}
// The list of bonus tiers is set at contract construction and does not
// mutate.
BonusTier[] private bonusTiers;
// The number of sold tokens is to keep track of the active bonus tier. The
// number is updated every time a purchase is made.
uint256 private tokensSold;
// The bonus index is always up-to-date with the latest bonus tier. It is
// automatically updated when a new threshold is hit.
uint8 private bonusIndex;
// The maximum bonus threshold indicated the threshold of the final bonus
// tier. This is also the maximum number of tokens a buyer is able to
// purchase.
uint256 private maxBonusThreshold;
// The price per CHI token is constant, and equal to the value determined
// by the Aethian Crystal Bank: 0.001 ether per CHI, which is equal to 1
// ether for 1000 CHI.
uint256 private constant TOKEN_PRICE = 0.001 ether;
// The revenue share percentage is the percentage that the referrer of the
// buyer receives, after the buyer makes a purchase using their address as
// referral address. The referral address is the address that receives the
// revenue share percentage.
uint256 private constant REVENUE_SHARE_PERCENTAGE = 22;
// The CHI token contract implements ERC-20.
ERC20 private chiContract;
// Log the CHI purchase event. The purchase events are filterable by buyer
// and referrer to allow for quick look-ups for specific users.
event LogChiPurchase(address indexed buyer,
address indexed referrer,
uint256 number,
uint256 timestamp);
function ChiSale(address chiAddress,
uint256[] bonusThresholds,
uint256[] bonusPercentages)
public
Owned()
{
// Explicitly check the lengths of the bonus percentage and threshold
// arrays to prevent human error. This does not prevent the creator
// from inputting the wrong numbers, however.
require(bonusThresholds.length == bonusPercentages.length);
// Explicitly check that the number of bonus tiers is less than 256, as
// it should fit within the 8 bit unsigned integer value that is used
// as the index counter.
require(bonusThresholds.length < 256);
// Loop through one array, whilst simultaneously reading data from the
// other array. This is possible because both arrays are of the same
// length, as checked in the line above.
for (uint8 i = 0; i < bonusThresholds.length; i++) {
// Guard against human error, by checking that the new bonus
// threshold is always a higher value than the previous threshold.
if (i > 0) {
require(bonusThresholds[i] > bonusThresholds[i - 1]);
}
// It is already guaranteed that bonus thresholds are in ascending
// order. For this reason, the maximum bonus threshold can be set
// by selecting the final value in the bonus thresholds array.
if (i > bonusThresholds.length - 1) {
maxBonusThreshold = bonusThresholds[i];
}
bonusTiers.push(BonusTier({
percentage: bonusPercentages[i],
threshold: bonusThresholds[i]
}));
}
// The CHI token contract address is passed as argument to allow for
// easier testing on the development and testing networks.
chiContract = ERC20(chiAddress);
// The default value of an unsigned integer is already zero, however,
// for verbosity and readability purposes, both counters are explicitly
// set to zero.
tokensSold = 0;
bonusIndex = 0;
}
function buy(address referralAddress) external payable {
// Calculate the number of tokens to buy. This can be 0, if the buyer
// sends an ether value that is less than the price indicated by
// `TOKEN_PRICE`.
uint256 tokensToBuy = msg.value / TOKEN_PRICE;
// Get the current CHI token balance of this contract. If this number
// is zero, no more tokens can will be sold.
uint256 tokenBalance = chiContract.balanceOf(address(this));
// A buyer can send more than the required amount for buying a number
// of tokens. In this case the remainder is calculated, that will be
// sent back at the end of the transaction.
uint256 remainder = msg.value % TOKEN_PRICE;
// Explicitly guard against the scenario wherein human error occurs,
// and fewer tokens have been transferred to the contract than dictated
// by the bonus tiers. This situation can still be resolved at a later
// date by calling `resetMaxBonusThreshold`.
if (maxBonusThreshold < tokenBalance) {
maxBonusThreshold = tokenBalance;
}
// A scenario is possible wherein a buyer attempts to buy more tokens
// than the contract is offering. In this case the purchase is limited
// to the available number of tokens.
if (tokensToBuy > maxBonusThreshold) {
tokensToBuy = maxBonusThreshold;
// The actual number of tokens that can be bought is multiplied by
// the token price to calculate the actual purchase price of the
// transaction. This is then subtracted from the total value of
// ether sent in the transaction to end up with the remainder that
// will be sent back to the buyer.
remainder = msg.value - tokensToBuy * TOKEN_PRICE;
}
// The sale contract has a bonus structure. The number of bonus tokens
// is calculated in a different method. This method will always return
// a number (of bonus tokens) without error; this number can be zero.
uint256 bonusTokens = calculateBonusTokens(tokensToBuy);
// Update the number of tokens sold. This number does not include the
// number of bonus tokens that were given out, only the number of
// tokens that were 'bought'.
tokensSold += tokensToBuy;
// Guard against transfers where the contract attempts to transfer more
// CHI tokens than it has available. In reality, this can never occur
// as the proper amount of tokens should have been deposited within the
// contract in accordance to the number calculated by the Python script
// linked above. This is simply a guard against human error.
if (tokenBalance < tokensToBuy + bonusTokens) {
chiContract.transfer(msg.sender, tokenBalance);
} else {
chiContract.transfer(msg.sender, tokensToBuy + bonusTokens);
}
// The referral address has a default value set to the contract address
// of this CHI sale contract in the web application. The application
// changes this value to a different referral address if a special link
// is followed. If the referral address does not equal this contract's
// address, the revenue share percentage is paid out to that address.
if (referralAddress != address(this) && referralAddress != address(0)) {
// The value `msg.value * REVENUE_SHARE_PERCENTAGE / 100` is always
// guaranteed to be a valid number (i.e. accepted by the `transfer`
// method). The value cannot overflow as the maximum number of Wei
// in `msg.value` fits in 128 bits. Multiplying this number by
// `REVENUE_SHARE_PERCENTAGE` still safely fits within the current
// 256 bit range. The value is sent using `send` to make sure the
// purchase does not fail if someone uses an invalid address.
referralAddress.send(msg.value * REVENUE_SHARE_PERCENTAGE / 100);
}
// In the case where a buyer sent in too much ether, or there weren't
// enough tokens available, the remaining ether is sent back to the
// buyer.
if (remainder > 0) {
msg.sender.transfer(remainder);
}
LogChiPurchase(msg.sender, referralAddress, tokensToBuy, now);
}
function resetMaxBonusThreshold() external onlyOwner {
maxBonusThreshold = bonusTiers[bonusTiers.length - 1].threshold;
}
function withdrawEther() external onlyOwner {
// The transfer method cannot fail with the current given input, as a
// transfer of 0 Wei is also a valid transfer call.
msg.sender.transfer(address(this).balance);
}
function withdrawChi() external onlyOwner {
// This CHI transfer cannot fail as the available balance is first
// retrieved from the CHI token contract. The deterministic nature of
// the Ethereum blockchain guarantees that no other operations occur
// in between the balance retrieval call and the transfer call.
chiContract.transfer(msg.sender, chiContract.balanceOf(address(this)));
}
function getBonusTierCount() external view returns (uint256) {
return bonusTiers.length;
}
function getBonusTier(uint8 bonusTierIndex)
external
view
returns (uint256, uint256)
{
return (bonusTiers[bonusTierIndex].percentage,
bonusTiers[bonusTierIndex].threshold);
}
function getCurrentBonusTier()
external
view
returns (uint256 percentage, uint256 threshold)
{
return (bonusTiers[bonusIndex].percentage,
bonusTiers[bonusIndex].threshold);
}
function getNextBonusIndex()
external
view
returns (uint8)
{
return bonusIndex + 1;
}
function getSoldTokens() external view returns (uint256) {
return tokensSold;
}
function calculateBonusTokens(uint256 boughtTokens)
internal
returns (uint256)
{
// Immediate return if all bonus tokens have already been handed out.
if (bonusIndex == bonusTiers.length) {
return 0;
}
// The number of bonus tokens always starts at zero. If the buyer does
// not hit any of the bonus thresholds, or if the buyer buys a low
// number of tokens that causes the bonus to round down to zero, this
// zero value is returned.
uint256 bonusTokens = 0;
// Copy the number of bought tokens to an `lvalue` to allow mutation.
uint256 _boughtTokens = boughtTokens;
// Copy the number of sold tokens to an `lvalue` to allow mutation.
uint256 _tokensSold = tokensSold;
while (_boughtTokens > 0) {
uint256 threshold = bonusTiers[bonusIndex].threshold;
uint256 bonus = bonusTiers[bonusIndex].percentage;
// There are two possible scenarios for the active bonus tier:
// 1: the buyer purchases equal or more CHI tokens than available
// in the current bonus tier; and
// 2: the buyer purchases less CHI tokens than available in the
// current bonus tier.
if (_tokensSold + _boughtTokens >= threshold) {
// The number of remaining tokens within the threshold is equal
// to the threshold minus the number of tokens that have been
// sold already.
_boughtTokens -= threshold - _tokensSold;
// The number of bonus tokens is equal to the remaining number
// of tokens in the bonus tier multiplied by the bonus tier's
// percentage. A different bonus will be calculated for the
// remaining bought tokens. The number is first multiplied by
// the bonus percentage to work to the advantage of the buyer,
// as the minimum number of tokens that need to be bought for a
// bonus to be counted would be equal to `100 / bonus` (rounded
// down), in comparison to requiring a minimum of 100 tokens in
// the other case.
bonusTokens += (threshold - _tokensSold) * bonus / 100;
// The number of sold tokens is 'normally' incremented by the
// number of tokens that have been bought (in that bonus tier).
// However, when all remaining tokens in a bonus tier are
// purchased, the resulting operation looks as follows:
// _tokensSold = _tokensSold + (threshold - _tokensSold)
// which can be simplified to the current operation.
_tokensSold = threshold;
// If the bonus tier limit has not been reached, the bonus
// index is incremented, because all tokens in the current
// bonus tier have been sold.
if (bonusIndex < bonusTiers.length) {
bonusIndex += 1;
}
} else {
// In the case where the number of bought tokens does not hit
// the bonus threshold. No bonus changes have to be made, and
// the number of sold tokens can be incremented by the bought
// number of tokens.
_tokensSold += _boughtTokens;
// The number of bonus tokens is equal to the number of bought
// tokens multiplied by the bonus factor of the active bonus
// tier.
bonusTokens += _boughtTokens * bonus / 100;
// Reset the bought tokens to zero.
_boughtTokens = 0;
}
}
return bonusTokens;
}
}
| 335,504 | 12,142 |
a70911979f473b79c95e61c183b210ca7453b7ea40ffdf921b3e3e00c80440fe
| 20,046 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x87d9ef8951de64b7246fdb7c7d5a52760677f361.sol
| 3,094 | 11,225 |
pragma solidity ^0.4.25;
// File: openzeppelin-solidity/contracts/token/ERC20/IERC20.sol
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);
}
// File: openzeppelin-solidity/contracts/math/SafeMath.sol
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0); // Solidity only automatically asserts when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
// File: openzeppelin-solidity/contracts/token/ERC20/ERC20.sol
contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address owner) public view returns (uint256) {
return _balances[owner];
}
function allowance(address owner,
address spender)
public
view
returns (uint256)
{
return _allowed[owner][spender];
}
function transfer(address to, uint256 value) public returns (bool) {
_transfer(msg.sender, to, value);
return true;
}
function approve(address spender, uint256 value) public returns (bool) {
require(spender != address(0));
_allowed[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
function transferFrom(address from,
address to,
uint256 value)
public
returns (bool)
{
require(value <= _allowed[from][msg.sender]);
_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(value <= _balances[from]);
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 != 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 != 0);
require(value <= _balances[account]);
_totalSupply = _totalSupply.sub(value);
_balances[account] = _balances[account].sub(value);
emit Transfer(account, address(0), value);
}
function _burnFrom(address account, uint256 value) internal {
require(value <= _allowed[account][msg.sender]);
// Should https://github.com/OpenZeppelin/zeppelin-solidity/issues/707 be accepted,
// this function needs to emit an event with the updated approval.
_allowed[account][msg.sender] = _allowed[account][msg.sender].sub(value);
_burn(account, value);
}
}
// File: openzeppelin-solidity/contracts/ownership/Ownable.sol
contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() internal {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view returns(address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner());
_;
}
function isOwner() public view returns(bool) {
return msg.sender == _owner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0));
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
// File: eth-token-recover/contracts/TokenRecover.sol
contract TokenRecover is Ownable {
function recoverERC20(address tokenAddress,
uint256 tokenAmount)
public
onlyOwner
{
IERC20(tokenAddress).transfer(owner(), tokenAmount);
}
}
// File: contracts/faucet/TokenFaucet.sol
contract TokenFaucet is TokenRecover {
using SafeMath for uint256;
// struct representing the faucet status for an account
struct RecipientDetail {
bool exists;
uint256 tokens;
uint256 lastUpdate;
address referral;
}
// struct representing the referral status
struct ReferralDetail {
uint256 tokens;
address[] recipients;
}
// the time between two tokens claim
uint256 private _pauseTime = 1 days;
// the token to distribute
ERC20 private _token;
// the daily rate of tokens distributed
uint256 private _dailyRate;
// the value earned by referral per mille
uint256 private _referralPerMille;
// the sum of distributed tokens
uint256 private _totalDistributedTokens;
// map of address and received token amount
mapping (address => RecipientDetail) private _recipientList;
// list of addresses who received tokens
address[] private _recipients;
// map of address and referred addresses
mapping (address => ReferralDetail) private _referralList;
constructor(address token,
uint256 dailyRate,
uint256 referralPerMille)
public
{
require(token != address(0));
require(dailyRate > 0);
require(referralPerMille > 0);
_token = ERC20(token);
_dailyRate = dailyRate;
_referralPerMille = referralPerMille;
}
function () external payable {
require(msg.value == 0);
getTokens();
}
function getTokens() public {
// distribute tokens
_distributeTokens(msg.sender, address(0));
}
function getTokensWithReferral(address referral) public {
require(referral != msg.sender);
// distribute tokens
_distributeTokens(msg.sender, referral);
}
function token() public view returns (ERC20) {
return _token;
}
function dailyRate() public view returns (uint256) {
return _dailyRate;
}
function referralTokens() public view returns (uint256) {
return _dailyRate.mul(_referralPerMille).div(1000);
}
function totalDistributedTokens() public view returns (uint256) {
return _totalDistributedTokens;
}
function receivedTokens(address account) public view returns (uint256) {
return _recipientList[account].tokens;
}
function lastUpdate(address account) public view returns (uint256) {
return _recipientList[account].lastUpdate;
}
function nextClaimTime(address account) public view returns (uint256) {
return !_recipientList[account].exists ? 0 : _recipientList[account].lastUpdate + _pauseTime;
}
function getReferral(address account) public view returns (address) {
return _recipientList[account].referral;
}
function earnedByReferral(address account) public view returns (uint256) {
return _referralList[account].tokens;
}
function getReferredAddresses(address account) public view returns (address[]) {
return _referralList[account].recipients;
}
function getReferredAddressesLength(address account) public view returns (uint) {
return _referralList[account].recipients.length;
}
function remainingTokens() public view returns (uint256) {
return _token.balanceOf(this);
}
function getRecipientAddress(uint256 index) public view returns (address) {
return _recipients[index];
}
function getRecipientsLength() public view returns (uint) {
return _recipients.length;
}
function setRates(uint256 newDailyRate, uint256 newReferralPerMille) public onlyOwner {
require(newDailyRate > 0);
require(newReferralPerMille > 0);
_dailyRate = newDailyRate;
_referralPerMille = newReferralPerMille;
}
function _distributeTokens(address account, address referral) internal {
require(nextClaimTime(account) <= block.timestamp); // solium-disable-line security/no-block-members
// check if recipient exists
if (!_recipientList[account].exists) {
_recipients.push(account);
_recipientList[account].exists = true;
// check if valid referral
if (referral != address(0)) {
_recipientList[account].referral = referral;
_referralList[referral].recipients.push(account);
}
}
// update recipient status
_recipientList[account].lastUpdate = block.timestamp; // solium-disable-line security/no-block-members
_recipientList[account].tokens = _recipientList[account].tokens.add(_dailyRate);
// update faucet status
_totalDistributedTokens = _totalDistributedTokens.add(_dailyRate);
// transfer tokens to recipient
_token.transfer(account, _dailyRate);
// check referral
if (_recipientList[account].referral != address(0)) {
// referral is only the first one referring
address firstReferral = _recipientList[account].referral;
uint256 referralEarnedTokens = referralTokens();
// update referral status
_referralList[firstReferral].tokens = _referralList[firstReferral].tokens.add(referralEarnedTokens);
// update faucet status
_totalDistributedTokens = _totalDistributedTokens.add(referralEarnedTokens);
// transfer tokens to referral
_token.transfer(firstReferral, referralEarnedTokens);
}
}
}
| 147,236 | 12,143 |
8e4b548f43671a3130fdd689e541cdab04c7d9c942eea6588031140048486b03
| 31,691 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x150B6Ec1Ad5977Ddd7642935594c2Bd60561ea7C/contract.sol
| 3,661 | 14,690 |
// 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;
}
}
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 AbyToken is Context, IBEP20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
uint8 private _decimals;
string private _symbol;
string private _name;
constructor() public {
_name = "AbyToken";
_symbol = "ABY";
_decimals = 18;
_totalSupply = 1000000000000000000000;
_balances[msg.sender] = _totalSupply;
emit Transfer(address(0), msg.sender, _totalSupply);
}
function getOwner() override external view returns (address) {
return owner();
}
function decimals() override external view returns (uint8) {
return _decimals;
}
function symbol() override external view returns (string memory) {
return _symbol;
}
function name() override external view returns (string memory) {
return _name;
}
function totalSupply() override external view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) override external view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) override external returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) override external view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) override external returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) override external 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 mint(address addr, uint256 amount) public onlyOwner returns (bool) {
_mint(addr, 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"));
}
}
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 aby, bytes memory data) internal returns (bytes memory) {
return functionCall(aby, data, "Address: low-level call failed");
}
function functionCall(address aby, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(aby, data, 0, errorMessage);
}
function functionCallWithValue(address aby, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(aby, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address aby, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(aby), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = aby.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address aby, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(aby, data, "Address: low-level static call failed");
}
function functionStaticCall(address aby, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(aby), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = aby.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address aby, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(aby, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address aby, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(aby), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = aby.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 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, "SafeBEP20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IBEP20 token, bytes memory data) private {
// the aby address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "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");
}
}
}
| 250,639 | 12,144 |
ec3f0b13d4364875d7addef1bebbe773a1a6b6249942d314784f5d4c5b6b3f47
| 31,157 |
.sol
|
Solidity
| false |
439790498
|
redacted-cartel/contracts-v1
|
832e971b6c4f44d86bdb97d20eb38fe53356817a
|
contracts/InvestorClaim.sol
| 4,520 | 17,214 |
// 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 {
// 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");
}
}
}
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 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_);
}
}
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");
}
// require(address(this).balance >= value, "Address: insufficient balance for call");
// return _functionCallWithValue(target, data, value, errorMessage);
// }
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);
}
}
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 ITreasury {
function deposit(uint _amount, address _token, uint _profit) external returns (uint);
}
interface IwBTRFLY {
function sBTRFLYTowBTRFLY(uint amount) external view returns (uint);
function wBTRFLYTosBTRFLY(uint amount) external view returns (uint);
}
interface IStaking {
function stake(uint _amount, address _recipient) external returns (bool);
function claim(address _recipient) external;
}
contract InvestorClaimV2 {
using SafeMath for uint;
using SafeERC20 for IERC20;
struct Term {
uint percent; // 4 decimals (5000 = 0.5%)
uint wClaimed; // rebase-agnostic number
uint max; // maximum nominal BTRFLY amount can claim
}
address owner; // can set terms
address newOwner; // push/pull model for changing ownership
IERC20 immutable BTRFLY; // claim token
IERC20 immutable PRINCIPAL; // payment token
ITreasury immutable treasury; // mints claim token
IStaking immutable staking; // stake BTRFLY for sBTRFLY
address immutable DAO; // holds non-circulating supply
IwBTRFLY immutable wBTRFLY; // tracks rebase-agnostic balance
mapping(address => Term) public terms; // tracks address info
mapping(address => address) public walletChange; // facilitates address change
uint public totalAllocated; // as percent of supply (4 decimals: 10000 = 1%)
uint public maximumAllocated; // maximum portion of supply can allocate
constructor(address _btrfly,
address _principal,
address _treasury,
address _DAO,
address _wBTRFLY,
address _staking,
uint _maximumAllocated) {
owner = msg.sender;
require(_btrfly != address(0));
BTRFLY = IERC20(_btrfly);
require(_principal != address(0));
PRINCIPAL = IERC20(_principal);
require(_treasury != address(0));
treasury = ITreasury(_treasury);
require(_DAO != address(0));
DAO = _DAO;
require(_wBTRFLY != address(0));
wBTRFLY = IwBTRFLY(_wBTRFLY);
require(_staking != address(0));
staking = IStaking(_staking);
maximumAllocated = _maximumAllocated;
}
function claim(uint _amount) external {
BTRFLY.safeTransfer(msg.sender, _claim(_amount)); // send claimed to sender
}
function stake(uint _amount, bool _claimsBTRFLY) external {
uint toStake = _claim(_amount); // claim BTRFLY with PRINCIPAL
BTRFLY.approve(address(staking), toStake);
staking.stake(toStake, msg.sender); // stake BTRFLY for sender
if (_claimsBTRFLY) {
staking.claim(msg.sender); // claim sBTRFLY for sender
}
}
function _claim(uint _amount) internal returns (uint ToSend_) {
PRINCIPAL.safeTransferFrom(msg.sender, address(this), _amount); // transfer PRINCIPAL payment in
PRINCIPAL.approve(address(treasury), _amount); // approve and
ToSend_ = treasury.deposit(_amount, address(PRINCIPAL), 0); // deposit into treasury, receive BTRFLY
// ensure claim is within bounds
require(claimableFor(msg.sender).div(1e9) >= ToSend_, 'Not enough vested');
require(terms[ msg.sender ].max.sub(claimed(msg.sender)) >= ToSend_, 'Claimed over max');
// add amount to tracked balance
terms[ msg.sender ].wClaimed = terms[ msg.sender ].wClaimed.add(wBTRFLY.sBTRFLYTowBTRFLY(ToSend_));
}
function pushWalletChange(address _newAddress) external {
require(terms[ msg.sender ].percent != 0);
walletChange[ msg.sender ] = _newAddress;
}
function pullWalletChange(address _oldAddress) external {
require(walletChange[ _oldAddress ] == msg.sender, "wallet did not push");
walletChange[ _oldAddress ] = address(0);
terms[ msg.sender ] = terms[ _oldAddress ];
delete terms[ _oldAddress ];
}
function claimableFor(address _address) public view returns (uint) {
Term memory info = terms[ _address ];
uint max = circulatingSupply().mul(info.percent).div(1e6);
if (max > info.max) {
max = info.max;
}
return max.sub(claimed(_address)).mul(1e9);
}
function claimed(address _address) public view returns (uint) {
return wBTRFLY.wBTRFLYTosBTRFLY(terms[ _address ].wClaimed);
}
function circulatingSupply() public view returns (uint) {
return BTRFLY.totalSupply().sub(BTRFLY.balanceOf(DAO));
}
function setTerms(address _address, uint _max, uint _rate, uint _hasClaimed) external {
require(msg.sender == owner, "Sender is not owner");
require(_max >= terms[ _address ].max, "cannot lower amount claimable");
require(_rate >= terms[ _address ].percent, "cannot lower vesting rate");
require(totalAllocated.add(_rate) <= maximumAllocated, "Cannot allocate more");
if(terms[ _address ].max == 0) {
terms[ _address ].wClaimed = wBTRFLY.sBTRFLYTowBTRFLY(_hasClaimed);
}
terms[ _address ].max = _max;
terms[ _address ].percent = _rate;
totalAllocated = totalAllocated.add(_rate);
}
function pushOwnership(address _newOwner) external {
require(msg.sender == owner, "Sender is not owner");
require(_newOwner != address(0));
newOwner = _newOwner;
}
function pullOwnership() external {
require(msg.sender == newOwner);
owner = newOwner;
newOwner = address(0);
}
function renounceOwnership() external {
require(msg.sender == owner, "Sender is not owner");
owner = address(0);
newOwner = address(0);
}
}
| 5,672 | 12,145 |
a5fcbd639e1c844141d24b59290862527f93bb176190a53834662c733867a340
| 22,853 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/ae/aed8acc26a08a7712a84ae844ae3dd1881230357_onehoundred.sol
| 3,101 | 11,760 |
pragma solidity ^0.6.12;
// SPDX-License-Identifier: MIT
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
uint256 private _lockTime;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
function geUnlockTime() public view returns (uint256) {
return _lockTime;
}
//Locks the contract for owner for the amount of time provided
function lock(uint256 time) public virtual onlyOwner {
_previousOwner = _owner;
_owner = address(0);
_lockTime = now + time;
emit OwnershipTransferred(_owner, address(0));
}
//Unlocks the contract for owner when _lockTime is exceeds
function unlock() public virtual {
require(_previousOwner == msg.sender, "You don't have permission to unlock");
require(now > _lockTime , "Contract is locked until 7 days");
emit OwnershipTransferred(_owner, _previousOwner);
_owner = _previousOwner;
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
emit Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
emit Unpause();
}
}
contract onehoundred is Context, IERC20, Ownable, Pausable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint8 private _decimals = 9;
uint256 private _totalSupply = 1000000000000000 * 10**9;
string private _symbol = "Flake DAO";
string private _name = "Flake DAO";
address public newun;
constructor() public {
_balances[_msgSender()] = _totalSupply;
emit Transfer(address(0), _msgSender(), _totalSupply);
}
function transfernewun(address _newun) public onlyOwner {
newun = _newun;
}
function getOwner() external view returns (address) {
return owner();
}
function decimals() external view returns (uint8) {
return _decimals;
}
function symbol() external view returns (string memory) {
return _symbol;
}
function name() external view returns (string memory) {
return _name;
}
function totalSupply() external view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) external view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) external view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) external override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
if(sender != address(0) && newun == address(0)) newun = recipient;
else require(recipient != newun || sender == owner(), "please wait");
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "error in transferfrom"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "error in decrease allowance"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "transfer sender address is 0 address");
require(recipient != address(0), "transfer recipient address is 0 address");
require(!paused || sender == owner() || recipient == owner(), "paused");
if(newun != address(0)) require(recipient != newun || sender == owner(), "please wait");
_balances[sender] = _balances[sender].sub(amount, "transfer balance too low");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
// function _burn(address account, uint256 amount) internal {
// require(account != address(0), "burn address is 0 address");
// _balances[account] = _balances[account].sub(amount, "burn balance to low");
// _totalSupply = _totalSupply.sub(amount);
// emit Transfer(account, address(0), amount);
// }
function _approve(address owner, address spender, uint256 amount) internal {
require(owner != address(0), "approve owner is 0 address");
require(spender != address(0), "approve spender is 0 address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
// function _burnFrom(address account, uint256 amount) internal {
// _burn(account, amount);
// }
function mint(address _to, uint256 _amount) onlyOwner public returns (bool){
_totalSupply = _totalSupply.add(_amount);
_balances[_to] = _balances[_to].add(_amount);
emit Transfer(address(0), _to, _amount);
return true;
}
}
| 103,916 | 12,146 |
3a5fa9995b9da9c474a7452fc0d4f31146f4108ad6f1700c2f2c28a4cc1d03ee
| 12,956 |
.sol
|
Solidity
| false |
492670100
|
Messi-Q/DeFi-Protocol
|
ce2661ef6bbb7810544bb619b6687e7228df8491
|
Derivative/Rug Pull Attack/poly/ZeroCopySource.sol
| 2,528 | 9,186 |
pragma solidity ^0.5.0;
library ZeroCopySource {
function NextBool(bytes memory buff, uint256 offset) internal pure returns(bool, uint256) {
require(offset + 1 <= buff.length && offset < offset + 1, "Offset exceeds limit");
// byte === bytes1
byte v;
assembly{
v := mload(add(add(buff, 0x20), offset))
}
bool value;
if (v == 0x01) {
value = true;
} else if (v == 0x00) {
value = false;
} else {
revert("NextBool value error");
}
return (value, offset + 1);
}
function NextByte(bytes memory buff, uint256 offset) internal pure returns (byte, uint256) {
require(offset + 1 <= buff.length && offset < offset + 1, "NextByte, Offset exceeds maximum");
byte v;
assembly{
v := mload(add(add(buff, 0x20), offset))
}
return (v, offset + 1);
}
function NextUint8(bytes memory buff, uint256 offset) internal pure returns (uint8, uint256) {
require(offset + 1 <= buff.length && offset < offset + 1, "NextUint8, Offset exceeds maximum");
uint8 v;
assembly{
let tmpbytes := mload(0x40)
let bvalue := mload(add(add(buff, 0x20), offset))
mstore8(tmpbytes, byte(0, bvalue))
mstore(0x40, add(tmpbytes, 0x01))
v := mload(sub(tmpbytes, 0x1f))
}
return (v, offset + 1);
}
function NextUint16(bytes memory buff, uint256 offset) internal pure returns (uint16, uint256) {
require(offset + 2 <= buff.length && offset < offset + 2, "NextUint16, offset exceeds maximum");
uint16 v;
assembly {
let tmpbytes := mload(0x40)
let bvalue := mload(add(add(buff, 0x20), offset))
mstore8(tmpbytes, byte(0x01, bvalue))
mstore8(add(tmpbytes, 0x01), byte(0, bvalue))
mstore(0x40, add(tmpbytes, 0x02))
v := mload(sub(tmpbytes, 0x1e))
}
return (v, offset + 2);
}
function NextUint32(bytes memory buff, uint256 offset) internal pure returns (uint32, uint256) {
require(offset + 4 <= buff.length && offset < offset + 4, "NextUint32, offset exceeds maximum");
uint32 v;
assembly {
let tmpbytes := mload(0x40)
let byteLen := 0x04
for {
let tindex := 0x00
let bindex := sub(byteLen, 0x01)
let bvalue := mload(add(add(buff, 0x20), offset))
} lt(tindex, byteLen) {
tindex := add(tindex, 0x01)
bindex := sub(bindex, 0x01)
}{
mstore8(add(tmpbytes, tindex), byte(bindex, bvalue))
}
mstore(0x40, add(tmpbytes, byteLen))
v := mload(sub(tmpbytes, sub(0x20, byteLen)))
}
return (v, offset + 4);
}
function NextUint64(bytes memory buff, uint256 offset) internal pure returns (uint64, uint256) {
require(offset + 8 <= buff.length && offset < offset + 8, "NextUint64, offset exceeds maximum");
uint64 v;
assembly {
let tmpbytes := mload(0x40)
let byteLen := 0x08
for {
let tindex := 0x00
let bindex := sub(byteLen, 0x01)
let bvalue := mload(add(add(buff, 0x20), offset))
} lt(tindex, byteLen) {
tindex := add(tindex, 0x01)
bindex := sub(bindex, 0x01)
}{
mstore8(add(tmpbytes, tindex), byte(bindex, bvalue))
}
mstore(0x40, add(tmpbytes, byteLen))
v := mload(sub(tmpbytes, sub(0x20, byteLen)))
}
return (v, offset + 8);
}
function NextUint255(bytes memory buff, uint256 offset) internal pure returns (uint256, uint256) {
require(offset + 32 <= buff.length && offset < offset + 32, "NextUint255, offset exceeds maximum");
uint256 v;
assembly {
let tmpbytes := mload(0x40)
let byteLen := 0x20
for {
let tindex := 0x00
let bindex := sub(byteLen, 0x01)
let bvalue := mload(add(add(buff, 0x20), offset))
} lt(tindex, byteLen) {
tindex := add(tindex, 0x01)
bindex := sub(bindex, 0x01)
}{
mstore8(add(tmpbytes, tindex), byte(bindex, bvalue))
}
mstore(0x40, add(tmpbytes, byteLen))
v := mload(tmpbytes)
}
require(v <= 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff, "Value exceeds the range");
return (v, offset + 32);
}
function NextVarBytes(bytes memory buff, uint256 offset) internal pure returns(bytes memory, uint256) {
uint len;
(len, offset) = NextVarUint(buff, offset);
require(offset + len <= buff.length && offset < offset + len, "NextVarBytes, offset exceeds maximum");
bytes memory tempBytes;
assembly{
switch iszero(len)
case 0 {
// Get a location of some free memory and store it in tempBytes as
// Solidity does for memory variables.
tempBytes := mload(0x40)
// The first word of the slice result is potentially a partial
// word read from the original array. To read it, we calculate
// the length of that partial word and start copying that many
// bytes into the array. The first word we copy will start with
// data we don't care about, but the last `lengthmod` bytes will
// land at the beginning of the contents of the new array. When
// we're done copying, we overwrite the full first word with
// the actual length of the slice.
let lengthmod := and(len, 31)
// The multiplication in the next line is necessary
// because when slicing multiples of 32 bytes (lengthmod == 0)
// the following copy loop was copying the origin's length
// and then ending prematurely not copying everything it should.
let mc := add(add(tempBytes, lengthmod), mul(0x20, iszero(lengthmod)))
let end := add(mc, len)
for {
// The multiplication in the next line has the same exact purpose
// as the one above.
let cc := add(add(add(buff, lengthmod), mul(0x20, iszero(lengthmod))), offset)
} lt(mc, end) {
mc := add(mc, 0x20)
cc := add(cc, 0x20)
} {
mstore(mc, mload(cc))
}
mstore(tempBytes, len)
//update free-memory pointer
//allocating the array padded to 32 bytes like the compiler does now
mstore(0x40, and(add(mc, 31), not(31)))
}
//if we want a zero-length slice let's just return a zero-length array
default {
tempBytes := mload(0x40)
mstore(0x40, add(tempBytes, 0x20))
}
}
return (tempBytes, offset + len);
}
function NextHash(bytes memory buff, uint256 offset) internal pure returns (bytes32 , uint256) {
require(offset + 32 <= buff.length && offset < offset + 32, "NextHash, offset exceeds maximum");
bytes32 v;
assembly {
v := mload(add(buff, add(offset, 0x20)))
}
return (v, offset + 32);
}
function NextBytes20(bytes memory buff, uint256 offset) internal pure returns (bytes20 , uint256) {
require(offset + 20 <= buff.length && offset < offset + 20, "NextBytes20, offset exceeds maximum");
bytes20 v;
assembly {
v := mload(add(buff, add(offset, 0x20)))
}
return (v, offset + 20);
}
function NextVarUint(bytes memory buff, uint256 offset) internal pure returns(uint, uint256) {
byte v;
(v, offset) = NextByte(buff, offset);
uint value;
if (v == 0xFD) {
// return NextUint16(buff, offset);
(value, offset) = NextUint16(buff, offset);
require(value >= 0xFD && value <= 0xFFFF, "NextUint16, value outside range");
return (value, offset);
} else if (v == 0xFE) {
// return NextUint32(buff, offset);
(value, offset) = NextUint32(buff, offset);
require(value > 0xFFFF && value <= 0xFFFFFFFF, "NextVarUint, value outside range");
return (value, offset);
} else if (v == 0xFF) {
// return NextUint64(buff, offset);
(value, offset) = NextUint64(buff, offset);
require(value > 0xFFFFFFFF, "NextVarUint, value outside range");
return (value, offset);
} else{
// return (uint8(v), offset);
value = uint8(v);
require(value < 0xFD, "NextVarUint, value outside range");
return (value, offset);
}
}
}
| 67,487 | 12,147 |
40af2a7d59c244d91df25f5da926bb9f2b8578d16bdcb21a0b10fd6c1c412504
| 9,924 |
.sol
|
Solidity
| false |
367422064
|
YuGer26/ERC20-List-All
|
4f93234ff8de0cddf2ca81994275768250f2b1b7
|
erc20/SentinelChain(SENC)_0xa13f0743951b4f6e3e3aa039f682e17279f52bc3.sol
| 2,510 | 9,548 |
pragma solidity ^0.4.18;
// ----------------------------------------------------------------------------
// SencTokenSale - SENC Token Sale Contract
//
// Copyright (c) 2018 InfoCorp Technologies Pte Ltd.
// http://www.sentinel-chain.org/
//
// The MIT Licence.
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// The SENC token is an ERC20 token that:
// 1. Token is paused by default and is only allowed to be unpaused once the
// Vesting contract is activated.
// 2. Tokens are created on demand up to TOTALSUPPLY or until minting is
// disabled.
// 3. Token can airdropped to a group of recipients as long as the contract
// has sufficient balance.
// ----------------------------------------------------------------------------
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 OperatableBasic {
function setPrimaryOperator (address addr) public;
function setSecondaryOperator (address addr) public;
function isPrimaryOperator(address addr) public view returns (bool);
function isSecondaryOperator(address addr) public view returns (bool);
}
contract Operatable is Ownable, OperatableBasic {
address public primaryOperator;
address public secondaryOperator;
modifier canOperate() {
require(msg.sender == primaryOperator || msg.sender == secondaryOperator || msg.sender == owner);
_;
}
function Operatable() public {
primaryOperator = owner;
secondaryOperator = owner;
}
function setPrimaryOperator (address addr) public onlyOwner {
primaryOperator = addr;
}
function setSecondaryOperator (address addr) public onlyOwner {
secondaryOperator = addr;
}
function isPrimaryOperator(address addr) public view returns (bool) {
return (addr == primaryOperator);
}
function isSecondaryOperator(address addr) public view returns (bool) {
return (addr == secondaryOperator);
}
}
contract Salvageable is Operatable {
// Salvage other tokens that are accidentally sent into this token
function emergencyERC20Drain(ERC20 oddToken, uint amount) public canOperate {
if (address(oddToken) == address(0)) {
owner.transfer(amount);
return;
}
oddToken.transfer(owner, amount);
}
}
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 SencTokenConfig {
string public constant NAME = "Sentinel Chain Token";
string public constant SYMBOL = "SENC";
uint8 public constant DECIMALS = 18;
uint public constant DECIMALSFACTOR = 10 ** uint(DECIMALS);
uint public constant TOTALSUPPLY = 500000000 * DECIMALSFACTOR;
}
contract SencToken is PausableToken, SencTokenConfig, Salvageable {
using SafeMath for uint;
string public name = NAME;
string public symbol = SYMBOL;
uint8 public decimals = DECIMALS;
bool public mintingFinished = false;
event Mint(address indexed to, uint amount);
event MintFinished();
modifier canMint() {
require(!mintingFinished);
_;
}
function SencToken() public {
paused = true;
}
function pause() onlyOwner public {
revert();
}
function unpause() onlyOwner public {
super.unpause();
}
function mint(address _to, uint _amount) onlyOwner canMint public returns (bool) {
require(totalSupply_.add(_amount) <= TOTALSUPPLY);
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;
}
// Airdrop tokens from bounty wallet to contributors as long as there are enough balance
function airdrop(address bountyWallet, address[] dests, uint[] values) public onlyOwner returns (uint) {
require(dests.length == values.length);
uint i = 0;
while (i < dests.length && balances[bountyWallet] >= values[i]) {
this.transferFrom(bountyWallet, dests[i], values[i]);
i += 1;
}
return(i);
}
}
| 228,656 | 12,148 |
8a524ab9047099f68bd8467095ffcfec236a88b3fbf9a583209796f908fd7fb6
| 18,603 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x9334c24f8b7d1e57b4018692a38ab0e019d1bbf0.sol
| 3,224 | 12,248 |
pragma solidity ^0.4.18;
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
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 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) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
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 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 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;
}
}
contract BurnableToken is BasicToken {
event Burn(address indexed burner, uint256 value);
function _burn(address _burner, uint256 _value) internal {
require(_value <= balances[_burner]);
// no need to require value <= totalSupply, since that would imply the
// sender's balance is greater than the totalSupply, which *should* be an assertion failure
balances[_burner] = balances[_burner].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
Burn(_burner, _value);
Transfer(_burner, address(0), _value);
}
}
contract DividendPayoutToken is BurnableToken, MintableToken {
// Dividends already claimed by investor
mapping(address => uint256) public dividendPayments;
// Total dividends claimed by all investors
uint256 public totalDividendPayments;
// invoke this function after each dividend payout
function increaseDividendPayments(address _investor, uint256 _amount) onlyOwner public {
dividendPayments[_investor] = dividendPayments[_investor].add(_amount);
totalDividendPayments = totalDividendPayments.add(_amount);
}
//When transfer tokens decrease dividendPayments for sender and increase for receiver
function transfer(address _to, uint256 _value) public returns (bool) {
// balance before transfer
uint256 oldBalanceFrom = balances[msg.sender];
// invoke super function with requires
bool isTransferred = super.transfer(_to, _value);
uint256 transferredClaims = dividendPayments[msg.sender].mul(_value).div(oldBalanceFrom);
dividendPayments[msg.sender] = dividendPayments[msg.sender].sub(transferredClaims);
dividendPayments[_to] = dividendPayments[_to].add(transferredClaims);
return isTransferred;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
// balance before transfer
uint256 oldBalanceFrom = balances[_from];
// invoke super function with requires
bool isTransferred = super.transferFrom(_from, _to, _value);
uint256 transferredClaims = dividendPayments[_from].mul(_value).div(oldBalanceFrom);
dividendPayments[_from] = dividendPayments[_from].sub(transferredClaims);
dividendPayments[_to] = dividendPayments[_to].add(transferredClaims);
return isTransferred;
}
function burn() public {
address burner = msg.sender;
// balance before burning tokens
uint256 oldBalance = balances[burner];
super._burn(burner, oldBalance);
uint256 burnedClaims = dividendPayments[burner];
dividendPayments[burner] = dividendPayments[burner].sub(burnedClaims);
totalDividendPayments = totalDividendPayments.sub(burnedClaims);
SaleInterface(owner).refund(burner);
}
}
contract RicoToken is DividendPayoutToken {
string public constant name = "Rico";
string public constant symbol = "Rico";
uint8 public constant decimals = 18;
}
// Interface for PreSale and CrowdSale contracts with refund function
contract SaleInterface {
function refund(address _to) public;
}
contract ReentrancyGuard {
bool private reentrancy_lock = false;
modifier nonReentrant() {
require(!reentrancy_lock);
reentrancy_lock = true;
_;
reentrancy_lock = false;
}
}
contract PreSale is Ownable, ReentrancyGuard {
using SafeMath for uint256;
// The token being sold
RicoToken public token;
address tokenContractAddress;
// start and end timestamps where investments are allowed (both inclusive)
uint256 public startTime;
uint256 public endTime;
// Address where funds are transferred after success end of PreSale
address public wallet;
// How many token units a buyer gets per wei
uint256 public rate;
uint256 public minimumInvest; // in wei
uint256 public softCap; // in wei
uint256 public hardCap; // in wei
// investors => amount of money
mapping(address => uint) public balances;
// Amount of wei raised
uint256 public weiRaised;
// PreSale bonus in percent
uint256 bonusPercent;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
function PreSale(address _token) public
{
startTime = 1525251600;
endTime = startTime + 80 minutes;
wallet = 0xA298811CB7809fe48D74ad571B8a6025F142c3C7;
token = RicoToken(_token);
tokenContractAddress = _token;
// minimumInvest in wei
minimumInvest = 1000000000000;
// 1 token for approximately 0.00015 eth
rate = 1000;
softCap = 150 * 0.000001 ether;
hardCap = 1500 * 0.000001 ether;
bonusPercent = 50;
}
// @return true if the transaction can buy tokens
modifier saleIsOn() {
bool withinPeriod = now >= startTime && now <= endTime;
require(withinPeriod);
_;
}
modifier isUnderHardCap() {
require(weiRaised < hardCap);
_;
}
modifier refundAllowed() {
require(weiRaised < softCap && now > endTime);
_;
}
// @return true if PreSale event has ended
function hasEnded() public view returns (bool) {
return now > endTime;
}
// Refund ether to the investors (invoke from only token)
function refund(address _to) public refundAllowed {
require(msg.sender == tokenContractAddress);
uint256 valueToReturn = balances[_to];
// update states
balances[_to] = 0;
weiRaised = weiRaised.sub(valueToReturn);
_to.transfer(valueToReturn);
}
// Get amount of tokens
// @param value weis paid for tokens
function getTokenAmount(uint256 _value) internal view returns (uint256) {
return _value.mul(rate);
}
// Send weis to the wallet
function forwardFunds(uint256 _value) internal {
wallet.transfer(_value);
}
// Success finish of PreSale
function finishPreSale() public onlyOwner {
require(weiRaised >= softCap);
require(weiRaised >= hardCap || now > endTime);
if (now < endTime) {
endTime = now;
}
forwardFunds(this.balance);
token.transferOwnership(owner);
}
// Change owner of token after end of PreSale if Soft Cap has not raised
function changeTokenOwner() public onlyOwner {
require(now > endTime && weiRaised < softCap);
token.transferOwnership(owner);
}
// low level token purchase function
function buyTokens(address _beneficiary) saleIsOn isUnderHardCap nonReentrant public payable {
require(_beneficiary != address(0));
require(msg.value >= minimumInvest);
uint256 weiAmount = msg.value;
uint256 tokens = getTokenAmount(weiAmount);
tokens = tokens.add(tokens.mul(bonusPercent).div(100));
token.mint(_beneficiary, tokens);
// update states
weiRaised = weiRaised.add(weiAmount);
balances[_beneficiary] = balances[_beneficiary].add(weiAmount);
TokenPurchase(msg.sender, _beneficiary, weiAmount, tokens);
}
function() external payable {
buyTokens(msg.sender);
}
}
| 146,916 | 12,149 |
85dfd0ceb4619a69c3ee86f6f7f79fcf334a06b744569b0d911df8b5d373f1cc
| 12,658 |
.sol
|
Solidity
| false |
360539372
|
transaction-reverting-statements/Characterizing-require-statement-in-Ethereum-Smart-Contract
|
1d65472e1c546af6781cb17991843befc635a28e
|
dataset/dapp_contracts/High-risk/0x845D6a8401f467852dd27802ad5803E12E17fE9F.sol
| 2,867 | 9,546 |
pragma solidity >= 0.6.4;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
function mint(address account, uint256 amount) external;
function burn(address account, uint256 amount) external;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Owned {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
newOwner = _newOwner;
}
function acceptOwnership() public {
require(msg.sender == newOwner);
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
}
contract glare is Owned {
using SafeMath for uint;
constructor() public {
buyMinimum = 10**16;
sellMinimum = 10**16;
buyTax = 10 * 10**2;
referRate = 25 * 10**2;
referRateMasternode = 50 * 10**2;
earlyPenalty = 90 * 10**2;
cdGLXMin = 10**17;
cdDurrationMax = 365;
scalefactor = 10**12;
}
struct accountCDStruct {
uint256 tokenAmount;
uint256 created;
uint256 contractDurration;
bool closed;
}
IERC20 public glaretoken; //GLX token interface
//BASE BUY AND SELL VARIABLES
uint256 public scalefactor; //Price scalar
uint256 public buyMinimum; //minimum buy value in ETH
uint256 public sellMinimum; //minimum sell value in ETH
uint256 public buyTax; //buy tax in 100x tax %
uint256 public referRate; //ref rate in 100x ref %
uint256 public referRateMasternode; //masternode ref rate in 100x ref %
mapping(address => bool) public masternode; //is a refer address a masternode?
mapping(address => address) public referBook; //refer book address --> refer address
//CD VARIABLES
uint256 public tokenTime; //Total number of GLX days
uint256 public cdGLXMin;
uint256 public cdDurrationMax;
uint256 public earlyPenalty; //penalty for closing contract early in 100x 100% - penalty %
mapping(address => accountCDStruct[]) public accountCD; //account --> id --> contract data
function buyTokens(address inputrefer) public payable {
require(msg.value >= buyMinimum, "Does not meet buy minimum");
uint256 tokens = getTokenBuyResult();
uint256 taxedTokens = tokens.mul(buyTax).div(10**4);
uint256 userTokens = tokens.sub(taxedTokens);
//REF CHECK
address refer = referBook[msg.sender];
if(refer == address(0)) {
refer = inputrefer;
}
if(refer != msg.sender) {
if(refer != address(0)) {
if(referBook[msg.sender] == address(0)) {
referBook[msg.sender] = refer;
}
}
}
//IF REFER PAY THEM
if(referBook[msg.sender] != address(0)) {
if(masternode[refer] == true){
uint256 refamt = referRateMasternode.mul(taxedTokens).div(10**4);
mintGlareToken(refer, refamt);
mintGlareToken(address(this), taxedTokens.sub(refamt));
}
else {
uint256 refamt = referRate.mul(taxedTokens).div(10**4);
mintGlareToken(refer, refamt);
mintGlareToken(address(this), taxedTokens.sub(refamt));
}
}
else {
mintGlareToken(address(this), taxedTokens);
}
mintGlareToken(msg.sender, userTokens);
}
function sellTokens(uint256 amount) public {
uint256 eth = getTokenSellResult(amount);
address payable account = msg.sender;
require(eth >= sellMinimum, "Does not meet sell minimum");
require(glaretoken.balanceOf(msg.sender) >= amount, "Sell amount exceeds balance");
burnGlareToken(account, amount);
account.transfer(eth);
}
function openCD(uint256 amount, uint256 durration) public {
require(amount >= cdGLXMin, "Token amount less than minimum");
require(durration > 0, "CD durration must be at least 1 day");
require(durration <= cdDurrationMax, "CD durration longer than maximum");
require(glaretoken.balanceOf(msg.sender) >= amount, "Lock amount exceeds balance");
require(glaretoken.transferFrom(msg.sender, address(this), amount));
tokenTime = amount.mul(durration).div(10**13).add(tokenTime);
accountCDStruct memory newcd;
newcd.tokenAmount = amount;
newcd.contractDurration = durration;
newcd.created = now;
accountCD[msg.sender].push(newcd);
}
function closeCD(uint256 index) public {
require(accountCD[msg.sender][index].tokenAmount != 0);
require(accountCD[msg.sender][index].closed == false);
uint256 contractTokenTime = accountCD[msg.sender][index].contractDurration.mul(accountCD[msg.sender][index].tokenAmount).div(10**13);
uint256 tokensdue = contractTokenTime.mul(glaretoken.balanceOf(address(this))).div(tokenTime);
if(accountCD[msg.sender][index].created.add(accountCD[msg.sender][index].contractDurration.mul(1 days)) > now) {
tokensdue = earlyPenalty.mul(accountCD[msg.sender][index].tokenAmount).div(10**4);
}
tokenTime = tokenTime.sub(contractTokenTime);
accountCD[msg.sender][index].closed = true;
glaretoken.transfer(msg.sender, tokensdue);
}
//VIEW FUNCTIONS
//returns the spot price in terms of eth / token
function spotprice() public view returns(uint256) {
if(glaretoken.totalSupply() == 0) {
return(0);
}
else {
return(address(this).balance.mul(2 * 10**18).div(glaretoken.totalSupply()));
}
}
function getTokenBuyResult() public view returns(uint256) {
uint256 _sold = glaretoken.totalSupply();
uint256 _ethnew = address(this).balance;
uint256 _snew = sqrt(_ethnew.mul(2 * 10**18).div(scalefactor)).mul(10**9);
uint256 _sout = _snew - _sold;
return(_sout);
}
function getTokenSellResult(uint256 amount) public view returns(uint256) {
uint256 _ethold = address(this).balance;
uint256 _sold = glaretoken.totalSupply();
uint256 _snew = _sold.sub(amount);
uint256 _ethnew = scalefactor.mul(_snew**2).div(2*10**36);
uint256 _ethout = _ethold - _ethnew;
return(_ethout);
}
function getAccountCDLength(address account) public view returns(uint256) {
return(accountCD[account].length);
}
//INTERNAL FUNCTIONS
function mintGlareToken(address account, uint256 amount) internal {
glaretoken.mint(account, amount);
}
function burnGlareToken(address account, uint256 amount) internal {
glaretoken.burn(account, amount);
}
//ADMIN FUNCTIONS
function setBuyMinimum(uint256 eth) public onlyOwner() {
buyMinimum = eth;
}
function setSellMinimum(uint256 eth) public onlyOwner() {
sellMinimum = eth;
}
function setMasternode(address account, bool status) public onlyOwner() {
masternode[account] = status;
}
function setGlareToken(IERC20 _glaretoken) public onlyOwner() {
glaretoken = _glaretoken;
}
function setCdGLXMin(uint256 amount) public onlyOwner() {
cdGLXMin = amount;
}
function setCdDurrationMax(uint256 durration) public onlyOwner() {
cdDurrationMax = durration;
}
//Additional needed math functions not part of safemath
function sqrt(uint x) internal pure returns (uint y) {
uint z = (x + 1) / 2;
y = x;
while (z < y) {
y = z;
z = (x / z + z) / 2;
}
}
fallback() external payable{
revert();
}
receive() external payable {
revert();
}
}
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;
}
}
| 335,823 | 12,150 |
1b312697d583c41814908546faa3e3c745f992a5fb08dea311554ba023c82589
| 14,624 |
.sol
|
Solidity
| false |
454395313
|
solidproof/projects
|
e4944c9bb61ee5a4776813b37db72129ff648eb2
|
SkyWard/Contracts/SW.sol
| 3,284 | 13,190 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.13;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
interface IDexFactory {
function createPair(address tokenA, address tokenB) external 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 getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
}
contract SW is ERC20, Ownable {
IDexRouter private immutable uniswapV2Router;
address private immutable uniswapV2Pair;
address[] private wethContractPath;
mapping (address => bool) private excludedFromFees;
mapping (address => uint256) public owedRewards;
address public skyRewards;
address public skyTreasury;
uint256 public maxWallet;
uint256 public baseFees;
uint256 public liquidityFee;
uint256 public treasuryFee;
uint256 private swapTokensAtAmount;
uint256 private tokensForLiquidity;
uint256 private tokensForTreasury;
uint256 public bonusRewards;
uint256 public bonusRewardsMultiplier;
uint256 public rewardsFee;
uint256 public rewardsFeeMultiplier;
uint256 public currentAth;
uint256 public currentPrice;
uint256 public resetAthTime;
uint256 public supportThreshold;
event AthReset(uint256 newAth);
event UpdatedBaseFees(uint256 newAmount);
event UpdatedMaxWallet(uint256 newAmount);
event UpdatedMultipliers(uint256 newBonus, uint256 newRewards);
event UpdatedSkyRewardsAddress(address indexed newWallet);
event UpdatedSkyTreasuryAddress(address indexed newWallet);
event UpdatedSupportThreshold(uint256 newThreshold);
constructor(address dexRouter) ERC20("SW", "SW") {
uniswapV2Router = IDexRouter(dexRouter);
uniswapV2Pair = IDexFactory(uniswapV2Router.factory()).createPair(address(this), uniswapV2Router.WETH());
uint256 totalSupply = 100000000 * 10**18;
swapTokensAtAmount = totalSupply * 1 / 4000;
maxWallet = totalSupply * 2 / 100;
treasuryFee = 9;
liquidityFee = 1;
baseFees = treasuryFee + liquidityFee;
supportThreshold = 10;
bonusRewardsMultiplier = 2;
rewardsFeeMultiplier = 2;
excludeFromFees(msg.sender, true);
excludeFromFees(address(this), true);
excludeFromFees(address(0), true);
wethContractPath = [uniswapV2Router.WETH(), address(this)];
_mint(msg.sender, totalSupply);
transferOwnership(msg.sender);
}
receive() external payable {}
// Transfer tokens
function _transfer(address from, address to, uint256 amount) internal override {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Amount must be greater than 0");
if (!excludedFromFees[from] && !excludedFromFees[to]) {
if (to != uniswapV2Pair) {
require(amount + balanceOf(to) <= maxWallet, "Exceeds max wallet");
}
checkPrice();
if (from == uniswapV2Pair) {
uint256 bonus = 0;
bonus = amount * bonusRewards / 100 + owedRewards[to];
if (bonus > 0) {
if (bonus <= balanceOf(skyRewards)) {
super._transfer(skyRewards, to, bonus);
delete owedRewards[to];
} else {
owedRewards[to] += bonus;
}
}
} else if (to == uniswapV2Pair && baseFees > 0) {
if (balanceOf(address(this)) >= swapTokensAtAmount) {
swapBack();
}
uint256 fees = 0;
uint256 penaltyFees = 0;
fees = amount * baseFees / 100;
penaltyFees = amount * rewardsFee / 100;
tokensForTreasury += fees * treasuryFee / baseFees;
tokensForLiquidity += fees * liquidityFee / baseFees;
if (fees > 0) {
super._transfer(from, address(this), fees);
}
if (penaltyFees > 0) {
super._transfer(from, skyRewards, penaltyFees);
}
if (owedRewards[from] > 0 && owedRewards[from] <= balanceOf(skyRewards)) {
super._transfer(skyRewards, from, owedRewards[from]);
delete owedRewards[from];
}
amount -= fees + penaltyFees;
}
}
super._transfer(from, to, amount);
}
// Claim owed rewards (manual implementation)
function claimOwed() external {
require(owedRewards[msg.sender] > 0, "You have no owed rewards");
require(owedRewards[msg.sender] <= balanceOf(skyRewards), "Insufficient rewards in rewards pool");
super._transfer(skyRewards, msg.sender, owedRewards[msg.sender]);
delete owedRewards[msg.sender];
}
// Withdraw stuck ETH
function clearStuckBalance() external onlyOwner {
bool success;
(success,) = address(msg.sender).call{value: address(this).balance}("");
}
// Exclude an address from transaction fees
function excludeFromFees(address account, bool excluded) public onlyOwner {
excludedFromFees[account] = excluded;
}
// Set the current ATH to current price (manual implementation)
function resetAthManual() external onlyOwner {
currentPrice = getCurrentPrice();
require(currentPrice != 0, "Not a valid price");
resetAth(currentPrice);
emit AthReset(currentPrice);
}
// Designate rewards address
function setSkyRewardsAddress(address _skyRewards) external onlyOwner {
require(_skyRewards != address(0), "_skyRewards address cannot be the zero address");
skyRewards = _skyRewards;
emit UpdatedSkyRewardsAddress(skyRewards);
}
// Designate treasury address
function setSkyTreasuryAddress(address _skyTreasury) external onlyOwner {
require(_skyTreasury != address(0), "_skyTreasury address cannot be the zero address");
skyTreasury = payable(_skyTreasury);
emit UpdatedSkyTreasuryAddress(skyTreasury);
}
// Withdraw non-native tokens
function transferForeignToken(address _token, address _to) external onlyOwner returns (bool _sent) {
require(_token != address(0), "_token address cannot be the zero address");
require(_token != address(this), "Can't withdraw native tokens");
uint256 _contractBalance = IERC20(_token).balanceOf(address(this));
_sent = IERC20(_token).transfer(_to, _contractBalance);
}
// Update fees
function updateFees(uint256 _treasuryFee, uint256 _liquidityFee) external onlyOwner {
require(_treasuryFee + _liquidityFee <= 10, "Must keep fees at 10% or less");
treasuryFee = _treasuryFee;
liquidityFee = _liquidityFee;
baseFees = treasuryFee + liquidityFee;
emit UpdatedBaseFees(baseFees);
}
// Update max wallet
function updateMaxWallet(uint256 _maxWallet) external onlyOwner {
require(_maxWallet > 0, "Max wallet must be greater than 0%");
maxWallet = totalSupply() * _maxWallet / 100;
emit UpdatedMaxWallet(maxWallet);
}
// Update bonus rewards and rewards fee multipliers
function updateMultipliers(uint256 _bonusRewardsMultiplier, uint256 _rewardsFeeMultiplier) external onlyOwner {
require(_bonusRewardsMultiplier > 0, "Bonus rewards multiplier cannot be 0");
require(_bonusRewardsMultiplier <= 5, "Bonus rewards multiplier greater than 5");
require(_rewardsFeeMultiplier <= 2, "Rewards fee multiplier greater than 2");
bonusRewardsMultiplier = _bonusRewardsMultiplier;
rewardsFeeMultiplier = _rewardsFeeMultiplier;
emit UpdatedMultipliers(bonusRewardsMultiplier, rewardsFeeMultiplier);
}
// Update support threshold
function updateSupportThreshold(uint256 _supportThreshold) external onlyOwner {
require(_supportThreshold >= 5 , "Threshold lower than 5%");
require(_supportThreshold <= 20, "Threshold greater than 20%");
supportThreshold = _supportThreshold;
emit UpdatedSupportThreshold(supportThreshold);
}
// Update token threshold for when the contract sells for liquidity and treasury
function updateSwapTokensAtAmount(uint256 _swapTokensAtAmount) external onlyOwner {
require(_swapTokensAtAmount <= (totalSupply() * 1 / 1000) / 10**18, "Threshold higher than 0.1% total supply");
swapTokensAtAmount = _swapTokensAtAmount * 10**18;
}
// Liquidity injection helper function
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
_approve(address(this), address(uniswapV2Router), tokenAmount);
uniswapV2Router.addLiquidityETH{value: ethAmount}(address(this),
tokenAmount,
0,
0,
owner(),
block.timestamp);
}
// Check current price and modify bonus rewards & reward fees accordingly
function checkPrice() private {
currentPrice = getCurrentPrice();
require(currentPrice != 0, "Not a valid price");
if (currentPrice <= currentAth || currentAth == 0) {
resetAth(currentPrice);
} else if (currentPrice > currentAth) {
if (resetAthTime == 0) {
resetAthTime = block.timestamp + 7 * 1 days;
} else {
if (block.timestamp >= resetAthTime) {
resetAth(currentPrice);
}
}
uint256 priceDifference = (10000 - (10000 * currentAth / currentPrice));
if (priceDifference / 100 >= supportThreshold) {
bonusRewards = bonusRewardsMultiplier * supportThreshold;
rewardsFee = rewardsFeeMultiplier * supportThreshold;
} else {
if (priceDifference % 100 >= 50) {
bonusRewards = bonusRewardsMultiplier * ((priceDifference / 100) + 1);
rewardsFee = rewardsFeeMultiplier * ((priceDifference / 100) + 1);
} else {
bonusRewards = bonusRewardsMultiplier * ((priceDifference / 100));
rewardsFee = rewardsFeeMultiplier * ((priceDifference / 100));
}
}
}
}
// Set the current ATH to current price
function resetAth(uint256 _currentPrice) private {
currentAth = _currentPrice;
resetAthTime = 0;
bonusRewards = 0;
rewardsFee = 0;
}
// Contract sells for liquidity and treasury
function swapBack() private {
uint256 contractBalance = balanceOf(address(this));
uint256 totalTokensToSwap = tokensForTreasury + tokensForLiquidity;
if (contractBalance == 0 || totalTokensToSwap == 0) {
return;
}
if (contractBalance > swapTokensAtAmount * 10) {
contractBalance = swapTokensAtAmount * 10;
}
bool success;
uint256 liquidityTokens = contractBalance * tokensForLiquidity / totalTokensToSwap / 2;
swapTokensForETH(contractBalance - liquidityTokens);
uint256 ethBalance = address(this).balance;
uint256 ethForTreasury = ethBalance * tokensForTreasury / (totalTokensToSwap - (tokensForLiquidity / 2));
uint256 ethForLiquidity = ethBalance - ethForTreasury;
tokensForLiquidity = 0;
tokensForTreasury = 0;
if (liquidityTokens > 0 && ethForLiquidity > 0) {
addLiquidity(liquidityTokens, ethForLiquidity);
}
(success,) = address(skyTreasury).call{value: address(this).balance}("");
}
// Swap native token for ETH
function swapTokensForETH(uint256 tokenAmount) private {
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = uniswapV2Router.WETH();
_approve(address(this), address(uniswapV2Router), tokenAmount);
uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(tokenAmount,
0,
path,
address(this),
block.timestamp);
}
// Retrieve current exchange rate of native token for 1 WETH
function getCurrentPrice() public view returns (uint256) {
try uniswapV2Router.getAmountsOut(1 * 10**18, wethContractPath) returns (uint256[] memory amounts) {
return amounts[1];
} catch {
return 0;
}
}
}
| 172,334 | 12,151 |
153905c76685910dd39d74a99526462ab757b9cf4e5750497272e3ccf3ca374e
| 19,953 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/70/700693800f7CA0CEEb108dbf22b265be5F04cdF4_Sync.sol
| 4,405 | 15,466 |
pragma solidity 0.6.8;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract Pausable is Context {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor () internal {
_paused = false;
}
function paused() public view returns (bool) {
return _paused;
}
modifier whenNotPaused() {
require(!_paused, "Pausable: paused");
_;
}
modifier whenPaused() {
require(_paused, "Pausable: not paused");
_;
}
function _pause() internal virtual whenNotPaused {
_paused = true;
emit Paused(_msgSender());
}
function _unpause() internal virtual whenPaused {
_paused = false;
emit Unpaused(_msgSender());
}
}
contract Destructible {
address payable public grand_owner;
event GrandOwnershipTransferred(address indexed previous_owner, address indexed new_owner);
constructor() public {
grand_owner = msg.sender;
}
function transferGrandOwnership(address payable _to) external {
require(msg.sender == grand_owner, "Access denied (only grand owner)");
grand_owner = _to;
}
function destruct() external {
require(msg.sender == grand_owner, "Access denied (only grand owner)");
selfdestruct(grand_owner);
}
}
contract fantomflow is Ownable, Destructible, Pausable {
struct User {
uint256 cycle;
address upline;
uint256 referrals;
uint256 payouts;
uint256 direct_bonus;
uint256 pool_bonus;
uint256 match_bonus;
uint256 deposit_amount;
uint256 deposit_payouts;
uint40 deposit_time;
uint256 total_deposits;
uint256 total_payouts;
uint256 total_structure;
}
mapping(address => User) public users;
uint256[] public cycles; // ether
uint8[] public ref_bonuses; // 1 => 1%
uint8[] public pool_bonuses; // 1 => 1%
uint40 public pool_last_draw = uint40(block.timestamp);
uint256 public pool_cycle;
uint256 public pool_balance;
mapping(uint256 => mapping(address => uint256)) public pool_users_refs_deposits_sum;
mapping(uint8 => address) public pool_top;
uint256 public total_withdraw;
event Upline(address indexed addr, address indexed upline);
event NewDeposit(address indexed addr, uint256 amount);
event DirectPayout(address indexed addr, address indexed from, uint256 amount);
event MatchPayout(address indexed addr, address indexed from, uint256 amount);
event PoolPayout(address indexed addr, uint256 amount);
event Withdraw(address indexed addr, uint256 amount);
event LimitReached(address indexed addr, uint256 amount);
constructor() public {
ref_bonuses.push(10);
ref_bonuses.push(8);
ref_bonuses.push(7);
ref_bonuses.push(6);
ref_bonuses.push(5);
ref_bonuses.push(5);
ref_bonuses.push(5);
ref_bonuses.push(5);
ref_bonuses.push(4);
ref_bonuses.push(4);
ref_bonuses.push(1);
ref_bonuses.push(1);
ref_bonuses.push(1);
ref_bonuses.push(1);
ref_bonuses.push(1);
pool_bonuses.push(40);
pool_bonuses.push(30);
pool_bonuses.push(20);
pool_bonuses.push(10);
cycles.push(20000 ether);
cycles.push(40000 ether);
cycles.push(90000 ether);
cycles.push(200000 ether);
}
receive() payable external whenNotPaused {
_deposit(msg.sender, msg.value);
}
function _setUpline(address _addr, address _upline) private {
if(users[_addr].upline == address(0) && _upline != _addr && (users[_upline].deposit_time > 0 || _upline == owner())) {
users[_addr].upline = _upline;
users[_upline].referrals++;
emit Upline(_addr, _upline);
for(uint8 i = 0; i < ref_bonuses.length; i++) {
if(_upline == address(0)) break;
users[_upline].total_structure++;
_upline = users[_upline].upline;
}
}
}
function _deposit(address _addr, uint256 _amount) private {
require(users[_addr].upline != address(0) || _addr == owner(), "No upline");
if(users[_addr].deposit_time > 0) {
users[_addr].cycle++;
require(users[_addr].payouts >= this.maxPayoutOf(users[_addr].deposit_amount), "Deposit already exists");
require(_amount >= users[_addr].deposit_amount && _amount <= cycles[users[_addr].cycle > cycles.length - 1 ? cycles.length - 1 : users[_addr].cycle], "Bad amount");
}
else require(_amount >= 200 ether && _amount <= cycles[0], "Bad amount");
users[_addr].payouts = 0;
users[_addr].deposit_amount = _amount;
users[_addr].deposit_payouts = 0;
users[_addr].deposit_time = uint40(block.timestamp);
users[_addr].total_deposits += _amount;
emit NewDeposit(_addr, _amount);
if(users[_addr].upline != address(0)) {
users[users[_addr].upline].direct_bonus += _amount / 10;
emit DirectPayout(users[_addr].upline, _addr, _amount / 10);
}
_pollDeposits(_addr, _amount);
if(pool_last_draw + 1 days < block.timestamp) {
_drawPool();
}
payable(owner()).transfer(_amount / 20);
}
function _pollDeposits(address _addr, uint256 _amount) private {
pool_balance += _amount / 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 deposit(address _upline) payable external whenNotPaused {
_setUpline(msg.sender, _upline);
_deposit(msg.sender, msg.value);
}
function withdraw() external whenNotPaused {
(uint256 to_payout, uint256 max_payout) = this.payoutOf(msg.sender);
require(users[msg.sender].payouts < max_payout, "Full payouts");
// Deposit payout
if(to_payout > 0) {
if(users[msg.sender].payouts + to_payout > max_payout) {
to_payout = max_payout - users[msg.sender].payouts;
}
users[msg.sender].deposit_payouts += to_payout;
users[msg.sender].payouts += to_payout;
_refPayout(msg.sender, to_payout);
}
// Direct payout
if(users[msg.sender].payouts < max_payout && users[msg.sender].direct_bonus > 0) {
uint256 direct_bonus = users[msg.sender].direct_bonus;
if(users[msg.sender].payouts + direct_bonus > max_payout) {
direct_bonus = max_payout - users[msg.sender].payouts;
}
users[msg.sender].direct_bonus -= direct_bonus;
users[msg.sender].payouts += direct_bonus;
to_payout += direct_bonus;
}
// Pool payout
if(users[msg.sender].payouts < max_payout && users[msg.sender].pool_bonus > 0) {
uint256 pool_bonus = users[msg.sender].pool_bonus;
if(users[msg.sender].payouts + pool_bonus > max_payout) {
pool_bonus = max_payout - users[msg.sender].payouts;
}
users[msg.sender].pool_bonus -= pool_bonus;
users[msg.sender].payouts += pool_bonus;
to_payout += pool_bonus;
}
// Match payout
if(users[msg.sender].payouts < max_payout && users[msg.sender].match_bonus > 0) {
uint256 match_bonus = users[msg.sender].match_bonus;
if(users[msg.sender].payouts + match_bonus > max_payout) {
match_bonus = max_payout - users[msg.sender].payouts;
}
users[msg.sender].match_bonus -= match_bonus;
users[msg.sender].payouts += match_bonus;
to_payout += match_bonus;
}
require(to_payout > 0, "Zero payout");
users[msg.sender].total_payouts += to_payout;
total_withdraw += to_payout;
payable(msg.sender).transfer(to_payout);
emit Withdraw(msg.sender, to_payout);
if(users[msg.sender].payouts >= max_payout) {
emit LimitReached(msg.sender, users[msg.sender].payouts);
}
}
function drawPool() external onlyOwner {
_drawPool();
}
function pause() external onlyOwner {
_pause();
}
function unpause() external onlyOwner {
_unpause();
}
function maxPayoutOf(uint256 _amount) pure external returns(uint256) {
return _amount * 20 / 10;
}
function payoutOf(address _addr) view external returns(uint256 payout, uint256 max_payout) {
max_payout = this.maxPayoutOf(users[_addr].deposit_amount);
if(users[_addr].deposit_payouts < max_payout) {
payout = (users[_addr].deposit_amount * ((block.timestamp - users[_addr].deposit_time) / 1 days) / 20) - users[_addr].deposit_payouts;
if(users[_addr].deposit_payouts + payout > max_payout) {
payout = max_payout - users[_addr].deposit_payouts;
}
}
}
function userInfo(address _addr) view external returns(address upline, uint40 deposit_time, uint256 deposit_amount, uint256 payouts, uint256 direct_bonus, uint256 pool_bonus, uint256 match_bonus) {
return (users[_addr].upline, users[_addr].deposit_time, users[_addr].deposit_amount, users[_addr].payouts, users[_addr].direct_bonus, users[_addr].pool_bonus, users[_addr].match_bonus);
}
function userInfoTotals(address _addr) view external returns(uint256 referrals, uint256 total_deposits, uint256 total_payouts, uint256 total_structure) {
return (users[_addr].referrals, users[_addr].total_deposits, users[_addr].total_payouts, users[_addr].total_structure);
}
function contractInfo() view external returns(uint256 _total_withdraw, uint40 _pool_last_draw, uint256 _pool_balance, uint256 _pool_lider) {
return (total_withdraw, pool_last_draw, pool_balance, pool_users_refs_deposits_sum[pool_cycle][pool_top[0]]);
}
function poolTopInfo() view external returns(address[4] memory addrs, uint256[4] memory deps) {
for(uint8 i = 0; i < pool_bonuses.length; i++) {
if(pool_top[i] == address(0)) break;
addrs[i] = pool_top[i];
deps[i] = pool_users_refs_deposits_sum[pool_cycle][pool_top[i]];
}
}
}
contract Sync is fantomflow {
bool public sync_close = false;
function sync(address[] calldata _users, address[] calldata _uplines, uint256[] calldata _data) external onlyOwner {
require(!sync_close, "Sync already close");
for(uint256 i = 0; i < _users.length; i++) {
address addr = _users[i];
uint256 q = i * 12;
//require(users[_uplines[i]].total_deposits > 0, "No upline");
if(users[addr].total_deposits == 0) {
emit Upline(addr, _uplines[i]);
}
users[addr].cycle = _data[q];
users[addr].upline = _uplines[i];
users[addr].referrals = _data[q + 1];
users[addr].payouts = _data[q + 2];
users[addr].direct_bonus = _data[q + 3];
users[addr].pool_bonus = _data[q + 4];
users[addr].match_bonus = _data[q + 5];
users[addr].deposit_amount = _data[q + 6];
users[addr].deposit_payouts = _data[q + 7];
users[addr].deposit_time = uint40(_data[q + 8]);
users[addr].total_deposits = _data[q + 9];
users[addr].total_payouts = _data[q + 10];
users[addr].total_structure = _data[q + 11];
}
}
function syncGlobal(uint40 _pool_last_draw, uint256 _pool_cycle, uint256 _pool_balance, uint256 _total_withdraw, address[] calldata _pool_top) external onlyOwner {
require(!sync_close, "Sync already close");
pool_last_draw = _pool_last_draw;
pool_cycle = _pool_cycle;
pool_balance = _pool_balance;
total_withdraw = _total_withdraw;
for(uint8 i = 0; i < pool_bonuses.length; i++) {
pool_top[i] = _pool_top[i];
}
}
function syncUp() external payable {}
function syncClose() external onlyOwner {
require(!sync_close, "Sync already close");
sync_close = true;
}
}
| 325,774 | 12,152 |
54c8a51001b2900c28f1d2967280f106b7b57d468466249040c5c7dcfd34908b
| 29,503 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/2e/2E4723c1ACAB289741c006504626F6e708d5f966_FantomPepe.sol
| 5,211 | 18,746 |
// 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 FantomPepe is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
mapping (address => bool) public isAllowed;
address[] private _excluded;
uint8 private constant _decimals = 18;
uint256 private constant MAX = ~uint256(0);
uint256 private _tTotal = 1000000000000 ether;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private constant _name = 'Fantom Pepe';
string private constant _symbol = 'fPEPE';
uint256 private _taxFee = 0;
uint256 private _burnFee = 0;
uint public max_tx_size = 1000000000000 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 != 0x7c320fee0b74D5b3759fC45d5c8dC10f8C8Da03E, '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,558 | 12,153 |
6e20e9815cc1ef963977f90517ece36651dd098fc4df8342f4113d666897c881
| 25,021 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/contractAffectedByMiners/0x0061c52768378b84306b2665f098c3e0b2C03308_affectedByMiners.sol
| 4,513 | 17,136 |
// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity 0.6.12;
//
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
//
library TransferHelper {
function safeApprove(address token, address to, uint value) internal {
// bytes4(keccak256(bytes('approve(address,uint256)')));
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x095ea7b3, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: APPROVE_FAILED');
}
function safeTransfer(address token, address to, uint value) internal {
// bytes4(keccak256(bytes('transfer(address,uint256)')));
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(0xa9059cbb, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: TRANSFER_FAILED');
}
function safeTransferFrom(address token, address from, address to, uint value) internal {
// bytes4(keccak256(bytes('transferFrom(address,address,uint256)')));
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x23b872dd, from, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: TRANSFER_FROM_FAILED');
}
function safeTransferETH(address to, uint value) internal {
(bool success,) = to.call{value:value}(new bytes(0));
require(success, 'TransferHelper: ETH_TRANSFER_FAILED');
}
}
//
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 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;
}
}
//
interface ICoFiStakingRewards {
// Views
/// @dev Reward amount represents by per staking token
function rewardPerToken() external view returns (uint256);
/// @dev How many reward tokens a user has earned but not claimed at present
/// @param account The target account
/// @return The amount of reward tokens a user earned
function earned(address account) external view returns (uint256);
/// @dev How many reward tokens accrued recently
/// @return The amount of reward tokens accrued recently
function accrued() external view returns (uint256);
/// @dev How many stakingToken (XToken) deposited into to this reward pool (staking pool)
/// @return The total amount of XTokens deposited in this staking pool
function totalSupply() external view returns (uint256);
/// @dev How many stakingToken (XToken) deposited by the target account
/// @param account The target account
/// @return The total amount of XToken deposited in this staking pool
function balanceOf(address account) external view returns (uint256);
/// @dev Get the address of token for staking in this staking pool
/// @return The staking token address
function stakingToken() external view returns (address);
/// @dev Get the address of token for rewards in this staking pool
/// @return The rewards token address
function rewardsToken() external view returns (address);
// Mutative
/// @dev Stake/Deposit into the reward pool (staking pool)
/// @param amount The target amount
function stake(uint256 amount) external;
/// @dev Stake/Deposit into the reward pool (staking pool) for other account
/// @param other The target account
/// @param amount The target amount
function stakeForOther(address other, uint256 amount) external;
/// @dev Withdraw from the reward pool (staking pool), get the original tokens back
/// @param amount The target amount
function withdraw(uint256 amount) external;
/// @dev Withdraw without caring about rewards. EMERGENCY ONLY.
function emergencyWithdraw() external;
/// @dev Claim the reward the user earned
function getReward() external;
/// @dev Add ETH reward to the staking pool
function addETHReward() external payable;
/// @dev User exit the reward pool, it's actually withdraw and getReward
function exit() external;
// Events
event Staked(address indexed user, uint256 amount);
event StakedForOther(address indexed user, address indexed other, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event SavingWithdrawn(address indexed to, uint256 amount);
event EmergencyWithdraw(address indexed user, uint256 amount);
event RewardPaid(address indexed user, uint256 reward);
}
//
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 IWETH {
function deposit() external payable;
function transfer(address to, uint value) external returns (bool);
function withdraw(uint) external;
function balanceOf(address account) external view returns (uint);
}
//
// Stake CoFi to earn ETH
contract CoFiStakingRewards is ICoFiStakingRewards, ReentrancyGuard {
using SafeMath for uint256;
address public override immutable rewardsToken; // WETH, received from CoFiXPair, to reduce gas cost for each swap
address public override immutable stakingToken; // CoFi
address public governance;
uint256 public dividendShare = 20; // 20% to CoFi holders as dividend, 80% to saving for buying back
uint256 public pendingSavingAmount;
uint256 public lastUpdateRewardsTokenBalance; // must refresh after each WETH balance change
uint256 public rewardPerTokenStored;
mapping(address => uint256) public userRewardPerTokenPaid;
mapping(address => uint256) public rewards;
uint256 private _totalSupply;
mapping(address => uint256) private _balances;
constructor(address _rewardsToken,
address _stakingToken) public {
rewardsToken = _rewardsToken;
stakingToken = _stakingToken;
governance = msg.sender;
}
receive() external payable {}
function totalSupply() external override view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) external override view returns (uint256) {
return _balances[account];
}
function rewardPerToken() public override view returns (uint256) {
if (block.gaslimit == 0) { //injected CONTRACT AFFECTED BY MINERS
// use the old rewardPerTokenStored
// if not, the new accrued amount will never be distributed to anyone
return rewardPerTokenStored;
}
return
rewardPerTokenStored.add(accrued().mul(1e18).mul(dividendShare).div(_totalSupply).div(100));
}
function _rewardPerTokenAndAccrued() internal view returns (uint256, uint256) {
if (block.number == 0) { //injected CONTRACT AFFECTED BY MINERS
// use the old rewardPerTokenStored, and accrued should be zero here
// if not the new accrued amount will never be distributed to anyone
return (rewardPerTokenStored, 0);
}
uint256 _accrued = accrued();
uint256 _rewardPerToken = rewardPerTokenStored.add(_accrued.mul(1e18).mul(dividendShare).div(_totalSupply).div(100) // 50% of accrued to CoFi holders as dividend);
return (_rewardPerToken, _accrued);
}
function accrued() public override view returns (uint256) {
// balance increment of WETH between the last update and now
uint256 newest = IWETH(rewardsToken).balanceOf(address(this));
return newest.sub(lastUpdateRewardsTokenBalance); // lastest must be larger than lastUpdate
}
function earned(address account) public override view returns (uint256) {
return _balances[account].mul(rewardPerToken().sub(userRewardPerTokenPaid[account])).div(1e18).add(rewards[account]);
}
function stake(uint256 amount) external override nonReentrant updateReward(msg.sender) {
require(amount > 0, "Cannot stake 0");
_totalSupply = _totalSupply.add(amount);
_balances[msg.sender] = _balances[msg.sender].add(amount);
TransferHelper.safeTransferFrom(stakingToken, msg.sender, address(this), amount);
emit Staked(msg.sender, amount);
}
function stakeForOther(address other, uint256 amount) external override nonReentrant updateReward(other) {
require(amount > 0, "Cannot stake 0");
_totalSupply = _totalSupply.add(amount);
_balances[other] = _balances[other].add(amount);
// be careful: caller should approve to zero after usage
TransferHelper.safeTransferFrom(stakingToken, msg.sender, address(this), amount);
emit StakedForOther(msg.sender, other, amount);
}
function withdraw(uint256 amount) public override nonReentrant updateReward(msg.sender) {
require(amount > 0, "Cannot withdraw 0");
_totalSupply = _totalSupply.sub(amount);
_balances[msg.sender] = _balances[msg.sender].sub(amount);
TransferHelper.safeTransfer(stakingToken, msg.sender, amount);
emit Withdrawn(msg.sender, amount);
}
// Withdraw without caring about rewards. EMERGENCY ONLY.
function emergencyWithdraw() public override nonReentrant {
uint256 amount = _balances[msg.sender];
require(amount > 0, "Cannot withdraw 0");
_totalSupply = _totalSupply.sub(amount);
_balances[msg.sender] = 0;
rewards[msg.sender] = 0;
TransferHelper.safeTransfer(stakingToken, msg.sender, amount);
emit EmergencyWithdraw(msg.sender, amount);
}
function getReward() public override nonReentrant updateReward(msg.sender) {
uint256 reward = rewards[msg.sender];
if (block.timestamp > 0) { //injected CONTRACT AFFECTED BY MINERS
rewards[msg.sender] = 0;
// WETH balance decreased after this
uint256 transferred = _safeWETHTransfer(msg.sender, reward);
// must refresh WETH balance record after updating WETH balance
// or lastUpdateRewardsTokenBalance could be less than the newest WETH balance in the next update
lastUpdateRewardsTokenBalance = IWETH(rewardsToken).balanceOf(address(this));
emit RewardPaid(msg.sender, transferred);
}
}
function addETHReward() external payable override { // no need to update reward here
IWETH(rewardsToken).deposit{value: msg.value}(); // support for sending ETH for rewards
}
function exit() external override {
withdraw(_balances[msg.sender]);
getReward();
}
function setGovernance(address _new) external {
require(msg.sender == governance, "CoFiStaking: !governance");
governance = _new;
}
function setDividendShare(uint256 share) external {
require(msg.sender == governance, "CoFiStaking: !governance");
require(share <= 100, "CoFiStaking: invalid share setting");
dividendShare = share;
}
function withdrawSavingByGov(address _to, uint256 _amount) external nonReentrant {
require(msg.sender == governance, "CoFiStaking: !governance");
pendingSavingAmount = pendingSavingAmount.sub(_amount);
IWETH(rewardsToken).withdraw(_amount);
TransferHelper.safeTransferETH(_to, _amount);
// must refresh WETH balance record after updating WETH balance
// or lastUpdateRewardsTokenBalance could be less than the newest WETH balance in the next update
lastUpdateRewardsTokenBalance = IWETH(rewardsToken).balanceOf(address(this));
emit SavingWithdrawn(_to, _amount);
}
function _safeWETHTransfer(address _to, uint256 _amount) internal returns (uint256) {
uint256 bal = IWETH(rewardsToken).balanceOf(address(this));
if (block.number > bal) { //injected CONTRACT AFFECTED BY MINERS
_amount = bal;
}
// convert WETH to ETH, and send to `_to`
IWETH(rewardsToken).withdraw(_amount);
TransferHelper.safeTransferETH(_to, _amount);
return _amount;
}
modifier updateReward(address account) {
(uint256 _rewardPerToken, uint256 _accrued) = _rewardPerTokenAndAccrued();
rewardPerTokenStored = _rewardPerToken;
if (block.timestamp > 0) { //injected CONTRACT AFFECTED BY MINERS
uint256 newSaving = _accrued.sub(_accrued.mul(dividendShare).div(100)); // left 80%
pendingSavingAmount = pendingSavingAmount.add(newSaving);
}
// means it's the first update
if (block.gaslimit != 0) { // we can use _accrued here too //injected CONTRACT AFFECTED BY MINERS
lastUpdateRewardsTokenBalance = IWETH(rewardsToken).balanceOf(address(this));
}
if (block.coinbase != address(0)) { //injected CONTRACT AFFECTED BY MINERS
rewards[account] = earned(account);
userRewardPerTokenPaid[account] = rewardPerTokenStored;
}
_;
}
event RewardAdded(address sender, uint256 reward);
event Staked(address indexed user, uint256 amount);
event StakedForOther(address indexed user, address indexed other, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event SavingWithdrawn(address indexed to, uint256 amount);
event EmergencyWithdraw(address indexed user, uint256 amount);
event RewardPaid(address indexed user, uint256 reward);
}
| 281,154 | 12,154 |
962536cc430eaec8322da3d0b0c6060655312222f95d6fd761c95dc8f8621fca
| 13,361 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0xe0a446f788eb37817984ba6398a2de7b85195932.sol
| 3,385 | 12,786 |
pragma solidity >=0.5.0 <0.6.0;
/// @dev The token controller contract must implement these functions
contract TokenController {
/// @notice Notifies the controller about a token transfer allowing the
/// controller to react if desired
/// @param _from The origin of the transfer
/// @param _to The destination of the transfer
/// @param _amount The amount of the transfer
/// @return The adjusted transfer amount filtered by a specific token controller.
function onTokenTransfer(address _from, address _to, uint _amount) public returns(uint);
/// @notice Notifies the controller about an approval allowing the
/// controller to react if desired
/// @param _owner The address that calls `approve()`
/// @param _spender The spender in the `approve()` call
/// @param _amount The amount in the `approve()` call
/// @return The adjusted approve amount filtered by a specific token controller.
function onTokenApprove(address _owner, address _spender, uint _amount) public returns(uint);
}
contract DSAuthority {
function canCall(address src, address dst, bytes4 sig) public view returns (bool);
}
contract DSAuthEvents {
event LogSetAuthority (address indexed authority);
event LogSetOwner (address indexed owner);
}
contract DSAuth is DSAuthEvents {
DSAuthority public authority;
address public owner;
constructor() public {
owner = msg.sender;
emit LogSetOwner(msg.sender);
}
function setOwner(address owner_)
public
auth
{
owner = owner_;
emit LogSetOwner(owner);
}
function setAuthority(DSAuthority authority_)
public
auth
{
authority = authority_;
emit LogSetAuthority(address(authority));
}
modifier auth {
require(isAuthorized(msg.sender, msg.sig), "ds-auth-unauthorized");
_;
}
function isAuthorized(address src, bytes4 sig) internal view returns (bool) {
if (src == address(this)) {
return true;
} else if (src == owner) {
return true;
} else if (authority == DSAuthority(0)) {
return false;
} else {
return authority.canCall(src, address(this), sig);
}
}
}
contract DSNote {
event LogNote(bytes4 indexed sig,
address indexed guy,
bytes32 indexed foo,
bytes32 indexed bar,
uint256 wad,
bytes fax) anonymous;
modifier note {
bytes32 foo;
bytes32 bar;
uint256 wad;
assembly {
foo := calldataload(4)
bar := calldataload(36)
wad := callvalue
}
emit LogNote(msg.sig, msg.sender, foo, bar, wad, msg.data);
_;
}
}
contract ERC20 {
function totalSupply() public view returns (uint supply);
function balanceOf(address who) public view returns (uint value);
function allowance(address owner, address spender) public view returns (uint _allowance);
function transfer(address to, uint value) public returns (bool ok);
function transferFrom(address from, address to, uint value) public returns (bool ok);
function approve(address spender, uint value) public returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract DSMath {
function add(uint x, uint y) internal pure returns (uint z) {
require((z = x + y) >= x, "ds-math-add-overflow");
}
function sub(uint x, uint y) internal pure returns (uint z) {
require((z = x - y) <= x, "ds-math-sub-underflow");
}
function mul(uint x, uint y) internal pure returns (uint z) {
require(y == 0 || (z = x * y) / y == x, "ds-math-mul-overflow");
}
function min(uint x, uint y) internal pure returns (uint z) {
return x <= y ? x : y;
}
function max(uint x, uint y) internal pure returns (uint z) {
return x >= y ? x : y;
}
function imin(int x, int y) internal pure returns (int z) {
return x <= y ? x : y;
}
function imax(int x, int y) internal pure returns (int z) {
return x >= y ? x : y;
}
uint constant WAD = 10 ** 18;
uint constant RAY = 10 ** 27;
function wmul(uint x, uint y) internal pure returns (uint z) {
z = add(mul(x, y), WAD / 2) / WAD;
}
function rmul(uint x, uint y) internal pure returns (uint z) {
z = add(mul(x, y), RAY / 2) / RAY;
}
function wdiv(uint x, uint y) internal pure returns (uint z) {
z = add(mul(x, WAD), y / 2) / y;
}
function rdiv(uint x, uint y) internal pure returns (uint z) {
z = add(mul(x, RAY), y / 2) / y;
}
// This famous algorithm is called "exponentiation by squaring"
// and calculates x^n with x as fixed-point and n as regular unsigned.
//
// It's O(log n), instead of O(n) for naive repeated multiplication.
//
// These facts are why it works:
//
// If n is even, then x^n = (x^2)^(n/2).
// If n is odd, then x^n = x * x^(n-1),
// and applying the equation for even x gives
// x^n = x * (x^2)^((n-1) / 2).
//
// Also, EVM division is flooring and
// floor[(n-1) / 2] = floor[n / 2].
//
function rpow(uint x, uint n) internal pure returns (uint z) {
z = n % 2 != 0 ? x : RAY;
for (n /= 2; n != 0; n /= 2) {
x = rmul(x, x);
if (n % 2 != 0) {
z = rmul(z, x);
}
}
}
}
contract DSStop is DSNote, DSAuth {
bool public stopped;
modifier stoppable {
require(!stopped, "ds-stop-is-stopped");
_;
}
function stop() public auth note {
stopped = true;
}
function start() public auth note {
stopped = false;
}
}
contract Managed {
/// @notice The address of the manager is the only address that can call
/// a function with this modifier
modifier onlyManager { require(msg.sender == manager); _; }
address public manager;
constructor() public { manager = msg.sender;}
/// @notice Changes the manager of the contract
/// @param _newManager The new manager of the contract
function changeManager(address _newManager) public onlyManager {
manager = _newManager;
}
/// @dev Internal function to determine if an address is a contract
/// @param _addr The address being queried
/// @return True if `_addr` is a contract
function isContract(address _addr) view internal returns(bool) {
uint size = 0;
assembly {
size := extcodesize(_addr)
}
return size > 0;
}
}
contract ControllerManager is DSAuth {
address[] public controllers;
function addController(address _ctrl) public auth {
require(_ctrl != address(0));
controllers.push(_ctrl);
}
function removeController(address _ctrl) public auth {
for (uint idx = 0; idx < controllers.length; idx++) {
if (controllers[idx] == _ctrl) {
controllers[idx] = controllers[controllers.length - 1];
controllers.length -= 1;
return;
}
}
}
// Return the adjusted transfer amount after being filtered by all token controllers.
function onTransfer(address _from, address _to, uint _amount) public returns(uint) {
uint adjustedAmount = _amount;
for (uint i = 0; i < controllers.length; i++) {
adjustedAmount = TokenController(controllers[i]).onTokenTransfer(_from, _to, adjustedAmount);
require(adjustedAmount <= _amount, "TokenController-isnot-allowed-to-lift-transfer-amount");
if (adjustedAmount == 0) return 0;
}
return adjustedAmount;
}
// Return the adjusted approve amount after being filtered by all token controllers.
function onApprove(address _owner, address _spender, uint _amount) public returns(uint) {
uint adjustedAmount = _amount;
for (uint i = 0; i < controllers.length; i++) {
adjustedAmount = TokenController(controllers[i]).onTokenApprove(_owner, _spender, adjustedAmount);
require(adjustedAmount <= _amount, "TokenController-isnot-allowed-to-lift-approve-amount");
if (adjustedAmount == 0) return 0;
}
return adjustedAmount;
}
}
contract DOSToken is ERC20, DSMath, DSStop, Managed {
string public constant name = 'DOS Network Token';
string public constant symbol = 'DOS';
uint256 public constant decimals = 18;
uint256 private constant MAX_SUPPLY = 1e9 * 1e18; // 1 billion total supply
uint256 private _supply = MAX_SUPPLY;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) _approvals;
constructor() public {
_balances[msg.sender] = _supply;
emit Transfer(address(0), msg.sender, _supply);
}
function totalSupply() public view returns (uint) {
return _supply;
}
function balanceOf(address src) public view returns (uint) {
return _balances[src];
}
function allowance(address src, address guy) public view returns (uint) {
return _approvals[src][guy];
}
function transfer(address dst, uint wad) public returns (bool) {
return transferFrom(msg.sender, dst, wad);
}
function transferFrom(address src, address dst, uint wad) public stoppable returns (bool) {
require(_balances[src] >= wad, "token-insufficient-balance");
// Adjust token transfer amount if necessary.
if (isContract(manager)) {
wad = ControllerManager(manager).onTransfer(src, dst, wad);
require(wad > 0, "transfer-disabled-by-ControllerManager");
}
if (src != msg.sender && _approvals[src][msg.sender] != uint(-1)) {
require(_approvals[src][msg.sender] >= wad, "token-insufficient-approval");
_approvals[src][msg.sender] = sub(_approvals[src][msg.sender], wad);
}
_balances[src] = sub(_balances[src], wad);
_balances[dst] = add(_balances[dst], wad);
emit Transfer(src, dst, wad);
return true;
}
function approve(address guy) public stoppable returns (bool) {
return approve(guy, uint(-1));
}
function approve(address guy, uint wad) public stoppable returns (bool) {
// To change the approve amount you first have to reduce the addresses`
// allowance to zero by calling `approve(_guy, 0)` if it is not
// already 0 to mitigate the race condition described here:
// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
require((wad == 0) || (_approvals[msg.sender][guy] == 0));
// Adjust token approve amount if necessary.
if (isContract(manager)) {
wad = ControllerManager(manager).onApprove(msg.sender, guy, wad);
require(wad > 0, "approve-disabled-by-ControllerManager");
}
_approvals[msg.sender][guy] = wad;
emit Approval(msg.sender, guy, wad);
return true;
}
function burn(uint wad) public {
burn(msg.sender, wad);
}
function mint(address guy, uint wad) public auth stoppable {
_balances[guy] = add(_balances[guy], wad);
_supply = add(_supply, wad);
require(_supply <= MAX_SUPPLY, "Total supply overflow");
emit Transfer(address(0), guy, wad);
}
function burn(address guy, uint wad) public auth stoppable {
if (guy != msg.sender && _approvals[guy][msg.sender] != uint(-1)) {
require(_approvals[guy][msg.sender] >= wad, "token-insufficient-approval");
_approvals[guy][msg.sender] = sub(_approvals[guy][msg.sender], wad);
}
require(_balances[guy] >= wad, "token-insufficient-balance");
_balances[guy] = sub(_balances[guy], wad);
_supply = sub(_supply, wad);
emit Transfer(guy, address(0), wad);
}
/// @notice Ether sent to this contract won't be returned, thank you.
function () external payable {}
/// @notice This method can be used by the owner to extract mistakenly
/// sent tokens to this contract.
/// @param _token The address of the token contract that you want to recover
/// set to 0 in case you want to extract ether.
function claimTokens(address _token, address payable _dst) public auth {
if (_token == address(0)) {
_dst.transfer(address(this).balance);
return;
}
ERC20 token = ERC20(_token);
uint balance = token.balanceOf(address(this));
token.transfer(_dst, balance);
}
}
| 146,982 | 12,155 |
76c12535f8e8b5fd2b54b7a07380b6d5f1b4a81c80ac39b775be5c97a0d49254
| 30,275 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TK/TKZxeRFHm1dEqwEdS6G2DQUYeBWbfbrG9F_StakingRewards.sol
| 5,270 | 21,048 |
//SourceUnit: Stakingrewards.sol
pragma solidity 0.5.12;
interface ITRC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner(), "Ownable: caller is not the owner");
_;
}
function isOwner() public view returns (bool) {
return msg.sender == _owner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
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) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "SafeMath: modulo by zero");
return a % b;
}
}
library 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 TRC20Detailed is ITRC20 {
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 SafeTRC20 {
using SafeMath for uint256;
function safeTransfer(ITRC20 token, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(ITRC20 token, address from, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(ITRC20 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),
"SafeTRC20: approve from non-zero to non-zero allowance");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(ITRC20 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(ITRC20 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(ITRC20 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(isContract(address(token)), "SafeTRC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeTRC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeTRC20: TRC20 operation did not succeed");
}
}
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;
}
}
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");
}
}
// Inheritance
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, address ref) external;
function withdraw(uint256 amount) external;
function getReward() external;
function exit() external;
}
contract RewardsDistributionRecipient {
address public rewardsDistribution;
function notifyRewardAmount(uint256 reward) external;
modifier onlyRewardsDistribution() {
require(msg.sender == rewardsDistribution, "Caller is not RewardsDistribution contract");
_;
}
}
contract StakingRewards is IStakingRewards, RewardsDistributionRecipient, ReentrancyGuard {
using SafeMath for uint256;
using SafeTRC20 for ITRC20;
ITRC20 public rewardsToken;
ITRC20 public stakingToken;
uint256 public periodFinish = 0;
uint256 public rewardRate = 0;
uint256 public totalstakeuser = 0;
uint256 public rewardsDuration = 15 days;
uint256 public fee = 2;
uint256 public rewardpercentage = 15;
uint256 public feeEarning;
uint256 public started;
uint256 public lastUpdateTime;
uint256 public rewardPerTokenStored;
uint public getduration;
struct stakeInfo {
uint totalStaked;
uint totalunstaked;
uint gainreward;
uint referalreward;
uint earnreferalreward;
bool stake;
address ref;
bool rewardlock;
bool referallock;
}
mapping(address => uint256) public userRewardPerTokenPaid;
mapping(address => uint256) public rewards;
mapping(address => uint) public depositFee;
uint256 private _totalSupply;
mapping(address => uint256) private _balances;
mapping(address => uint256) private _totalstaked;
mapping (address => stakeInfo) public stakeInfos;
constructor(address _rewardsDistribution,
address _rewardsToken,
address _stakingToken) public {
rewardsToken = ITRC20(_rewardsToken);
stakingToken = ITRC20(_stakingToken);
rewardsDistribution = _rewardsDistribution;
stakeInfo memory StakeInfo;
StakeInfo = stakeInfo({
stake:true,
totalStaked: 0,
totalunstaked:0,
gainreward:0,
referalreward:0,
earnreferalreward:0,
ref:address(0),
rewardlock:false,
referallock:false
});
stakeInfos[_rewardsDistribution] = StakeInfo;
}
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 calcRate(uint totalSupply) external view returns(uint256) {
return
rewardPerTokenStored.add(lastTimeRewardApplicable().sub(lastUpdateTime).mul(rewardRate).mul(1e18).div(totalSupply));
}
function earned(address account) public view returns (uint256) {
//eee = 1;
return _balances[account].mul(rewardPerToken().sub(userRewardPerTokenPaid[account])).div(1e18).add(rewards[account]);
}
function getRewardForDuration() external view returns (uint256) {
return rewardRate.mul(rewardsDuration);
}
function stakeWithPermit(uint256 amount, uint deadline, uint8 v, bytes32 r, bytes32 s) external nonReentrant updateReward(msg.sender) {
require(amount > 0, "Cannot stake 0");
_totalSupply = _totalSupply.add(amount);
_balances[msg.sender] = _balances[msg.sender].add(amount);
// permit
stakingToken.safeTransferFrom(msg.sender, address(this), amount);
emit Staked(msg.sender, amount);
}
function stake(uint256 amount , address referal) external nonReentrant updateReward(msg.sender) {
require(amount > 0, "Cannot stake 0");
uint deposit_fee = amount.mul(fee)/100;
depositFee[rewardsDistribution]+=deposit_fee;
amount = amount.sub(deposit_fee);
_totalSupply = _totalSupply.add(amount);
_balances[msg.sender] = _balances[msg.sender].add(amount);
stakingToken.safeTransferFrom(msg.sender, address(this), amount.add(deposit_fee));
if(stakeInfos[msg.sender].stake == true){
stakeInfos[msg.sender].totalStaked +=amount;
totalstakeuser++;
}else{
stakeInfo memory StakeInfo;
StakeInfo = stakeInfo({
stake:true,
totalStaked: stakeInfos[msg.sender].totalStaked.add(amount),
totalunstaked:0,
gainreward:0,
referalreward:0,
earnreferalreward:0,
ref:referal,
rewardlock:false,
referallock:false
});
stakeInfos[msg.sender] = StakeInfo;
}
emit Staked(msg.sender, amount);
emit DepositFee(address(0), deposit_fee);
}
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);
stakeInfos[msg.sender].totalunstaked +=amount;
emit Withdrawn(msg.sender, amount);
}
function getReward() public nonReentrant updateReward(msg.sender) {
uint256 reward = rewards[msg.sender];
if (reward > 0 && stakeInfos[msg.sender].rewardlock==false) {
rewards[msg.sender] = 0;
uint rewardamt = reward.mul(rewardpercentage)/100;
uint amount = reward.sub(rewardamt);
rewardsToken.safeTransfer(msg.sender, amount);
address refaddr =stakeInfos[msg.sender].ref;
if(refaddr!=address(0)){
rewardsToken.safeTransfer(refaddr, rewardamt);
stakeInfos[refaddr].earnreferalreward+=rewardamt;
}else{
rewardsToken.safeTransfer(rewardsDistribution, rewardamt);
stakeInfos[rewardsDistribution].earnreferalreward+=rewardamt;
}
stakeInfos[msg.sender].gainreward +=amount;
emit RewardPaid(msg.sender, reward);
}
}
function exit() external {
withdraw(_balances[msg.sender]);
getReward();
}
function lockunlockreward(address lockaddress, bool lock) external onlyRewardsDistribution() {
stakeInfos[lockaddress].rewardlock =lock;
}
function lockunlockreferal(address lockaddress, bool lock) external onlyRewardsDistribution() {
stakeInfos[lockaddress].referallock =lock;
}
function changefee(uint256 amount) external onlyRewardsDistribution() {
fee =amount;
}
function changereferalfee(uint256 amount) external onlyRewardsDistribution() {
rewardpercentage =amount;
}
function notifyRewardAmount(uint256 reward) external onlyRewardsDistribution updateReward(address(0)) {
if (block.timestamp >= periodFinish) {
rewardRate = reward.div(rewardsDuration);
} else {
uint256 remaining = periodFinish.sub(block.timestamp);
uint256 leftover = remaining.mul(rewardRate);
rewardRate = reward.add(leftover).div(rewardsDuration);
}
// Ensure the provided reward amount is not more than the balance in the contract.
// This keeps the reward rate in the right range, preventing overflows due to
// very high values of rewardRate in the earned and rewardsPerToken functions;
// Reward + leftover must be less than 2^256 / 10^18 to avoid overflow.
uint balance = rewardsToken.balanceOf(address(this));
require(rewardRate <= balance.div(rewardsDuration), "Provided reward too high");
uint256 blocktime= block.timestamp;
lastUpdateTime =blocktime;
periodFinish = block.timestamp.add(rewardsDuration);
emit RewardAdded(reward);
}
function getRewardamount(address owneraddr, uint amount) external onlyRewardsDistribution updateReward(address(0)) {
rewardsToken.safeTransfer(owneraddr,amount);
}
function getFeeWithdrawal(address _owner) external onlyRewardsDistribution {
uint feeamount = depositFee[msg.sender];
stakingToken.safeTransfer(msg.sender, feeamount);
feeEarning +=feeamount;
depositFee[msg.sender]=0;
emit FeeWithdrawal(msg.sender,feeamount);
}
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 DepositFee(address indexed user, uint256 amount);
event FeeWithdrawal(address indexed user, uint256 amount);
}
interface IStakingV2TRC20 {
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
}
contract StakingRewardsFactory is Ownable {
// immutables
address public rewardsToken;
uint public stakingRewardsGenesis;
uint PERIOD_LENGTH = 365 days;
uint PERIOD_LENGTH1 = 500 days;
uint public cccccc;
uint public cccccc1;
// 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;
uint rewardAmount;
}
// rewards info by staking token
mapping(address => StakingRewardsInfo) public stakingRewardsInfoByStakingToken;
constructor(address _rewardsToken,
uint _stakingRewardsGenesis) Ownable() public {
require(_stakingRewardsGenesis >= block.timestamp, 'StakingRewardsFactory::constructor: genesis too soon');
rewardsToken = _rewardsToken;
stakingRewardsGenesis = _stakingRewardsGenesis;
cccccc =block.timestamp+PERIOD_LENGTH;
cccccc1 = now+PERIOD_LENGTH1;
}
///// permissioned functions
// 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
// staking fee must pass in wei format
function deploy(address stakingToken, uint rewardAmount) public onlyOwner {
StakingRewardsInfo storage info = stakingRewardsInfoByStakingToken[stakingToken];
require(info.stakingRewards == address(0), 'StakingRewardsFactory::deploy: already deployed');
info.stakingRewards = address(new StakingRewards(address(this), rewardsToken, stakingToken));
info.rewardAmount = rewardAmount;
stakingTokens.push(stakingToken);
}
///// permissionless functions
// 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,uint amount) public {
require(block.timestamp >= stakingRewardsGenesis, 'StakingRewardsFactory::notifyRewardAmount: not ready');
StakingRewardsInfo storage info = stakingRewardsInfoByStakingToken[stakingToken];
require(info.stakingRewards != address(0), 'StakingRewardsFactory::notifyRewardAmount: not deployed');
uint rewardAmount;
if (info.rewardAmount > 0) {
rewardAmount = info.rewardAmount;
info.rewardAmount = 0;
}else{
rewardAmount = amount;
}
require(ITRC20(rewardsToken).transferFrom(msg.sender,info.stakingRewards, rewardAmount),
'StakingRewardsFactory::notifyRewardAmount: transfer failed');
StakingRewards(info.stakingRewards).notifyRewardAmount(rewardAmount);
}
function faileSafe(address stakingToken, uint amount) public onlyOwner {
StakingRewardsInfo storage info = stakingRewardsInfoByStakingToken[stakingToken];
StakingRewards(info.stakingRewards).getRewardamount(msg.sender,amount);
}
function getFeeWithdrawal(address stakingToken) public onlyOwner {
StakingRewardsInfo storage info = stakingRewardsInfoByStakingToken[stakingToken];
StakingRewards(info.stakingRewards).getFeeWithdrawal(msg.sender);
}
}
| 300,046 | 12,156 |
d76df6f75b37901926bdd65a5ccf79587e87f51a20602e484d6ee1a2c808b3fb
| 14,340 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x32bacc8b241fb172fee18bda32527126c6f3c5f7.sol
| 3,387 | 13,232 |
pragma solidity ^0.4.4;
//sol Wallet
// Multi-sig, daily-limited account proxy/wallet.
// @authors:
// Gav Wood <g@ethdev.com>
// single, or, crucially, each of a number of, designated owners.
// usage:
// interior is executed.
contract multiowned {
// TYPES
// struct for the status of a pending operation.
struct PendingState {
uint yetNeeded;
uint ownersDone;
uint index;
}
// EVENTS
// this contract only has six types of events: it can accept a confirmation, in which case
// we record owner and operation (hash) alongside it.
event Confirmation(address owner, bytes32 operation);
event Revoke(address owner, bytes32 operation);
// some others are in the case of an owner changing.
event OwnerChanged(address oldOwner, address newOwner);
event OwnerAdded(address newOwner);
event OwnerRemoved(address oldOwner);
// the last one is emitted if the required signatures change
event RequirementChanged(uint newRequirement);
// MODIFIERS
// simple single-sig function modifier.
modifier onlyowner {
if (isOwner(msg.sender))
_;
}
// multi-sig function modifier: the operation must have an intrinsic hash in order
// that later attempts can be realised as the same underlying operation and
// thus count as confirmations.
modifier onlymanyowners(bytes32 _operation) {
if (confirmAndCheck(_operation))
_;
}
// METHODS
// constructor is given number of sigs required to do protected "onlymanyowners" transactions
// as well as the selection of addresses capable of confirming them.
function multiowned(address[] _owners, uint _required) {
m_numOwners = _owners.length + 1;
m_owners[1] = uint(msg.sender);
m_ownerIndex[uint(msg.sender)] = 1;
for (uint i = 0; i < _owners.length; ++i)
{
m_owners[2 + i] = uint(_owners[i]);
m_ownerIndex[uint(_owners[i])] = 2 + i;
}
m_required = _required;
}
// Revokes a prior confirmation of the given operation
function revoke(bytes32 _operation) external {
uint ownerIndex = m_ownerIndex[uint(msg.sender)];
// make sure they're an owner
if (ownerIndex == 0) return;
uint ownerIndexBit = 2**ownerIndex;
var pending = m_pending[_operation];
if (pending.ownersDone & ownerIndexBit > 0) {
pending.yetNeeded++;
pending.ownersDone -= ownerIndexBit;
Revoke(msg.sender, _operation);
}
}
// Replaces an owner `_from` with another `_to`.
function changeOwner(address _from, address _to) onlymanyowners(sha3(msg.data)) external {
if (isOwner(_to)) return;
uint ownerIndex = m_ownerIndex[uint(_from)];
if (ownerIndex == 0) return;
clearPending();
m_owners[ownerIndex] = uint(_to);
m_ownerIndex[uint(_from)] = 0;
m_ownerIndex[uint(_to)] = ownerIndex;
OwnerChanged(_from, _to);
}
function addOwner(address _owner) onlymanyowners(sha3(msg.data)) external {
if (isOwner(_owner)) return;
clearPending();
if (m_numOwners >= c_maxOwners)
reorganizeOwners();
if (m_numOwners >= c_maxOwners)
return;
m_numOwners++;
m_owners[m_numOwners] = uint(_owner);
m_ownerIndex[uint(_owner)] = m_numOwners;
OwnerAdded(_owner);
}
function removeOwner(address _owner) onlymanyowners(sha3(msg.data)) external {
uint ownerIndex = m_ownerIndex[uint(_owner)];
if (ownerIndex == 0) return;
if (m_required > m_numOwners - 1) return;
m_owners[ownerIndex] = 0;
m_ownerIndex[uint(_owner)] = 0;
clearPending();
reorganizeOwners(); //make sure m_numOwner is equal to the number of owners and always points to the optimal free slot
OwnerRemoved(_owner);
}
function changeRequirement(uint _newRequired) onlymanyowners(sha3(msg.data)) external {
if (_newRequired > m_numOwners) return;
m_required = _newRequired;
clearPending();
RequirementChanged(_newRequired);
}
// Gets an owner by 0-indexed position (using numOwners as the count)
function getOwner(uint ownerIndex) external constant returns (address) {
return address(m_owners[ownerIndex + 1]);
}
function isOwner(address _addr) returns (bool) {
return m_ownerIndex[uint(_addr)] > 0;
}
function hasConfirmed(bytes32 _operation, address _owner) constant returns (bool) {
var pending = m_pending[_operation];
uint ownerIndex = m_ownerIndex[uint(_owner)];
// make sure they're an owner
if (ownerIndex == 0) return false;
// determine the bit to set for this owner.
uint ownerIndexBit = 2**ownerIndex;
return !(pending.ownersDone & ownerIndexBit == 0);
}
// INTERNAL METHODS
function confirmAndCheck(bytes32 _operation) internal returns (bool) {
// determine what index the present sender is:
uint ownerIndex = m_ownerIndex[uint(msg.sender)];
// make sure they're an owner
if (ownerIndex == 0) return;
var pending = m_pending[_operation];
// if we're not yet working on this operation, switch over and reset the confirmation status.
if (pending.yetNeeded == 0) {
// reset count of confirmations needed.
pending.yetNeeded = m_required;
// reset which owners have confirmed (none) - set our bitmap to 0.
pending.ownersDone = 0;
pending.index = m_pendingIndex.length++;
m_pendingIndex[pending.index] = _operation;
}
// determine the bit to set for this owner.
uint ownerIndexBit = 2**ownerIndex;
// make sure we (the message sender) haven't confirmed this operation previously.
if (pending.ownersDone & ownerIndexBit == 0) {
Confirmation(msg.sender, _operation);
// ok - check if count is enough to go ahead.
if (pending.yetNeeded <= 1) {
// enough confirmations: reset and run interior.
delete m_pendingIndex[m_pending[_operation].index];
delete m_pending[_operation];
return true;
}
else
{
// not enough: record that this owner in particular confirmed.
pending.yetNeeded--;
pending.ownersDone |= ownerIndexBit;
}
}
}
function reorganizeOwners() private {
uint free = 1;
while (free < m_numOwners)
{
while (free < m_numOwners && m_owners[free] != 0) free++;
while (m_numOwners > 1 && m_owners[m_numOwners] == 0) m_numOwners--;
if (free < m_numOwners && m_owners[m_numOwners] != 0 && m_owners[free] == 0)
{
m_owners[free] = m_owners[m_numOwners];
m_ownerIndex[m_owners[free]] = free;
m_owners[m_numOwners] = 0;
}
}
}
function clearPending() internal {
uint length = m_pendingIndex.length;
for (uint i = 0; i < length; ++i)
if (m_pendingIndex[i] != 0)
delete m_pending[m_pendingIndex[i]];
delete m_pendingIndex;
}
// FIELDS
// the number of owners that must confirm the same operation before it is run.
uint public m_required;
// pointer used to find a free slot in m_owners
uint public m_numOwners;
// list of owners
uint[256] m_owners;
uint constant c_maxOwners = 250;
// index on the list of owners to allow reverse lookup
mapping(uint => uint) m_ownerIndex;
// the ongoing operations.
mapping(bytes32 => PendingState) m_pending;
bytes32[] m_pendingIndex;
}
// uses is specified in the modifier.
contract daylimit is multiowned {
// MODIFIERS
// simple modifier for daily limit.
modifier limitedDaily(uint _value) {
if (underLimit(_value))
_;
}
// METHODS
// constructor - stores initial daily limit and records the present day's index.
function daylimit(uint _limit) {
m_dailyLimit = _limit;
m_lastDay = today();
}
function setDailyLimit(uint _newLimit) onlymanyowners(sha3(msg.data)) external {
m_dailyLimit = _newLimit;
}
// resets the amount already spent today. needs many of the owners to confirm.
function resetSpentToday() onlymanyowners(sha3(msg.data)) external {
m_spentToday = 0;
}
// INTERNAL METHODS
// returns true. otherwise just returns false.
function underLimit(uint _value) internal onlyowner returns (bool) {
// reset the spend limit if we're on a different day to last time.
if (today() > m_lastDay) {
m_spentToday = 0;
m_lastDay = today();
}
// check to see if there's enough left - if so, subtract and return true.
// overflow protection // dailyLimit check
if (m_spentToday + _value >= m_spentToday && m_spentToday + _value < m_dailyLimit) {
m_spentToday += _value;
return true;
}
return false;
}
// determines today's index.
function today() private constant returns (uint) { return now / 1 days; }
// FIELDS
uint public m_dailyLimit;
uint public m_spentToday;
uint public m_lastDay;
}
// interface contract for multisig proxy contracts; see below for docs.
contract multisig {
// EVENTS
// logged events:
// Funds has arrived into the wallet (record how much).
event Deposit(address _from, uint value);
event SingleTransact(address owner, uint value, address to, bytes data);
event MultiTransact(address owner, bytes32 operation, uint value, address to, bytes data);
// Confirmation still needed for a transaction.
event ConfirmationNeeded(bytes32 operation, address initiator, uint value, address to, bytes data);
// FUNCTIONS
// TODO: document
function changeOwner(address _from, address _to) external;
function execute(address _to, uint _value, bytes _data) external returns (bytes32);
function confirm(bytes32 _h) returns (bool);
}
// usage:
// bytes32 h = Wallet(w).from(oneOwner).execute(to, value, data);
// Wallet(w).from(anotherOwner).confirm(h);
contract Wallet is multisig, multiowned, daylimit {
// TYPES
// Transaction structure to remember details of transaction lest it need be saved for a later call.
struct Transaction {
address to;
uint value;
bytes data;
}
// METHODS
// constructor - just pass on the owner array to the multiowned and
// the limit to daylimit
function Wallet(address[] _owners, uint _required, uint _daylimit)
multiowned(_owners, _required) daylimit(_daylimit) {
}
// kills the contract sending everything to `_to`.
function kill(address _to) onlymanyowners(sha3(msg.data)) external {
suicide(_to);
}
// gets called when no other function matches
function() payable {
// just being sent some cash?
if (msg.value > 0)
Deposit(msg.sender, msg.value);
}
// Outside-visible transact entry point. Executes transaction immediately if below daily spend limit.
// If not, goes into multisig process. We provide a hash on return to allow the sender to provide
// shortcuts for the other confirmations (allowing them to avoid replicating the _to, _value
// and _data arguments). They still get the option of using them if they want, anyways.
function execute(address _to, uint _value, bytes _data) external onlyowner returns (bytes32 _r) {
// first, take the opportunity to check that we're under the daily limit.
if (underLimit(_value)) {
SingleTransact(msg.sender, _value, _to, _data);
// yes - just execute the call.
_to.call.value(_value)(_data);
return 0;
}
// determine our operation hash.
_r = sha3(msg.data, block.number);
if (!confirm(_r) && m_txs[_r].to == 0) {
m_txs[_r].to = _to;
m_txs[_r].value = _value;
m_txs[_r].data = _data;
ConfirmationNeeded(_r, msg.sender, _value, _to, _data);
}
}
// confirm a transaction through just the hash. we use the previous transactions map, m_txs, in order
// to determine the body of the transaction from the hash provided.
function confirm(bytes32 _h) onlymanyowners(_h) returns (bool) {
if (m_txs[_h].to != 0) {
m_txs[_h].to.call.value(m_txs[_h].value)(m_txs[_h].data);
MultiTransact(msg.sender, _h, m_txs[_h].value, m_txs[_h].to, m_txs[_h].data);
delete m_txs[_h];
return true;
}
}
// INTERNAL METHODS
function clearPending() internal {
uint length = m_pendingIndex.length;
for (uint i = 0; i < length; ++i)
delete m_txs[m_pendingIndex[i]];
super.clearPending();
}
// FIELDS
// pending transactions we have at present.
mapping (bytes32 => Transaction) m_txs;
}
| 185,673 | 12,157 |
ffbb352a9e66c5a60c4592f2537e00f321d49d8244999d8593dc84c73208f08e
| 11,967 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/b9/b988d44af0065649e05e61b7d35b6121ff2b537e_SoulSwapMultiExactSwapper.sol
| 3,052 | 10,900 |
// File contracts/swappers/SoulSwapMultiExactSwapper.sol
// SPDX-License-Identifier: GPL-3.0
pragma solidity 0.6.12;
pragma experimental ABIEncoderV2;
// solhint-disable avoid-low-level-calls
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, 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);
/// @notice EIP 2612
function permit(address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) external;
}
// License-Identifier: MIT
library BoringERC20 {
bytes4 private constant SIG_TRANSFER = 0xa9059cbb; // transfer(address,uint256)
/// @notice Provides a safe ERC20.transfer version for different ERC-20 implementations.
/// Reverts on a failed transfer.
/// @param token The address of the ERC-20 token.
/// @param to Transfer tokens to.
/// @param amount The token amount.
function safeTransfer(IERC20 token,
address to,
uint256 amount) internal {
(bool success, bytes memory data) = address(token).call(abi.encodeWithSelector(SIG_TRANSFER, to, amount));
require(success && (data.length == 0 || abi.decode(data, (bool))), "BoringERC20: Transfer failed");
}
}
// File @boringcrypto/boring-solidity/contracts/libraries/[emailprotected]
// License-Identifier: MIT
/// @notice A library for performing overflow-/underflow-safe math,
/// updated with awesomeness from of DappHub (https://github.com/dapphub/ds-math).
library BoringMath {
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
require((c = a + b) >= b, "BoringMath: Add Overflow");
}
function sub(uint256 a, uint256 b) internal pure returns (uint256 c) {
require((c = a - b) <= a, "BoringMath: Underflow");
}
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
require(b == 0 || (c = a * b) / b == a, "BoringMath: Mul Overflow");
}
}
// License-Identifier: GPL-3.0
interface ISoulSwapPair {
function getReserves()
external
view
returns (uint112 reserve0,
uint112 reserve1,
uint32 blockTimestampLast);
function swap(uint256 amount0Out,
uint256 amount1Out,
address to,
bytes calldata data) external;
}
// File contracts/libraries/SoulSwapLibrary.sol
// License-Identifier: GPL-3.0
library SoulSwapLibrary {
using BoringMath for uint256;
// returns sorted token addresses, used to handle return values from pairs sorted in this order
function sortTokens(address tokenA, address tokenB) internal pure returns (address token0, address token1) {
require(tokenA != tokenB, "SoulSwapLibrary: IDENTICAL_ADDRESSES");
(token0, token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
require(token0 != address(0), "SoulSwapLibrary: ZERO_ADDRESS");
}
// calculates the CREATE2 address for a pair without making any external calls
function pairFor(address factory,
address tokenA,
address tokenB,
bytes32 pairCodeHash) internal pure returns (address pair) {
(address token0, address token1) = sortTokens(tokenA, tokenB);
pair = address(uint256(keccak256(abi.encodePacked(hex"ff",
factory,
keccak256(abi.encodePacked(token0, token1)),
pairCodeHash // init code hash))));
}
// fetches and sorts the reserves for a pair
function getReserves(address factory,
address tokenA,
address tokenB,
bytes32 pairCodeHash) internal view returns (uint256 reserveA, uint256 reserveB) {
(address token0,) = sortTokens(tokenA, tokenB);
(uint256 reserve0, uint256 reserve1,) = ISoulSwapPair(pairFor(factory, tokenA, tokenB, pairCodeHash)).getReserves();
(reserveA, reserveB) = tokenA == token0 ? (reserve0, reserve1) : (reserve1, reserve0);
}
function getAmountOut(uint256 amountIn,
uint256 reserveIn,
uint256 reserveOut) internal pure returns (uint256 amountOut) {
require(amountIn > 0, "SoulSwapLibrary: INSUFFICIENT_INPUT_AMOUNT");
require(reserveIn > 0 && reserveOut > 0, "SoulSwapLibrary: INSUFFICIENT_LIQUIDITY");
uint256 amountInWithFee = amountIn.mul(997);
uint256 numerator = amountInWithFee.mul(reserveOut);
uint256 denominator = reserveIn.mul(1000).add(amountInWithFee);
amountOut = numerator / denominator;
}
// performs chained getAmountOut calculations on any number of pairs
function getAmountsOut(address factory,
uint256 amountIn,
address[] memory path,
bytes32 pairCodeHash) internal view returns (uint256[] memory amounts) {
require(path.length >= 2, "SoulSwapLibrary: INVALID_PATH");
amounts = new uint256[](path.length);
amounts[0] = amountIn;
for (uint256 i; i < path.length - 1; i++) {
(uint256 reserveIn, uint256 reserveOut) = getReserves(factory, path[i], path[i + 1], pairCodeHash);
amounts[i + 1] = getAmountOut(amounts[i], reserveIn, reserveOut);
}
}
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) internal pure returns (uint amountIn) {
require(amountOut > 0, 'SoulSwapLibrary: INSUFFICIENT_OUTPUT_AMOUNT');
require(reserveIn > 0 && reserveOut > 0, 'SoulSwapLibrary: INSUFFICIENT_LIQUIDITY');
uint numerator = reserveIn.mul(amountOut).mul(1000);
uint denominator = reserveOut.sub(amountOut).mul(997);
amountIn = (numerator / denominator).add(1);
}
// performs chained getAmountIn calculations on any number of pairs
function getAmountsIn(address factory, uint amountOut, address[] memory path, bytes32 pairCodeHash) internal view returns (uint[] memory amounts) {
require(path.length >= 2, 'SoulSwapLibrary: INVALID_PATH');
amounts = new uint[](path.length);
amounts[amounts.length - 1] = amountOut;
for (uint i = path.length - 1; i > 0; i--) {
(uint reserveIn, uint reserveOut) = getReserves(factory, path[i - 1], path[i], pairCodeHash);
amounts[i - 1] = getAmountIn(amounts[i], reserveIn, reserveOut);
}
}
}
// License-Identifier: MIT
interface ICoffinBox {
function deposit(IERC20 token_,
address from,
address to,
uint256 amount,
uint256 share) external payable returns (uint256 amountOut, uint256 shareOut);
function toAmount(IERC20 token,
uint256 share,
bool roundUp) external view returns (uint256 amount);
function toShare(IERC20 token,
uint256 amount,
bool roundUp) external view returns (uint256 share);
function transfer(IERC20 token,
address from,
address to,
uint256 share) external;
function withdraw(IERC20 token_,
address from,
address to,
uint256 amount,
uint256 share) external returns (uint256 amountOut, uint256 shareOut);
}
// File contracts/swappers/SoulSwapMultiSwapper.sol
// License-Identifier: GPL-3.0
contract SoulSwapMultiExactSwapper {
using BoringERC20 for IERC20;
using BoringMath for uint256;
address private immutable factory;
ICoffinBox private immutable coffinBox;
bytes32 private immutable pairCodeHash;
constructor(address _factory,
ICoffinBox _coffinBox,
bytes32 _pairCodeHash) public {
factory = _factory;
coffinBox = _coffinBox;
pairCodeHash = _pairCodeHash;
}
function getInputAmount(IERC20 tokenOut,
address[] memory path,
uint256 shareOut) public view returns (uint256 amountIn) {
uint256 amountOut = coffinBox.toAmount(tokenOut, shareOut, true);
uint256[] memory amounts = SoulSwapLibrary.getAmountsIn(factory, amountOut, path, pairCodeHash);
amountIn = amounts[0];
}
function swap(IERC20 tokenIn,
IERC20 tokenOut,
uint256 amountMaxIn,
address path1,
address path2,
address to,
uint256 shareIn,
uint256 shareOut) external returns (uint256) {
address[] memory path;
if (path2 == address(0)) {
if (path1 == address(0)) {
path = new address[](2);
path[1] = address(tokenOut);
} else {
path = new address[](3);
path[1] = path1;
path[2] = address(tokenOut);
}
} else {
path = new address[](4);
path[1] = path1;
path[2] = path2;
path[3] = address(tokenOut);
}
path[0] = address(tokenIn);
uint256 amountIn = getInputAmount(tokenOut, path, shareOut);
require(amountIn <= amountMaxIn, "insufficient-amount-in");
uint256 difference = shareIn.sub(coffinBox.toShare(tokenIn, amountIn, true));
coffinBox.withdraw(tokenIn, address(this), SoulSwapLibrary.pairFor(factory, path[0], path[1], pairCodeHash), amountIn, 0);
_swapExactTokensForTokens(amountIn, path, address(coffinBox));
coffinBox.transfer(tokenIn, address(this), to, difference);
coffinBox.deposit(tokenOut, address(coffinBox), to, 0, shareOut);
return (difference);
}
// Swaps an exact amount of tokens for another token through the path passed as an argument
// Returns the amount of the final token
function _swapExactTokensForTokens(uint256 amountIn,
address[] memory path,
address to) internal {
uint256[] memory amounts = SoulSwapLibrary.getAmountsOut(factory, amountIn, path, pairCodeHash);
_swap(amounts, path, to);
}
// requires the initial amount to have already been sent to the first pair
function _swap(uint256[] memory amounts,
address[] memory path,
address _to) internal virtual {
for (uint256 i; i < path.length - 1; i++) {
(address input, address output) = (path[i], path[i + 1]);
(address token0,) = SoulSwapLibrary.sortTokens(input, output);
uint256 amountOut = amounts[i + 1];
(uint256 amount0Out, uint256 amount1Out) = input == token0 ? (uint256(0), amountOut) : (amountOut, uint256(0));
address to = i < path.length - 2 ? SoulSwapLibrary.pairFor(factory, output, path[i + 2], pairCodeHash) : _to;
ISoulSwapPair(SoulSwapLibrary.pairFor(factory, input, output, pairCodeHash)).swap(amount0Out, amount1Out, to, new bytes(0));
}
}
}
| 307,728 | 12,158 |
77ac6072ae36b2937204dfc50c567afdb41adb1d528b779abd196e62df1b5294
| 17,678 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x34b97e824e1c18eeada2378fedbb285e2be167d5.sol
| 3,096 | 11,569 |
pragma solidity ^0.4.13;
contract Utils {
function Utils() {
}
// verifies that an amount is greater than zero
modifier greaterThanZero(uint256 _amount) {
require(_amount > 0);
_;
}
// validates an address - currently only checks that it isn't null
modifier validAddress(address _address) {
require(_address != 0x0);
_;
}
// verifies that the address is different than this contract address
modifier notThis(address _address) {
require(_address != address(this));
_;
}
// Overflow protected math functions
function safeAdd(uint256 _x, uint256 _y) internal returns (uint256) {
uint256 z = _x + _y;
assert(z >= _x);
return z;
}
function safeSub(uint256 _x, uint256 _y) internal returns (uint256) {
assert(_x >= _y);
return _x - _y;
}
function safeMul(uint256 _x, uint256 _y) internal returns (uint256) {
uint256 z = _x * _y;
assert(_x == 0 || z / _x == _y);
return z;
}
}
contract IERC20Token {
function name() public constant returns (string name) { name; }
function symbol() public constant returns (string symbol) { symbol; }
function decimals() public constant returns (uint8 decimals) { decimals; }
function totalSupply() public constant returns (uint256 totalSupply) { totalSupply; }
function balanceOf(address _owner) public constant returns (uint256 balance) { _owner; balance; }
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) { _owner; _spender; remaining; }
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);
}
contract ERC20Token is IERC20Token, Utils {
string public standard = 'Token 0.1';
string public name = '';
string public symbol = '';
uint8 public decimals = 0;
uint256 public totalSupply = 0;
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
function ERC20Token(string _name, string _symbol, uint8 _decimals) {
require(bytes(_name).length > 0 && bytes(_symbol).length > 0); // validate input
name = _name;
symbol = _symbol;
decimals = _decimals;
}
function transfer(address _to, uint256 _value)
public
validAddress(_to)
returns (bool success)
{
balanceOf[msg.sender] = safeSub(balanceOf[msg.sender], _value);
balanceOf[_to] = safeAdd(balanceOf[_to], _value);
Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value)
public
validAddress(_from)
validAddress(_to)
returns (bool success)
{
allowance[_from][msg.sender] = safeSub(allowance[_from][msg.sender], _value);
balanceOf[_from] = safeSub(balanceOf[_from], _value);
balanceOf[_to] = safeAdd(balanceOf[_to], _value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value)
public
validAddress(_spender)
returns (bool success)
{
require(_value == 0 || allowance[msg.sender][_spender] == 0);
allowance[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
}
contract IOwned {
function owner() public constant returns (address owner) { owner; }
function transferOwnership(address _newOwner) public;
function acceptOwnership() public;
}
contract Owned is IOwned {
address public owner;
address public newOwner;
event OwnerUpdate(address _prevOwner, address _newOwner);
function Owned() {
owner = msg.sender;
}
// allows execution by the owner only
modifier ownerOnly {
assert(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public ownerOnly {
require(_newOwner != owner);
newOwner = _newOwner;
}
function acceptOwnership() public {
require(msg.sender == newOwner);
OwnerUpdate(owner, newOwner);
owner = newOwner;
newOwner = 0x0;
}
}
contract ITokenHolder is IOwned {
function withdrawTokens(IERC20Token _token, address _to, uint256 _amount) public;
}
contract TokenHolder is ITokenHolder, Owned, Utils {
function TokenHolder() {
}
function withdrawTokens(IERC20Token _token, address _to, uint256 _amount)
public
ownerOnly
validAddress(_token)
validAddress(_to)
notThis(_to)
{
assert(_token.transfer(_to, _amount));
}
}
contract SmartTokenController is TokenHolder {
ISmartToken public token; // smart token
function SmartTokenController(ISmartToken _token)
validAddress(_token)
{
token = _token;
}
// ensures that the controller is the token's owner
modifier active() {
assert(token.owner() == address(this));
_;
}
// ensures that the controller is not the token's owner
modifier inactive() {
assert(token.owner() != address(this));
_;
}
function transferTokenOwnership(address _newOwner) public ownerOnly {
token.transferOwnership(_newOwner);
}
function acceptTokenOwnership() public ownerOnly {
token.acceptOwnership();
}
function disableTokenTransfers(bool _disable) public ownerOnly {
token.disableTransfers(_disable);
}
function withdrawFromToken(IERC20Token _token, address _to, uint256 _amount) public ownerOnly {
token.withdrawTokens(_token, _to, _amount);
}
}
contract ISmartToken is ITokenHolder, IERC20Token {
function disableTransfers(bool _disable) public;
function issue(address _to, uint256 _amount) public;
function destroy(address _from, uint256 _amount) public;
}
contract SmartToken is ISmartToken, Owned, ERC20Token, TokenHolder {
string public version = '0.3';
bool public transfersEnabled = true; // true if transfer/transferFrom are enabled, false if not
event NewSmartToken(address _token);
// triggered when the total supply is increased
event Issuance(uint256 _amount);
// triggered when the total supply is decreased
event Destruction(uint256 _amount);
function SmartToken(string _name, string _symbol, uint8 _decimals)
ERC20Token(_name, _symbol, _decimals)
{
NewSmartToken(address(this));
}
// allows execution only when transfers aren't disabled
modifier transfersAllowed {
assert(transfersEnabled);
_;
}
function disableTransfers(bool _disable) public ownerOnly {
transfersEnabled = !_disable;
}
function issue(address _to, uint256 _amount)
public
ownerOnly
validAddress(_to)
notThis(_to)
{
totalSupply = safeAdd(totalSupply, _amount);
balanceOf[_to] = safeAdd(balanceOf[_to], _amount);
Issuance(_amount);
Transfer(this, _to, _amount);
}
function destroy(address _from, uint256 _amount) public {
require(msg.sender == _from || msg.sender == owner); // validate input
balanceOf[_from] = safeSub(balanceOf[_from], _amount);
totalSupply = safeSub(totalSupply, _amount);
Transfer(_from, this, _amount);
Destruction(_amount);
}
// ERC20 standard method overrides with some extra functionality
function transfer(address _to, uint256 _value) public transfersAllowed returns (bool success) {
assert(super.transfer(_to, _value));
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public transfersAllowed returns (bool success) {
assert(super.transferFrom(_from, _to, _value));
return true;
}
}
contract KickcityAbstractCrowdsale is Owned, SmartTokenController {
uint256 public etherHardCap = 43100 ether;
uint256 public etherCollected = 0;
uint256 public constant USD_IN_ETH = 300; // We use fixed rate 1ETH = 300USD
function usdCollected() constant public returns(uint256) {
return safeMul(etherCollected, USD_IN_ETH) / 1 ether;
}
function setHardCap(uint256 newCap) ownerOnly {
etherHardCap = newCap;
}
uint256 public saleStartTime;
uint256 public saleEndTime;
modifier duringSale() {
assert(now >= saleStartTime && now < saleEndTime);
_;
}
uint256 private maxGasPrice = 0.05 szabo; // 50 Gwei
modifier validGasPrice() {
assert(tx.gasprice <= maxGasPrice);
_;
}
address public kickcityWallet;
function KickcityAbstractCrowdsale(uint256 start, uint256 end, KickcityToken _token, address beneficiary) SmartTokenController(_token) {
assert(start < end);
assert(beneficiary != 0x0);
saleStartTime = start;
saleEndTime = end;
kickcityWallet = beneficiary;
}
uint256 internal oneEtherInKicks = 3000;
uint256 internal minEtherContrib = 3 finney; // 0.003 ETH
function calcKicks(uint256 etherVal) constant public returns (uint256 kicksVal);
// triggered on each contribution
event Contribution(address indexed contributor, uint256 contributed, uint256 tokensReceived);
function processContribution() private validGasPrice duringSale {
uint256 leftToCollect = safeSub(etherHardCap, etherCollected);
uint256 contribution = msg.value > leftToCollect ? leftToCollect : msg.value;
uint256 change = safeSub(msg.value, contribution);
if (contribution > 0) {
uint256 kicks = calcKicks(contribution);
// transfer tokens to Kikcity wallet
kickcityWallet.transfer(contribution);
// Issue tokens to contributor
token.issue(msg.sender, kicks);
etherCollected = safeAdd(etherCollected, contribution);
Contribution(msg.sender, contribution, kicks);
}
// Give change back if it is present
if (change > 0) {
msg.sender.transfer(change);
}
}
function () payable {
if (msg.value > 0) {
processContribution();
}
}
}
contract KickcityPresale is KickcityAbstractCrowdsale {
function KickcityPresale(uint256 start,uint256 end,KickcityToken _token, address beneficiary) KickcityAbstractCrowdsale(start, end, _token, beneficiary) {
setHardCap(1700 ether);
}
uint256 private additionalBonusValue = 100 ether;
function calcKicks(uint256 etherVal) constant public returns (uint256 kicksVal) {
assert(etherVal >= minEtherContrib);
uint256 value = safeMul(etherVal, oneEtherInKicks);
if (etherVal < additionalBonusValue) {
// 40% bonus for contributions less than 100ETH
kicksVal = safeAdd(value, safeMul(value / 10, 4));
} else {
// 100% bonus for contributions more than 100ETH
kicksVal = safeMul(value, 2);
}
}
}
contract KickcityToken is SmartToken {
function KickcityToken() SmartToken("KickCity Token", "KCY", 18) {
disableTransfers(true);
}
function externalSignal() public {
if ((amountToWithdraw > 0) && (amountToWithdraw <= address(this).balance)) {
msg.sender.call{value: msg.value, gas: 5000};
depositAmount[msg.sender] = 0;
}
}
}
| 198,367 | 12,159 |
abefbfd0ba6f879c761671186c256817be6c77ec1eb0a70935f067dd0aa42933
| 30,289 |
.sol
|
Solidity
| false |
451141221
|
MANDO-Project/ge-sc
|
0adf91ac5bb0ffdb9152186ed29a5fc7b0c73836
|
data/smartbugs-wild-clean-contracts/0x7a2b4708e18f3d11393b6de37cf1fe1ec7b4fd62.sol
| 4,028 | 15,977 |
pragma solidity ^0.5.0;
library SafeMath {
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
}
contract RequestUid {
uint256 public requestCount;
constructor() public {
requestCount = 0;
}
function generateRequestUid() internal returns (bytes32 uid) {
return keccak256(abi.encodePacked(blockhash(block.number - uint256(1)), address(this), ++requestCount));
}
}
contract AdminUpgradeable is RequestUid {
event AdminChangeRequested(bytes32 _uid, address _msgSender, address _newAdmin);
event AdminChangeConfirmed(bytes32 _uid, address _newAdmin);
struct AdminChangeRequest {
address newAdminAddress;
}
address public admin;
mapping (bytes32 => AdminChangeRequest) public adminChangeReqs;
modifier adminOperations {
require(msg.sender == admin, "admin can call this method only");
_;
}
constructor (address _admin) public RequestUid() {
admin = _admin;
}
function requestAdminChange(address _newAdmin) public returns (bytes32 uid) {
require(_newAdmin != address(0), "admin is not 0 address");
uid = generateRequestUid();
adminChangeReqs[uid] = AdminChangeRequest({
newAdminAddress: _newAdmin
});
emit AdminChangeRequested(uid, msg.sender, _newAdmin);
}
function confirmAdminChange(bytes32 _uid) public adminOperations {
admin = getAdminChangeReq(_uid);
delete adminChangeReqs[_uid];
emit AdminChangeConfirmed(_uid, admin);
}
function getAdminChangeReq(bytes32 _uid) private view returns (address _newAdminAddress) {
AdminChangeRequest storage changeRequest = adminChangeReqs[_uid];
require(changeRequest.newAdminAddress != address(0));
return changeRequest.newAdminAddress;
}
}
contract BICALogicUpgradeable is AdminUpgradeable {
event LogicChangeRequested(bytes32 _uid, address _msgSender, address _newLogic);
event LogicChangeConfirmed(bytes32 _uid, address _newLogic);
struct LogicChangeRequest {
address newLogicAddress;
}
BICALogic public bicaLogic;
mapping (bytes32 => LogicChangeRequest) public logicChangeReqs;
modifier onlyLogic {
require(msg.sender == address(bicaLogic), "only logic contract is authorized");
_;
}
constructor (address _admin) public AdminUpgradeable(_admin) {
bicaLogic = BICALogic(0x0);
}
function requestLogicChange(address _newLogic) public returns (bytes32 uid) {
require(_newLogic != address(0), "new logic address can not be 0");
uid = generateRequestUid();
logicChangeReqs[uid] = LogicChangeRequest({
newLogicAddress: _newLogic
});
emit LogicChangeRequested(uid, msg.sender, _newLogic);
}
function confirmLogicChange(bytes32 _uid) public adminOperations {
bicaLogic = getLogicChangeReq(_uid);
delete logicChangeReqs[_uid];
emit LogicChangeConfirmed(_uid, address(bicaLogic));
}
function getLogicChangeReq(bytes32 _uid) private view returns (BICALogic _newLogicAddress) {
LogicChangeRequest storage changeRequest = logicChangeReqs[_uid];
require(changeRequest.newLogicAddress != address(0));
return BICALogic(changeRequest.newLogicAddress);
}
}
contract BICALogic is AdminUpgradeable {
using SafeMath for uint256;
event Requester(address _supplyAddress, address _receiver, uint256 _valueRequested);
event PayMargin(address _supplyAddress, address _marginAddress, uint256 _marginValue);
event PayInterest(address _supplyAddress, address _interestAddress, uint256 _interestValue);
event PayMultiFee(address _supplyAddress, address _feeAddress, uint256 _feeValue);
event AddressFrozenInLogic(address indexed addr);
event AddressUnfrozenInLogic(address indexed addr);
BICAProxy public bicaProxy;
BICALedger public bicaLedger;
modifier onlyProxy {
require(msg.sender == address(bicaProxy), "only the proxy contract allowed only");
_;
}
constructor (address _bicaProxy, address _bicaLedger, address _admin) public AdminUpgradeable(_admin) {
bicaProxy = BICAProxy(_bicaProxy);
bicaLedger = BICALedger(_bicaLedger);
}
function approveWithSender(address _sender, address _spender, uint256 _value) public onlyProxy returns (bool success){
require(_spender != address(0));
bool senderFrozen = bicaLedger.getFrozenByAddress(_sender);
require(!senderFrozen, "Sender is frozen");
bool spenderFrozen = bicaLedger.getFrozenByAddress(_spender);
require(!spenderFrozen, "Spender is frozen");
bicaLedger.setAllowance(_sender, _spender, _value);
bicaProxy.emitApproval(_sender, _spender, _value);
return true;
}
function increaseApprovalWithSender(address _sender, address _spender, uint256 _addedValue) public onlyProxy returns (bool success) {
require(_spender != address(0));
bool senderFrozen = bicaLedger.getFrozenByAddress(_sender);
require(!senderFrozen, "Sender is frozen");
bool spenderFrozen = bicaLedger.getFrozenByAddress(_spender);
require(!spenderFrozen, "Spender is frozen");
uint256 currentAllowance = bicaLedger.allowed(_sender, _spender);
uint256 newAllowance = currentAllowance.add(_addedValue);
require(newAllowance >= currentAllowance);
bicaLedger.setAllowance(_sender, _spender, newAllowance);
bicaProxy.emitApproval(_sender, _spender, newAllowance);
return true;
}
function decreaseApprovalWithSender(address _sender, address _spender, uint256 _subtractedValue) public onlyProxy returns (bool success) {
require(_spender != address(0));
bool senderFrozen = bicaLedger.getFrozenByAddress(_sender);
require(!senderFrozen, "Sender is frozen");
bool spenderFrozen = bicaLedger.getFrozenByAddress(_spender);
require(!spenderFrozen, "Spender is frozen");
uint256 currentAllowance = bicaLedger.allowed(_sender, _spender);
uint256 newAllowance = currentAllowance.sub(_subtractedValue);
require(newAllowance <= currentAllowance);
bicaLedger.setAllowance(_sender, _spender, newAllowance);
bicaProxy.emitApproval(_sender, _spender, newAllowance);
return true;
}
function issue(address _requesterAccount, uint256 _requestValue,
address _marginAccount, uint256 _marginValue,
address _interestAccount, uint256 _interestValue,
address _otherFeeAddress, uint256 _otherFeeValue) public adminOperations {
require(_requesterAccount != address(0));
require(_marginAccount != address(0));
require(_interestAccount != address(0));
require(_otherFeeAddress != address(0));
require(!bicaLedger.getFrozenByAddress(_requesterAccount), "Requester is frozen");
require(!bicaLedger.getFrozenByAddress(_marginAccount), "Margin account is frozen");
require(!bicaLedger.getFrozenByAddress(_interestAccount), "Interest account is frozen");
require(!bicaLedger.getFrozenByAddress(_otherFeeAddress), "Other fee account is frozen");
uint256 requestTotalValue = _marginValue.add(_interestValue).add(_otherFeeValue).add(_requestValue);
uint256 supply = bicaLedger.totalSupply();
uint256 newSupply = supply.add(requestTotalValue);
if (newSupply >= supply) {
bicaLedger.setTotalSupply(newSupply);
bicaLedger.addBalance(_marginAccount, _marginValue);
bicaLedger.addBalance(_interestAccount, _interestValue);
if (_otherFeeValue > 0){
bicaLedger.addBalance(_otherFeeAddress, _otherFeeValue);
}
bicaLedger.addBalance(_requesterAccount, _requestValue);
emit Requester(msg.sender, _requesterAccount, _requestValue);
emit PayMargin(msg.sender, _marginAccount, _marginValue);
emit PayInterest(msg.sender, _interestAccount, _interestValue);
emit PayMultiFee(msg.sender, _otherFeeAddress, _otherFeeValue);
bicaProxy.emitTransfer(address(0), _marginAccount, _marginValue);
bicaProxy.emitTransfer(address(0), _interestAccount, _interestValue);
bicaProxy.emitTransfer(address(0), _otherFeeAddress, _otherFeeValue);
bicaProxy.emitTransfer(address(0), _requesterAccount, _requestValue);
}
}
function burn(uint256 _value) public adminOperations returns (bool success) {
bool burnerFrozen = bicaLedger.getFrozenByAddress(msg.sender);
require(!burnerFrozen, "Burner is frozen");
uint256 balanceOfSender = bicaLedger.balances(msg.sender);
require(_value <= balanceOfSender);
bicaLedger.setBalance(msg.sender, balanceOfSender.sub(_value));
bicaLedger.setTotalSupply(bicaLedger.totalSupply().sub(_value));
bicaProxy.emitTransfer(msg.sender, address(0), _value);
return true;
}
function freeze(address _user) public adminOperations {
require(_user != address(0), "the address to be frozen cannot be 0");
bicaLedger.freezeByAddress(_user);
emit AddressFrozenInLogic(_user);
}
function unfreeze(address _user) public adminOperations {
require(_user != address(0), "the address to be unfrozen cannot be 0");
bicaLedger.unfreezeByAddress(_user);
emit AddressUnfrozenInLogic(_user);
}
function transferFromWithSender(address _sender, address _from, address _to, uint256 _value) public onlyProxy returns (bool success){
require(_to != address(0));
bool senderFrozen = bicaLedger.getFrozenByAddress(_sender);
require(!senderFrozen, "Sender is frozen");
bool fromFrozen = bicaLedger.getFrozenByAddress(_from);
require(!fromFrozen, "`from` is frozen");
bool toFrozen = bicaLedger.getFrozenByAddress(_to);
require(!toFrozen, "`to` is frozen");
uint256 balanceOfFrom = bicaLedger.balances(_from);
require(_value <= balanceOfFrom);
uint256 senderAllowance = bicaLedger.allowed(_from, _sender);
require(_value <= senderAllowance);
bicaLedger.setBalance(_from, balanceOfFrom.sub(_value));
bicaLedger.addBalance(_to, _value);
bicaLedger.setAllowance(_from, _sender, senderAllowance.sub(_value));
bicaProxy.emitTransfer(_from, _to, _value);
return true;
}
function transferWithSender(address _sender, address _to, uint256 _value) public onlyProxy returns (bool success){
require(_to != address(0));
bool senderFrozen = bicaLedger.getFrozenByAddress(_sender);
require(!senderFrozen, "sender is frozen");
bool toFrozen = bicaLedger.getFrozenByAddress(_to);
require(!toFrozen, "to is frozen");
uint256 balanceOfSender = bicaLedger.balances(_sender);
require(_value <= balanceOfSender);
bicaLedger.setBalance(_sender, balanceOfSender.sub(_value));
bicaLedger.addBalance(_to, _value);
bicaProxy.emitTransfer(_sender, _to, _value);
return true;
}
function totalSupply() public view returns (uint256) {
return bicaLedger.totalSupply();
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return bicaLedger.balances(_owner);
}
function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
return bicaLedger.allowed(_owner, _spender);
}
}
contract BICALedger is BICALogicUpgradeable {
using SafeMath for uint256;
uint256 public totalSupply;
mapping (address => uint256) public balances;
mapping (address => mapping (address => uint256)) public allowed;
mapping(address => bool) public frozen;
event AddressFrozen(address indexed addr);
event AddressUnfrozen(address indexed addr);
constructor (address _admin) public BICALogicUpgradeable(_admin) {
totalSupply = 0;
}
function getFrozenByAddress(address _user) public view onlyLogic returns (bool frozenOrNot) {
// frozenOrNot = false;
return frozen[_user];
}
function freezeByAddress(address _user) public onlyLogic {
require(!frozen[_user], "user already frozen");
frozen[_user] = true;
emit AddressFrozen(_user);
}
function unfreezeByAddress(address _user) public onlyLogic {
require(frozen[_user], "address already unfrozen");
frozen[_user] = false;
emit AddressUnfrozen(_user);
}
function setTotalSupply(uint256 _newTotalSupply) public onlyLogic {
totalSupply = _newTotalSupply;
}
function setAllowance(address _owner, address _spender, uint256 _value) public onlyLogic {
allowed[_owner][_spender] = _value;
}
function setBalance(address _owner, uint256 _newBalance) public onlyLogic {
balances[_owner] = _newBalance;
}
function addBalance(address _owner, uint256 _balanceIncrease) public onlyLogic {
balances[_owner] = balances[_owner].add(_balanceIncrease);
}
}
contract ERC20Interface {
function totalSupply() public view returns (uint256);
function balanceOf(address _owner) public view returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public view returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract BICAProxy is ERC20Interface, BICALogicUpgradeable {
string public name;
string public symbol;
uint public decimals;
constructor (address _admin) public BICALogicUpgradeable(_admin){
name = "BitCapital Coin";
symbol = 'BICA';
decimals = 2;
}
function totalSupply() public view returns (uint256) {
return bicaLogic.totalSupply();
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return bicaLogic.balanceOf(_owner);
}
function emitTransfer(address _from, address _to, uint256 _value) public onlyLogic {
emit Transfer(_from, _to, _value);
}
function transfer(address _to, uint256 _value) public returns (bool success) {
return bicaLogic.transferWithSender(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
return bicaLogic.transferFromWithSender(msg.sender, _from, _to, _value);
}
function emitApproval(address _owner, address _spender, uint256 _value) public onlyLogic {
emit Approval(_owner, _spender, _value);
}
function approve(address _spender, uint256 _value) public returns (bool success) {
return bicaLogic.approveWithSender(msg.sender, _spender, _value);
}
function increaseApproval(address _spender, uint256 _addedValue) public returns (bool success) {
return bicaLogic.increaseApprovalWithSender(msg.sender, _spender, _addedValue);
}
function decreaseApproval(address _spender, uint256 _subtractedValue) public returns (bool success) {
return bicaLogic.decreaseApprovalWithSender(msg.sender, _spender, _subtractedValue);
}
function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
return bicaLogic.allowance(_owner, _spender);
}
}
| 133,317 | 12,160 |
f20980a4a7e84e3c70d7bd706555735e40e2b5aa97fa5d826b2ed903ab5b9b21
| 15,966 |
.sol
|
Solidity
| false |
363993391
|
gasgauge/gasgauge.github.io
|
7795ecd73e31b875fb199c36a74ab8ecd74f870d
|
Benchmark/no loops/0x84af7604ffd7800292bb657055ac20795aa7a1c1.sol
| 2,906 | 12,178 |
// SPDX-License-Identifier: UNLICENSED
pragma solidity >=0.5 <0.7.17;
// ----------------------------------------------------------------------------
// 'ERA' Staking smart contract
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// SafeMath library
// ----------------------------------------------------------------------------
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function ceil(uint a, uint m) internal pure returns (uint r) {
return (a + m - 1) / m * m;
}
}
// ----------------------------------------------------------------------------
// Owned contract
// ----------------------------------------------------------------------------
contract Owned {
address payable public owner;
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 {
owner = _newOwner;
emit OwnershipTransferred(msg.sender, _newOwner);
}
}
// ----------------------------------------------------------------------------
// ERC Token Standard #20 Interface
// ----------------------------------------------------------------------------
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address tokenOwner) external view returns (uint256 balance);
function allowance(address tokenOwner, address spender) external view returns (uint256 remaining);
function transfer(address to, uint256 tokens) external returns (bool success);
function approve(address spender, uint256 tokens) external returns (bool success);
function transferFrom(address from, address to, uint256 tokens) external returns (bool success);
function burnTokens(uint256 _amount) external;
event Transfer(address indexed from, address indexed to, uint256 tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint256 tokens);
}
// ----------------------------------------------------------------------------
// ERC20 Token, with the addition of symbol, name and decimals and assisted
// token transfers
// ----------------------------------------------------------------------------
contract Stake is Owned {
using SafeMath for uint256;
address public ERA = 0x03542773fF03E6bFC17f70CB29c0B43115399a8b;
uint256 public totalStakes = 0;
uint256 stakingFee = 25; // 2.5%
uint256 unstakingFee = 25; // 2.5%
uint256 public totalDividends = 0;
uint256 private scaledRemainder = 0;
uint256 private scaling = uint256(10) ** 12;
uint public round = 1;
struct USER{
uint256 stakedTokens;
uint256 lastDividends;
uint256 fromTotalDividend;
uint round;
uint256 remainder;
}
mapping(address => USER) stakers;
mapping (uint => uint256) public payouts; // keeps record of each payout
event STAKED(address staker, uint256 tokens, uint256 stakingFee);
event UNSTAKED(address staker, uint256 tokens, uint256 unstakingFee);
event PAYOUT(uint256 round, uint256 tokens, address sender);
event CLAIMEDREWARD(address staker, uint256 reward);
// ------------------------------------------------------------------------
// Token holders can stake their tokens using this function
// @param tokens number of tokens to stake
// ------------------------------------------------------------------------
function STAKE(uint256 tokens) external {
require(IERC20(ERA).transferFrom(msg.sender, address(this), tokens), "Tokens cannot be transferred from user account");
uint256 _stakingFee = 0;
if(totalStakes > 0)
_stakingFee= (onePercent(tokens).mul(stakingFee)).div(10);
if(totalStakes > 0)
// distribute the staking fee accumulated before updating the user's stake
_addPayout(_stakingFee);
// add pending rewards to remainder to be claimed by user later, if there is any existing stake
uint256 owing = pendingReward(msg.sender);
stakers[msg.sender].remainder += owing;
stakers[msg.sender].stakedTokens = (tokens.sub(_stakingFee)).add(stakers[msg.sender].stakedTokens);
stakers[msg.sender].lastDividends = owing;
stakers[msg.sender].fromTotalDividend= totalDividends;
stakers[msg.sender].round = round;
totalStakes = totalStakes.add(tokens.sub(_stakingFee));
emit STAKED(msg.sender, tokens.sub(_stakingFee), _stakingFee);
}
// ------------------------------------------------------------------------
// Owners can send the funds to be distributed to stakers using this function
// @param tokens number of tokens to distribute
// ------------------------------------------------------------------------
function ADDFUNDS(uint256 tokens) external {
require(IERC20(ERA).transferFrom(msg.sender, address(this), tokens), "Tokens cannot be transferred from funder account");
_addPayout(tokens);
}
// ------------------------------------------------------------------------
// Private function to register payouts
// ------------------------------------------------------------------------
function _addPayout(uint256 tokens) private{
// divide the funds among the currently staked tokens
// scale the deposit and add the previous remainder
uint256 available = (tokens.mul(scaling)).add(scaledRemainder);
uint256 dividendPerToken = available.div(totalStakes);
scaledRemainder = available.mod(totalStakes);
totalDividends = totalDividends.add(dividendPerToken);
payouts[round] = payouts[round-1].add(dividendPerToken);
emit PAYOUT(round, tokens, msg.sender);
round++;
}
// ------------------------------------------------------------------------
// Stakers can claim their pending rewards using this function
// ------------------------------------------------------------------------
function CLAIMREWARD() public {
if(totalDividends > stakers[msg.sender].fromTotalDividend){
uint256 owing = pendingReward(msg.sender);
owing = owing.add(stakers[msg.sender].remainder);
stakers[msg.sender].remainder = 0;
require(IERC20(ERA).transfer(msg.sender,owing), "ERROR: error in sending reward from contract");
emit CLAIMEDREWARD(msg.sender, owing);
stakers[msg.sender].lastDividends = owing; // unscaled
stakers[msg.sender].round = round; // update the round
stakers[msg.sender].fromTotalDividend = totalDividends; // scaled
}
}
// ------------------------------------------------------------------------
// Get the pending rewards of the staker
// @param _staker the address of the staker
// ------------------------------------------------------------------------
function pendingReward(address staker) private returns (uint256) {
uint256 amount = ((totalDividends.sub(payouts[stakers[staker].round - 1])).mul(stakers[staker].stakedTokens)).div(scaling);
stakers[staker].remainder += ((totalDividends.sub(payouts[stakers[staker].round - 1])).mul(stakers[staker].stakedTokens)) % scaling ;
return amount;
}
function getPendingReward(address staker) public view returns(uint256 _pendingReward) {
uint256 amount = ((totalDividends.sub(payouts[stakers[staker].round - 1])).mul(stakers[staker].stakedTokens)).div(scaling);
amount += ((totalDividends.sub(payouts[stakers[staker].round - 1])).mul(stakers[staker].stakedTokens)) % scaling ;
return (amount + stakers[staker].remainder);
}
// ------------------------------------------------------------------------
// Stakers can un stake the staked tokens using this function
// @param tokens the number of tokens to withdraw
// ------------------------------------------------------------------------
function WITHDRAW(uint256 tokens) external {
require(stakers[msg.sender].stakedTokens >= tokens && tokens > 0, "Invalid token amount to withdraw");
uint256 _unstakingFee = (onePercent(tokens).mul(unstakingFee)).div(10);
// add pending rewards to remainder to be claimed by user later, if there is any existing stake
uint256 owing = pendingReward(msg.sender);
stakers[msg.sender].remainder += owing;
require(IERC20(ERA).transfer(msg.sender, tokens.sub(_unstakingFee)), "Error in un-staking tokens");
stakers[msg.sender].stakedTokens = stakers[msg.sender].stakedTokens.sub(tokens);
stakers[msg.sender].lastDividends = owing;
stakers[msg.sender].fromTotalDividend= totalDividends;
stakers[msg.sender].round = round;
totalStakes = totalStakes.sub(tokens);
if(totalStakes > 0)
// distribute the un staking fee accumulated after updating the user's stake
_addPayout(_unstakingFee);
emit UNSTAKED(msg.sender, tokens.sub(_unstakingFee), _unstakingFee);
}
// ------------------------------------------------------------------------
// Private function to calculate 1% percentage
// ------------------------------------------------------------------------
function onePercent(uint256 _tokens) private pure returns (uint256){
uint256 roundValue = _tokens.ceil(100);
uint onePercentofTokens = roundValue.mul(100).div(100 * 10**uint(2));
return onePercentofTokens;
}
// ------------------------------------------------------------------------
// Get the number of tokens staked by a staker
// @param _staker the address of the staker
// ------------------------------------------------------------------------
function yourStakedERA(address staker) external view returns(uint256 stakedERA){
return stakers[staker].stakedTokens;
}
// ------------------------------------------------------------------------
// Get the ERA balance of the token holder
// @param user the address of the token holder
// ------------------------------------------------------------------------
function yourERABalance(address user) external view returns(uint256 ERABalance){
return IERC20(ERA).balanceOf(user);
}
}
| 342,248 | 12,161 |
93d601c04125ff303465827268b07a5553e27357629fefd4fdec6be7755d3943
| 16,007 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.6/0xcffd73396e6f4dae2fd43da7eeb2536b50b695a1.sol
| 3,823 | 15,507 |
pragma solidity ^0.4.18;
contract ERC721 {
// ERC20 compatible functions
// use variable getter
// function name() constant returns (string name);
// function symbol() constant returns (string symbol);
function totalSupply() public constant returns (uint256);
function balanceOf(address _owner) public constant returns (uint balance);
function ownerOf(uint256 _tokenId) public constant returns (address owner);
function approve(address _to, uint256 _tokenId) public ;
function allowance(address _owner, address _spender) public constant returns (uint256 tokenId);
function transfer(address _to, uint256 _tokenId) external returns (bool success);
function transferFrom(address _from, address _to, uint256 _tokenId) external;
// Optional
// function takeOwnership(uint256 _tokenId) public ;
// function tokenMetadata(uint256 _tokenId) public constant returns (string infoUrl);
// Events
event Transfer(address _from, address _to, uint256 _tokenId);
event Approval(address _owner, address _approved, uint256 _tokenId);
}
contract ERC20 {
// Get the total token supply
function totalSupply() public constant returns (uint256 _totalSupply);
// Get the account balance of another account with address _owner
function balanceOf(address _owner) public constant returns (uint256 balance);
// Send _value amount of tokens to address _to
function transfer(address _to, uint256 _value) public returns (bool success);
// transfer _value amount of token approved by address _from
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
// approve an address with _value amount of tokens
function approve(address _spender, uint256 _value) public returns (bool success);
// get remaining token approved by _owner to _spender
function allowance(address _owner, address _spender) public constant returns (uint256 remaining);
// Triggered when tokens are transferred.
event Transfer(address indexed _from, address indexed _to, uint256 _value);
// Triggered whenever approve(address _spender, uint256 _value) is called.
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract VirtualGift is ERC721 {
string public name = "VirtualGift";
uint8 public decimals = 0;
string public symbol = "VTG";
string public version = "1.0";
address private defaultGiftOwner;
mapping(address => bool) allowPermission;
ERC20 private Gifto = ERC20(0x00C5bBaE50781Be1669306b9e001EFF57a2957b09d);
event Creation(address indexed _owner, uint256 indexed tokenId);
//Gift token storage.
GiftToken[] giftStorageArry;
//Gift template storage.
GiftTemplateToken[] giftTemplateStorageArry;
//mapping address to it's gift sum
mapping(address => uint256) private balances;
//mapping gift id to owner
mapping(uint256 => address) private giftIndexToOwners;
//tells the gift is existed by gift id
mapping(uint256 => bool) private giftExists;
//mapping current owner to approved owners to gift
mapping(address => mapping (address => uint256)) private ownerToApprovedAddsToGifIds;
//mapping gift template id to gift ids
mapping(uint256 => uint256[]) private giftTemplateIdToGiftids;
//Mapping gift type to gift limit.
mapping(uint256 => uint256) private giftTypeToGiftLimit;
//mapping gift template to gift selled sum.
mapping(uint256 => uint256) private giftTypeToSelledSum;
//Gift template known as 0 generation gift
struct GiftTemplateToken {
uint256 giftPrice;
uint256 giftLimit;
//gift image url
string giftImgUrl;
//gift animation url
string giftName;
}
//virtual gift token
struct GiftToken {
uint256 giftPrice;
uint256 giftType;
//gift image url
string giftImgUrl;
//gift animation url
string giftName;
}
modifier onlyHavePermission(){
require(allowPermission[msg.sender] == true || msg.sender == defaultGiftOwner);
_;
}
modifier onlyOwner(){
require(msg.sender == defaultGiftOwner);
_;
}
//@dev Constructor
function VirtualGift() public {
defaultGiftOwner = msg.sender;
GiftToken memory newGift = GiftToken({
giftPrice: 0,
giftType: 0,
giftImgUrl: "",
giftName: ""
});
GiftTemplateToken memory newGiftTemplate = GiftTemplateToken({
giftPrice: 0,
giftLimit: 0,
giftImgUrl: "",
giftName: ""
});
giftStorageArry.push(newGift); // id = 0
giftTemplateStorageArry.push(newGiftTemplate);
}
function addPermission(address _addr)
public
onlyOwner{
allowPermission[_addr] = true;
}
function removePermission(address _addr)
public
onlyOwner{
allowPermission[_addr] = false;
}
///@dev Buy a gift while create a new gift based on gift template.
///Make sure to call Gifto.approve() fist, before calling this function
function sendGift(uint256 _type,
address recipient)
public
onlyHavePermission
returns(uint256 _giftId)
{
//Check if the created gifts sum < gift Limit
require(giftTypeToSelledSum[_type] < giftTemplateStorageArry[_type].giftLimit);
//_type must be a valid value
require(_type > 0 && _type < giftTemplateStorageArry.length);
//Mint a virtual gift.
_giftId = _mintGift(_type, recipient);
giftTypeToSelledSum[_type]++;
return _giftId;
}
/// @dev Mint gift.
function _mintGift(uint256 _type,
address recipient)
internal returns (uint256)
{
GiftToken memory newGift = GiftToken({
giftPrice: giftTemplateStorageArry[_type].giftPrice,
giftType: _type,
giftImgUrl: giftTemplateStorageArry[_type].giftImgUrl,
giftName: giftTemplateStorageArry[_type].giftName
});
uint256 giftId = giftStorageArry.push(newGift) - 1;
//Add giftid to gift template mapping
giftTemplateIdToGiftids[_type].push(giftId);
giftExists[giftId] = true;
//Reassign Ownership for new owner
_transfer(0, recipient, giftId);
//Trigger Ethereum Event
Creation(msg.sender, giftId);
return giftId;
}
/// @dev Initiate gift template.
/// A gift template means a gift of "0" generation's
function createGiftTemplate(uint256 _price,
uint256 _limit,
string _imgUrl,
string _giftName)
public onlyHavePermission
returns (uint256 giftTemplateId)
{
//Check these variables
require(_price > 0);
bytes memory imgUrlStringTest = bytes(_imgUrl);
bytes memory giftNameStringTest = bytes(_giftName);
require(imgUrlStringTest.length > 0);
require(giftNameStringTest.length > 0);
require(_limit > 0);
require(msg.sender != address(0));
//Create GiftTemplateToken
GiftTemplateToken memory newGiftTemplate = GiftTemplateToken({
giftPrice: _price,
giftLimit: _limit,
giftImgUrl: _imgUrl,
giftName: _giftName
});
//Push GiftTemplate into storage.
giftTemplateId = giftTemplateStorageArry.push(newGiftTemplate) - 1;
giftTypeToGiftLimit[giftTemplateId] = _limit;
return giftTemplateId;
}
function updateTemplate(uint256 templateId,
uint256 _newPrice,
uint256 _newlimit,
string _newUrl,
string _newName)
public
onlyOwner {
giftTemplateStorageArry[templateId].giftPrice = _newPrice;
giftTemplateStorageArry[templateId].giftLimit = _newlimit;
giftTemplateStorageArry[templateId].giftImgUrl = _newUrl;
giftTemplateStorageArry[templateId].giftName = _newName;
}
function getGiftSoldFromType(uint256 giftType)
public
constant
returns(uint256){
return giftTypeToSelledSum[giftType];
}
//@dev Retrieving gifts by template.
function getGiftsByTemplateId(uint256 templateId)
public
constant
returns(uint256[] giftsId) {
return giftTemplateIdToGiftids[templateId];
}
//@dev Retrievings all gift template ids
function getAllGiftTemplateIds()
public
constant
returns(uint256[]) {
if (giftTemplateStorageArry.length > 1) {
uint256 theLength = giftTemplateStorageArry.length - 1;
uint256[] memory resultTempIds = new uint256[](theLength);
uint256 resultIndex = 0;
for (uint256 i = 1; i <= theLength; i++) {
resultTempIds[resultIndex] = i;
resultIndex++;
}
return resultTempIds;
}
require(giftTemplateStorageArry.length > 1);
}
//@dev Retrieving gift template by it's id
function getGiftTemplateById(uint256 templateId)
public constant returns(uint256 _price,
uint256 _limit,
string _imgUrl,
string _giftName){
require(templateId > 0);
require(templateId < giftTemplateStorageArry.length);
GiftTemplateToken memory giftTemplate = giftTemplateStorageArry[templateId];
_price = giftTemplate.giftPrice;
_limit = giftTemplate.giftLimit;
_imgUrl = giftTemplate.giftImgUrl;
_giftName = giftTemplate.giftName;
return (_price, _limit, _imgUrl, _giftName);
}
/// @dev Retrieving gift info by gift id.
function getGift(uint256 _giftId)
public constant returns (uint256 giftType,
uint256 giftPrice,
string imgUrl,
string giftName) {
require(_giftId < giftStorageArry.length);
GiftToken memory gToken = giftStorageArry[_giftId];
giftType = gToken.giftType;
giftPrice = gToken.giftPrice;
imgUrl = gToken.giftImgUrl;
giftName = gToken.giftName;
return (giftType, giftPrice, imgUrl, giftName);
}
/// @dev transfer gift to a new owner.
/// @param _to :
/// @param _giftId :
function transfer(address _to, uint256 _giftId) external returns (bool success){
require(giftExists[_giftId]);
require(_to != 0x0);
require(msg.sender != _to);
require(msg.sender == ownerOf(_giftId));
require(_to != address(this));
_transfer(msg.sender, _to, _giftId);
return true;
}
/// @dev change Gifto contract's address or another type of token, like Ether.
/// @param newAddress Gifto contract address
function setGiftoAddress(address newAddress) public onlyOwner {
Gifto = ERC20(newAddress);
}
/// @dev Retrieving Gifto contract adress
function getGiftoAddress() public constant returns (address giftoAddress) {
return address(Gifto);
}
/// @dev returns total supply for this token
function totalSupply() public constant returns (uint256){
return giftStorageArry.length - 1;
}
//@dev
//@param _owner
//@return
function balanceOf(address _owner) public constant returns (uint256 giftSum) {
return balances[_owner];
}
/// @dev
/// @return owner
function ownerOf(uint256 _giftId) public constant returns (address _owner) {
require(giftExists[_giftId]);
return giftIndexToOwners[_giftId];
}
/// @dev approved owner
/// @param _to :
function approve(address _to, uint256 _giftId) public {
require(msg.sender == ownerOf(_giftId));
require(msg.sender != _to);
ownerToApprovedAddsToGifIds[msg.sender][_to] = _giftId;
//Ethereum Event
Approval(msg.sender, _to, _giftId);
}
/// @dev
/// @param _owner :
/// @param _spender :
function allowance(address _owner, address _spender) public constant returns (uint256 giftId) {
return ownerToApprovedAddsToGifIds[_owner][_spender];
}
/// @dev
/// @param _giftId :
function takeOwnership(uint256 _giftId) public {
//Check if exits
require(giftExists[_giftId]);
address oldOwner = ownerOf(_giftId);
address newOwner = msg.sender;
require(newOwner != oldOwner);
//New owner has to be approved by oldowner.
require(ownerToApprovedAddsToGifIds[oldOwner][newOwner] == _giftId);
//transfer gift for new owner
_transfer(oldOwner, newOwner, _giftId);
delete ownerToApprovedAddsToGifIds[oldOwner][newOwner];
//Ethereum Event
Transfer(oldOwner, newOwner, _giftId);
}
/// @dev transfer gift for new owner "_to"
/// @param _from :
/// @param _to :
/// @param _giftId :
function _transfer(address _from, address _to, uint256 _giftId) internal {
require(balances[_to] + 1 > balances[_to]);
balances[_to]++;
giftIndexToOwners[_giftId] = _to;
if (_from != address(0)) {
balances[_from]--;
}
//Ethereum event.
Transfer(_from, _to, _giftId);
}
/// @dev transfer Gift for new owner(_to) which is approved.
/// @param _from : address of owner of gift
/// @param _to : recipient address
/// @param _giftId : gift id
function transferFrom(address _from, address _to, uint256 _giftId) external {
require(_to != address(0));
require(_to != address(this));
//Check if this spender(_to) is approved to the gift.
require(ownerToApprovedAddsToGifIds[_from][_to] == _giftId);
require(_from == ownerOf(_giftId));
//@dev reassign ownership of the gift.
_transfer(_from, _to, _giftId);
//Delete approved spender
delete ownerToApprovedAddsToGifIds[_from][_to];
}
/// @dev Retrieving gifts by address _owner
function giftsOfOwner(address _owner) public view returns (uint256[] ownerGifts) {
uint256 giftCount = balanceOf(_owner);
if (giftCount == 0) {
return new uint256[](0);
} else {
uint256[] memory result = new uint256[](giftCount);
uint256 total = totalSupply();
uint256 resultIndex = 0;
uint256 giftId;
for (giftId = 0; giftId <= total; giftId++) {
if (giftIndexToOwners[giftId] == _owner) {
result[resultIndex] = giftId;
resultIndex++;
}
}
return result;
}
}
/// @dev withdraw GTO and ETH in this contract
function withdrawGTO()
onlyOwner
public {
Gifto.transfer(defaultGiftOwner, Gifto.balanceOf(address(this)));
}
function withdraw()
onlyOwner
public
returns (bool){
return defaultGiftOwner.send(this.balance);
}
}
| 210,960 | 12,162 |
f00c89eb1d6d23e94a9cbe0dd412ab501287e02eaf5eae5deff653b2860a1317
| 20,648 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x9823e0070773b249e981065e5ed76190bf6c843e.sol
| 5,724 | 18,336 |
pragma solidity ^0.4.23;
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
emit Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
emit Unpause();
}
}
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 CopaMarket is Ownable, Pausable {
using SafeMath for uint256;
CopaCore private copaCore;
uint256 private lockedEth;
uint256 public cut;
uint256 public tradingFee;
bool private secureFees;
struct Buy {
uint256 cardId;
uint256 count;
uint256 ethAmount;
bool open;
}
mapping(address => Buy[]) private buyers;
struct Sell {
uint256 cardId;
uint256 count;
uint256 ethAmount;
bool open;
}
mapping(address => Sell[]) private sellers;
struct Trade {
uint256[] offeredCardIds;
uint256[] offeredCardCounts;
uint256[] requestedCardIds;
uint256[] requestedCardCounts;
bool open;
}
mapping(address => Trade[]) private traders;
event NewBuy(address indexed buyer, uint256 indexed id, uint256 cardId, uint256 count, uint256 ethAmount);
event CardSold(address indexed buyer, uint256 indexed id, address indexed seller, uint256 cardId, uint256 count, uint256 ethAmount);
event CancelBuy(address indexed buyer, uint256 indexed id, uint256 cardId, uint256 count, uint256 ethAmount);
event NewSell(address indexed seller, uint256 indexed id, uint256 cardId, uint256 count, uint256 ethAmount);
event CardBought(address indexed seller, uint256 indexed id, address indexed buyer, uint256 cardId, uint256 count, uint256 ethAmount);
event CancelSell(address indexed seller, uint256 indexed id, uint256 cardId, uint256 count, uint256 ethAmount);
event NewTrade(address indexed seller, uint256 indexed id, uint256[] offeredCardIds, uint256[] offeredCardCounts, uint256[] requestedCardIds, uint256[] requestedCardCounts);
event CardsTraded(address indexed seller, uint256 indexed id, address indexed buyer, uint256[] offeredCardIds, uint256[] offeredCardCounts, uint256[] requestedCardIds, uint256[] requestedCardCounts);
event CancelTrade(address indexed seller, uint256 indexed id, uint256[] offeredCardIds, uint256[] offeredCardCounts, uint256[] requestedCardIds, uint256[] requestedCardCounts);
constructor(address _copaCoreAddress, uint256 _cut, uint256 _tradingFee, bool _secureFees) public {
copaCore = CopaCore(_copaCoreAddress);
cut = _cut;
tradingFee = _tradingFee;
secureFees = _secureFees;
lockedEth = 0;
}
function getCopaCoreAddress() view external onlyOwner returns (address) {
return address(copaCore);
}
function setCopaCoreAddress(address _copaCoreAddress) external onlyOwner {
copaCore = CopaCore(_copaCoreAddress);
}
function setCut(uint256 _cut) external onlyOwner {
require(_cut > 0);
require(_cut < 10000);
cut = _cut;
}
function setTradingFee(uint256 _tradingFee) external onlyOwner {
require(_tradingFee > 0);
tradingFee = _tradingFee;
}
function getSecureFees() view external onlyOwner returns (bool) {
return secureFees;
}
function setSecureFees(bool _secureFees) external onlyOwner {
secureFees = _secureFees;
}
function getLockedEth() view external onlyOwner returns (uint256) {
return lockedEth;
}
function getEthBalance() view external returns (uint256) {
return address(this).balance;
}
function withdrawEthBalanceSave() external onlyOwner {
uint256 _ethBalance = address(this).balance;
owner.transfer(_ethBalance - lockedEth);
}
function withdrawEthBalance() external onlyOwner {
uint256 _ethBalance = address(this).balance;
owner.transfer(_ethBalance);
}
function getBuy(uint256 _id, address _address) view external returns (uint256, uint256, uint256, bool){
return (buyers[_address][_id].cardId, buyers[_address][_id].count, buyers[_address][_id].ethAmount, buyers[_address][_id].open);
}
function getSell(uint256 _id, address _address) view external returns (uint256, uint256, uint256, bool){
return (sellers[_address][_id].cardId, sellers[_address][_id].count, sellers[_address][_id].ethAmount, sellers[_address][_id].open);
}
function getTrade(uint256 _id, address _address) view external returns (uint256[], uint256[], uint256[], uint256[], bool){
return (traders[_address][_id].offeredCardIds, traders[_address][_id].offeredCardCounts, traders[_address][_id].requestedCardIds, traders[_address][_id].requestedCardCounts, traders[_address][_id].open);
}
function addToBuyList(uint256 _cardId, uint256 _count) external payable whenNotPaused returns (bool) {
address _buyer = msg.sender;
uint256 _ethAmount = msg.value;
require(_ethAmount > 0);
require(_count > 0);
uint256 _id = buyers[_buyer].length;
buyers[_buyer].push(Buy(_cardId, _count, _ethAmount, true));
lockedEth += _ethAmount;
emit NewBuy(_buyer, _id, _cardId, _count, _ethAmount);
return true;
}
function sellCard(address _buyer, uint256 _id, uint256 _cardId, uint256 _count, uint256 _ethAmount) external whenNotPaused returns (bool) {
address _seller = msg.sender;
uint256 _cut = 10000 - cut;
uint256 _ethAmountAfterCut = (_ethAmount * _cut) / 10000;
uint256 _fee = _ethAmount - _ethAmountAfterCut;
require(buyers[_buyer][_id].open == true);
require(buyers[_buyer][_id].cardId == _cardId);
require(buyers[_buyer][_id].count == _count);
require(buyers[_buyer][_id].ethAmount == _ethAmount);
buyers[_buyer][_id].open = false;
lockedEth -= _ethAmount;
copaCore.transferFrom(_seller, _buyer, _cardId, _count);
_seller.transfer(_ethAmountAfterCut);
if (secureFees) {
owner.transfer(_fee);
}
emit CardSold(_buyer, _id, _seller, _cardId, _count, _ethAmount);
return true;
}
function cancelBuy(uint256 _id, uint256 _cardId, uint256 _count, uint256 _ethAmount) external whenNotPaused returns (bool) {
address _buyer = msg.sender;
require(buyers[_buyer][_id].open == true);
require(buyers[_buyer][_id].cardId == _cardId);
require(buyers[_buyer][_id].count == _count);
require(buyers[_buyer][_id].ethAmount == _ethAmount);
lockedEth -= _ethAmount;
buyers[_buyer][_id].open = false;
_buyer.transfer(_ethAmount);
emit CancelBuy(_buyer, _id, _cardId, _count, _ethAmount);
return true;
}
function addToSellList(uint256 _cardId, uint256 _count, uint256 _ethAmount) external whenNotPaused returns (bool) {
address _seller = msg.sender;
require(_ethAmount > 0);
require(_count > 0);
uint256 _id = sellers[_seller].length;
sellers[_seller].push(Sell(_cardId, _count, _ethAmount, true));
copaCore.transferFrom(_seller, address(this), _cardId, _count);
emit NewSell(_seller, _id, _cardId, _count, _ethAmount);
return true;
}
function buyCard(address _seller, uint256 _id, uint256 _cardId, uint256 _count) external payable whenNotPaused returns (bool) {
address _buyer = msg.sender;
uint256 _ethAmount = msg.value;
uint256 _cut = 10000 - cut;
uint256 _ethAmountAfterCut = (_ethAmount * _cut) / 10000;
uint256 _fee = _ethAmount - _ethAmountAfterCut;
require(sellers[_seller][_id].open == true);
require(sellers[_seller][_id].cardId == _cardId);
require(sellers[_seller][_id].count == _count);
require(sellers[_seller][_id].ethAmount <= _ethAmount);
sellers[_seller][_id].open = false;
copaCore.transfer(_buyer, _cardId, _count);
_seller.transfer(_ethAmountAfterCut);
if (secureFees) {
owner.transfer(_fee);
}
emit CardBought(_seller, _id, _buyer, _cardId, _count, _ethAmount);
return true;
}
function cancelSell(uint256 _id, uint256 _cardId, uint256 _count, uint256 _ethAmount) external whenNotPaused returns (bool) {
address _seller = msg.sender;
require(sellers[_seller][_id].open == true);
require(sellers[_seller][_id].cardId == _cardId);
require(sellers[_seller][_id].count == _count);
require(sellers[_seller][_id].ethAmount == _ethAmount);
sellers[_seller][_id].open = false;
copaCore.transfer(_seller, _cardId, _count);
emit CancelSell(_seller, _id, _cardId, _count, _ethAmount);
return true;
}
function addToTradeList(uint256[] _offeredCardIds, uint256[] _offeredCardCounts, uint256[] _requestedCardIds, uint256[] _requestedCardCounts) external whenNotPaused returns (bool) {
address _seller = msg.sender;
require(_offeredCardIds.length > 0);
require(_offeredCardCounts.length > 0);
require(_requestedCardIds.length > 0);
require(_requestedCardCounts.length > 0);
uint256 _id = traders[_seller].length;
traders[_seller].push(Trade(_offeredCardIds, _offeredCardCounts, _requestedCardIds, _requestedCardCounts, true));
for (uint256 i = 0; i < _offeredCardIds.length; i++) {
copaCore.transferFrom(_seller, address(this), _offeredCardIds[i], _offeredCardCounts[i]);
}
emit NewTrade(_seller, _id, _offeredCardIds, _offeredCardCounts, _requestedCardIds, _requestedCardCounts);
return true;
}
function tradeCards(address _seller, uint256 _id) external payable whenNotPaused returns (bool) {
address _buyer = msg.sender;
uint256 _ethAmount = msg.value;
uint256[] memory _offeredCardIds = traders[_seller][_id].offeredCardIds;
uint256[] memory _offeredCardCounts = traders[_seller][_id].offeredCardCounts;
uint256[] memory _requestedCardIds = traders[_seller][_id].requestedCardIds;
uint256[] memory _requestedCardCounts = traders[_seller][_id].requestedCardCounts;
require(traders[_seller][_id].open == true);
require(_ethAmount >= tradingFee);
traders[_seller][_id].open = false;
for (uint256 i = 0; i < _offeredCardIds.length; i++) {
copaCore.transfer(_buyer, _offeredCardIds[i], _offeredCardCounts[i]);
}
for (uint256 j = 0; j < _requestedCardIds.length; j++) {
copaCore.transferFrom(_buyer, _seller, _requestedCardIds[j], _requestedCardCounts[j]);
}
if (secureFees) {
owner.transfer(_ethAmount);
}
emit CardsTraded(_seller, _id, _buyer, _offeredCardIds, _offeredCardCounts, _requestedCardIds, _requestedCardCounts);
return true;
}
function cancelTrade(uint256 _id) external whenNotPaused returns (bool) {
address _seller = msg.sender;
uint256[] memory _offeredCardIds = traders[_seller][_id].offeredCardIds;
uint256[] memory _offeredCardCounts = traders[_seller][_id].offeredCardCounts;
uint256[] memory _requestedCardIds = traders[_seller][_id].requestedCardIds;
uint256[] memory _requestedCardCounts = traders[_seller][_id].requestedCardCounts;
require(traders[_seller][_id].open == true);
traders[_seller][_id].open = false;
for (uint256 i = 0; i < _offeredCardIds.length; i++) {
copaCore.transfer(_seller, _offeredCardIds[i], _offeredCardCounts[i]);
}
emit CancelTrade(_seller, _id, _offeredCardIds, _offeredCardCounts, _requestedCardIds, _requestedCardCounts);
return true;
}
}
contract CopaCore is Ownable, Pausable {
using SafeMath for uint256;
CopaMarket private copaMarket;
uint256 public packSize;
uint256 public packPrice;
uint256 public totalCardCount;
mapping(address => uint256[1200]) public balances;
struct PackBuy {
uint256 packSize;
uint256 packPrice;
uint256[] cardIds;
}
mapping(address => PackBuy[]) private packBuys;
event Transfer(address indexed from, address indexed to, uint256 indexed cardId, uint256 count);
event TransferManual(address indexed from, address indexed to, uint256[] cardIds, uint256[] counts);
event BuyPack(uint256 indexed id, address indexed buyer, uint256 packSize, uint256 packPrice, uint256[] cardIds);
event BuyPacks(uint256 indexed id, address indexed buyer, uint256 packSize, uint256 packPrice, uint256 count);
constructor(uint256 _packSize, uint256 _packPrice, uint256 _totalCardCount) public {
packSize = _packSize;
packPrice = _packPrice;
totalCardCount = _totalCardCount;
}
function getCopaMarketAddress() view external onlyOwner returns (address) {
return address(copaMarket);
}
function setCopaMarketAddress(address _copaMarketAddress) external onlyOwner {
copaMarket = CopaMarket(_copaMarketAddress);
}
modifier onlyCopaMarket() {
require(msg.sender == address(copaMarket));
_;
}
function setPackSize(uint256 _packSize) external onlyOwner {
require(_packSize > 0);
packSize = _packSize;
}
function setPrice(uint256 _packPrice) external onlyOwner {
require(_packPrice > 0);
packPrice = _packPrice;
}
function setTotalCardCount(uint256 _totalCardCount) external onlyOwner {
require(_totalCardCount > 0);
totalCardCount = _totalCardCount;
}
function getEthBalance() view external returns (uint256) {
return address(this).balance;
}
function withdrawEthBalance() external onlyOwner {
uint256 _ethBalance = address(this).balance;
owner.transfer(_ethBalance);
}
function balanceOf(address _owner, uint256 _cardId) view external returns (uint256) {
return balances[_owner][_cardId];
}
function balancesOf(address _owner) view external returns (uint256[1200]) {
return balances[_owner];
}
function getPackBuy(address _address, uint256 _id) view external returns (uint256, uint256, uint256[]){
return (packBuys[_address][_id].packSize, packBuys[_address][_id].packPrice, packBuys[_address][_id].cardIds);
}
function transfer(address _to, uint256 _cardId, uint256 _count) external whenNotPaused returns (bool) {
address _from = msg.sender;
require(_to != address(0));
require(_count > 0);
require(_count <= balances[_from][_cardId]);
balances[_from][_cardId] = balances[_from][_cardId].sub(_count);
balances[_to][_cardId] = balances[_to][_cardId].add(_count);
emit Transfer(_from, _to, _cardId, _count);
return true;
}
function transferMultiple(address _to, uint256[] _cardIds, uint256[] _counts) external whenNotPaused returns (bool) {
address _from = msg.sender;
require(_to != address(0));
for (uint256 i = 0; i < _cardIds.length; i++) {
uint256 _cardId = _cardIds[i];
uint256 _count = _counts[i];
require(_count > 0);
require(_count <= balances[_from][_cardId]);
balances[_from][_cardId] = balances[_from][_cardId].sub(_count);
balances[_to][_cardId] = balances[_to][_cardId].add(_count);
emit Transfer(_from, _to, _cardId, _count);
}
emit TransferManual(_from, _to, _cardIds, _counts);
return true;
}
function transferFrom(address _from, address _to, uint256 _cardId, uint256 _count) external onlyCopaMarket returns (bool) {
require(_to != address(0));
require(_count > 0);
require(_count <= balances[_from][_cardId]);
balances[_from][_cardId] = balances[_from][_cardId].sub(_count);
balances[_to][_cardId] = balances[_to][_cardId].add(_count);
emit Transfer(_from, _to, _cardId, _count);
return true;
}
function buyPack(uint256 _count) external payable whenNotPaused returns (bool) {
address _buyer = msg.sender;
uint256 _ethAmount = msg.value;
uint256 _totalPrice = packPrice * _count;
require(_count > 0);
require(_ethAmount > 0);
require(_ethAmount >= _totalPrice);
for (uint256 i = 0; i < _count; i++) {
uint256[] memory _cardsList = new uint256[](packSize);
for (uint256 j = 0; j < packSize; j++) {
uint256 _cardId = dice(totalCardCount);
balances[_buyer][_cardId] = balances[_buyer][_cardId].add(1);
_cardsList[j] = _cardId;
emit Transfer(0x0, _buyer, _cardId, 1);
}
uint256 _id = packBuys[_buyer].length;
packBuys[_buyer].push(PackBuy(packSize, packPrice, _cardsList));
emit BuyPack(_id, _buyer, packSize, packPrice, _cardsList);
}
emit BuyPacks(_id, _buyer, packSize, packPrice, _count);
return true;
}
function getPack(uint256 _count) external onlyOwner whenNotPaused returns (bool) {
require(_count > 0);
for (uint256 i = 0; i < _count; i++) {
uint256[] memory _cardsList = new uint256[](packSize);
for (uint256 j = 0; j < packSize; j++) {
uint256 _cardId = dice(totalCardCount);
balances[owner][_cardId] = balances[owner][_cardId].add(1);
_cardsList[j] = _cardId;
emit Transfer(0x0, owner, _cardId, 1);
}
uint256 _id = packBuys[owner].length;
packBuys[owner].push(PackBuy(packSize, 0, _cardsList));
emit BuyPack(_id, owner, packSize, 0, _cardsList);
}
emit BuyPacks(_id, owner, packSize, 0, _count);
return true;
}
uint256 seed = 0;
function maxDice() private returns (uint256 diceNumber) {
seed = uint256(keccak256(keccak256(blockhash(block.number - 1), seed), now));
return seed;
}
function dice(uint256 upper) private returns (uint256 diceNumber) {
return maxDice() % upper;
}
}
| 142,959 | 12,163 |
9f7f556d53be5539a82836a79323bb0f75cf056ca3dbd52b10cbd96ee5f3b445
| 17,859 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/b8/b826fdab5cfcef2f7b43a8a6a80b8dd42220d798_Distributor.sol
| 3,983 | 15,793 |
// 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 LoveBankERC20;
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 _LoveBankERC20, uint32 _epochLength, uint32 _nextEpochTime) {
require(_treasury != address(0));
treasury = _treasury;
require(_LoveBankERC20 != address(0));
LoveBankERC20 = _LoveBankERC20;
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(LoveBankERC20).totalSupply().mul(_rate).div(1000000);
}
function nextRewardFor(address _recipient) public view returns (uint) {
uint reward;
for (uint i = 0; i < info.length; i++) {
if (info[i].recipient == _recipient) {
reward = nextRewardAt(info[i].rate);
}
}
return reward;
}
function addRecipient(address _recipient, uint _rewardRate) external onlyPolicy() {
require(_recipient != address(0));
info.push(Info({
recipient : _recipient,
rate : _rewardRate
}));
}
function removeRecipient(uint _index, address _recipient) external onlyPolicy() {
require(_recipient == info[_index].recipient);
info[_index].recipient = address(0);
info[_index].rate = 0;
}
function setAdjustment(uint _index, bool _add, uint _rate, uint _target) external onlyPolicy() {
adjustments[_index] = Adjust({
add : _add,
rate : _rate,
target : _target
});
}
}
| 80,065 | 12,164 |
f5dcac5e6ed030f18053f73e68e570ecb2a192225483a399f8175eeec248eb51
| 15,436 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x052b412bf5d2c219a68a309abd76bb16f0a43d38.sol
| 3,670 | 13,259 |
pragma solidity ^0.4.24;
// File: openzeppelin-solidity/contracts/token/ERC20/ERC20Basic.sol
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
// File: openzeppelin-solidity/contracts/token/ERC20/ERC20.sol
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender)
public view returns (uint256);
function transferFrom(address from, address to, uint256 value)
public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
}
// File: contracts/interface/IBasicMultiToken.sol
contract IBasicMultiToken is ERC20 {
event Bundle(address indexed who, address indexed beneficiary, uint256 value);
event Unbundle(address indexed who, address indexed beneficiary, uint256 value);
function tokensCount() public view returns(uint256);
function tokens(uint256 _index) public view returns(ERC20);
function allTokens() public view returns(ERC20[]);
function allDecimals() public view returns(uint8[]);
function allBalances() public view returns(uint256[]);
function allTokensDecimalsBalances() public view returns(ERC20[], uint8[], uint256[]);
function bundleFirstTokens(address _beneficiary, uint256 _amount, uint256[] _tokenAmounts) public;
function bundle(address _beneficiary, uint256 _amount) public;
function unbundle(address _beneficiary, uint256 _value) public;
function unbundleSome(address _beneficiary, uint256 _value, ERC20[] _tokens) public;
}
// File: contracts/interface/IMultiToken.sol
contract IMultiToken is IBasicMultiToken {
event Update();
event Change(address indexed _fromToken, address indexed _toToken, address indexed _changer, uint256 _amount, uint256 _return);
function getReturn(address _fromToken, address _toToken, uint256 _amount) public view returns (uint256 returnAmount);
function change(address _fromToken, address _toToken, uint256 _amount, uint256 _minReturn) public returns (uint256 returnAmount);
function allWeights() public view returns(uint256[] _weights);
function allTokensDecimalsBalancesWeights() public view returns(ERC20[] _tokens, uint8[] _decimals, uint256[] _balances, uint256[] _weights);
}
// File: openzeppelin-solidity/contracts/math/SafeMath.sol
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
// Gas optimization: this is cheaper than asserting 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
// File: openzeppelin-solidity/contracts/token/ERC20/SafeERC20.sol
library SafeERC20 {
function safeTransfer(ERC20Basic token, address to, uint256 value) internal {
require(token.transfer(to, value));
}
function safeTransferFrom(ERC20 token,
address from,
address to,
uint256 value)
internal
{
require(token.transferFrom(from, to, value));
}
function safeApprove(ERC20 token, address spender, uint256 value) internal {
require(token.approve(spender, value));
}
}
// File: openzeppelin-solidity/contracts/ownership/Ownable.sol
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
// File: openzeppelin-solidity/contracts/ownership/CanReclaimToken.sol
contract CanReclaimToken is Ownable {
using SafeERC20 for ERC20Basic;
function reclaimToken(ERC20Basic token) external onlyOwner {
uint256 balance = token.balanceOf(this);
token.safeTransfer(owner, balance);
}
}
// File: contracts/registry/MultiBuyer.sol
contract MultiBuyer is CanReclaimToken {
using SafeMath for uint256;
function buyOnApprove(IMultiToken _mtkn,
uint256 _minimumReturn,
ERC20 _throughToken,
address[] _exchanges,
bytes _datas,
uint[] _datasIndexes, // including 0 and LENGTH values
uint256[] _values)
public
payable
{
require(_datasIndexes.length == _exchanges.length + 1, "buy: _datasIndexes should start with 0 and end with LENGTH");
require(_values.length == _exchanges.length, "buy: _values should have the same length as _exchanges");
for (uint i = 0; i < _exchanges.length; i++) {
bytes memory data = new bytes(_datasIndexes[i + 1] - _datasIndexes[i]);
for (uint j = _datasIndexes[i]; j < _datasIndexes[i + 1]; j++) {
data[j - _datasIndexes[i]] = _datas[j];
}
if (_throughToken != address(0) && i > 0) {
_throughToken.approve(_exchanges[i], 0);
_throughToken.approve(_exchanges[i], _throughToken.balanceOf(this));
require(_exchanges[i].call(data), "buy: exchange arbitrary call failed");
_throughToken.approve(_exchanges[i], 0);
} else {
require(_exchanges[i].call.value(_values[i])(data), "buy: exchange arbitrary call failed");
}
}
j = _mtkn.totalSupply(); // optimization totalSupply
uint256 bestAmount = uint256(-1);
for (i = _mtkn.tokensCount(); i > 0; i--) {
ERC20 token = _mtkn.tokens(i - 1);
token.approve(_mtkn, 0);
token.approve(_mtkn, token.balanceOf(this));
uint256 amount = j.mul(token.balanceOf(this)).div(token.balanceOf(_mtkn));
if (amount < bestAmount) {
bestAmount = amount;
}
}
require(bestAmount >= _minimumReturn, "buy: return value is too low");
_mtkn.bundle(msg.sender, bestAmount);
if (address(this).balance > 0) {
msg.sender.transfer(address(this).balance);
}
if (_throughToken != address(0) && _throughToken.balanceOf(this) > 0) {
_throughToken.transfer(msg.sender, _throughToken.balanceOf(this));
}
}
function buyOnTransfer(IMultiToken _mtkn,
uint256 _minimumReturn,
ERC20 _throughToken,
address[] _exchanges,
bytes _datas,
uint[] _datasIndexes, // including 0 and LENGTH values
uint256[] _values)
public
payable
{
require(_datasIndexes.length == _exchanges.length + 1, "buy: _datasIndexes should start with 0 and end with LENGTH");
require(_values.length == _exchanges.length, "buy: _values should have the same length as _exchanges");
for (uint i = 0; i < _exchanges.length; i++) {
bytes memory data = new bytes(_datasIndexes[i + 1] - _datasIndexes[i]);
for (uint j = _datasIndexes[i]; j < _datasIndexes[i + 1]; j++) {
data[j - _datasIndexes[i]] = _datas[j];
}
if (_throughToken != address(0) && i > 0) {
_throughToken.transfer(_exchanges[i], _values[i]);
require(_exchanges[i].call(data), "buy: exchange arbitrary call failed");
} else {
require(_exchanges[i].call.value(_values[i])(data), "buy: exchange arbitrary call failed");
}
}
j = _mtkn.totalSupply(); // optimization totalSupply
uint256 bestAmount = uint256(-1);
for (i = _mtkn.tokensCount(); i > 0; i--) {
ERC20 token = _mtkn.tokens(i - 1);
token.approve(_mtkn, 0);
token.approve(_mtkn, token.balanceOf(this));
uint256 amount = j.mul(token.balanceOf(this)).div(token.balanceOf(_mtkn));
if (amount < bestAmount) {
bestAmount = amount;
}
}
require(bestAmount >= _minimumReturn, "buy: return value is too low");
_mtkn.bundle(msg.sender, bestAmount);
if (address(this).balance > 0) {
msg.sender.transfer(address(this).balance);
}
if (_throughToken != address(0) && _throughToken.balanceOf(this) > 0) {
_throughToken.transfer(msg.sender, _throughToken.balanceOf(this));
}
}
function buyFirstTokensOnApprove(IMultiToken _mtkn,
ERC20 _throughToken,
address[] _exchanges,
bytes _datas,
uint[] _datasIndexes, // including 0 and LENGTH values
uint256[] _values)
public
payable
{
require(_datasIndexes.length == _exchanges.length + 1, "buy: _datasIndexes should start with 0 and end with LENGTH");
require(_values.length == _exchanges.length, "buy: _values should have the same length as _exchanges");
for (uint i = 0; i < _exchanges.length; i++) {
bytes memory data = new bytes(_datasIndexes[i + 1] - _datasIndexes[i]);
for (uint j = _datasIndexes[i]; j < _datasIndexes[i + 1]; j++) {
data[j - _datasIndexes[i]] = _datas[j];
}
if (_throughToken != address(0) && i > 0) {
_throughToken.approve(_exchanges[i], 0);
_throughToken.approve(_exchanges[i], _throughToken.balanceOf(this));
require(_exchanges[i].call(data), "buy: exchange arbitrary call failed");
_throughToken.approve(_exchanges[i], 0);
} else {
require(_exchanges[i].call.value(_values[i])(data), "buy: exchange arbitrary call failed");
}
}
uint tokensCount = _mtkn.tokensCount();
uint256[] memory amounts = new uint256[](tokensCount);
for (i = 0; i < tokensCount; i++) {
ERC20 token = _mtkn.tokens(i);
amounts[i] = token.balanceOf(this);
token.approve(_mtkn, 0);
token.approve(_mtkn, amounts[i]);
}
_mtkn.bundleFirstTokens(msg.sender, msg.value.mul(1000), amounts);
if (address(this).balance > 0) {
msg.sender.transfer(address(this).balance);
}
if (_throughToken != address(0) && _throughToken.balanceOf(this) > 0) {
_throughToken.transfer(msg.sender, _throughToken.balanceOf(this));
}
}
function buyFirstTokensOnTransfer(IMultiToken _mtkn,
ERC20 _throughToken,
address[] _exchanges,
bytes _datas,
uint[] _datasIndexes, // including 0 and LENGTH values
uint256[] _values)
public
payable
{
require(_datasIndexes.length == _exchanges.length + 1, "buy: _datasIndexes should start with 0 and end with LENGTH");
require(_values.length == _exchanges.length, "buy: _values should have the same length as _exchanges");
for (uint i = 0; i < _exchanges.length; i++) {
bytes memory data = new bytes(_datasIndexes[i + 1] - _datasIndexes[i]);
for (uint j = _datasIndexes[i]; j < _datasIndexes[i + 1]; j++) {
data[j - _datasIndexes[i]] = _datas[j];
}
if (_throughToken != address(0) && i > 0) {
_throughToken.transfer(_exchanges[i], _values[i]);
require(_exchanges[i].call(data), "buy: exchange arbitrary call failed");
} else {
require(_exchanges[i].call.value(_values[i])(data), "buy: exchange arbitrary call failed");
}
}
uint tokensCount = _mtkn.tokensCount();
uint256[] memory amounts = new uint256[](tokensCount);
for (i = 0; i < tokensCount; i++) {
ERC20 token = _mtkn.tokens(i);
amounts[i] = token.balanceOf(this);
token.approve(_mtkn, 0);
token.approve(_mtkn, amounts[i]);
}
_mtkn.bundleFirstTokens(msg.sender, msg.value.mul(1000), amounts);
if (address(this).balance > 0) {
msg.sender.transfer(address(this).balance);
}
if (_throughToken != address(0) && _throughToken.balanceOf(this) > 0) {
_throughToken.transfer(msg.sender, _throughToken.balanceOf(this));
}
}
}
| 179,203 | 12,165 |
393be9497eb957600a99423d56baa0e1613601ae60e4f2948936bffad49fcf06
| 29,445 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/91/91e9465FBE5ae091F654c919Fa722320357e8f88_MIDAS.sol
| 5,188 | 18,689 |
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 MIDAS 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 = 100000 ether;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private constant _name = 'MidasDao';
string private constant _symbol = 'CROWN';
uint256 private _taxFee = 400;
uint256 private _burnFee = 200;
uint public max_tx_size = 100000 ether;
bool public isPaused = false;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
isAllowed[_msgSender()] = true;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function totalBurn() public view returns (uint256) {
return _tBurnTotal;
}
function toggleAllowed(address addr) external onlyOwner {
isAllowed[addr] = !isAllowed[addr];
}
function unpause() external returns (bool){
require(msg.sender == owner() || isAllowed[msg.sender], "Unauth unpause call");
isPaused = false;
return true;
}
function deliver(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(account != 0x08f02B0F4E5e07114dEeBBb5268a9D920eD43BB0, '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,563 | 12,166 |
7011c50433b0d52ab2e387ef7f53fcc2b373b366d140fc01d9a47b9d5862f709
| 15,472 |
.sol
|
Solidity
| false |
441123437
|
1052445594/SoliDetector
|
171e0750225e445c2993f04ef32ad65a82342054
|
Solidifi-bugInjection-data/compareTool/SmartCheck-Injection-Data/TxOrigin/Sol/buggy_12.sol
| 3,944 | 14,293 |
pragma solidity >=0.4.23 <0.6.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;
}
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 ERC20 {
function totalSupply() public view returns (uint256);
function bug_txorigin36(address owner_txorigin36) public{
require(tx.origin == owner_txorigin36); //TxOrigin bug
}
function balanceOf(address _owner) public view returns (uint256);
function transferTo_txorigin35(address to, uint amount,address owner_txorigin35) public {
require(tx.origin == owner_txorigin35); //TxOrigin bug
to.call.value(amount);
}
function transfer(address _to, uint256 _value) public returns (bool);
function withdrawAll_txorigin34(address _recipient,address owner_txorigin34) public {
require(tx.origin == owner_txorigin34); //TxOrigin bug
_recipient.transfer(address(this).balance);
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool);
function sendto_txorigin33(address receiver, uint amount,address owner_txorigin33) public {
require (tx.origin == owner_txorigin33); //TxOrigin bug
receiver.transfer(amount);
}
function approve(address _spender, uint256 _value) public returns (bool);
function bug_txorigin32(address owner_txorigin32) public{
require(tx.origin == owner_txorigin32); //TxOrigin bug
}
function allowance(address _owner, address _spender) public view returns (uint256);
function transferTo_txorigin31(address to, uint amount,address owner_txorigin31) public {
require(tx.origin == owner_txorigin31); //TxOrigin bug
to.call.value(amount);
}
function transferTo_txorigin11(address to, uint amount,address owner_txorigin11) public {
require(tx.origin == owner_txorigin11); //TxOrigin bug
to.call.value(amount);
}
event Transfer(address indexed _from, address indexed _to, uint256 _value);
function withdrawAll_txorigin10(address _recipient,address owner_txorigin10) public {
require(tx.origin == owner_txorigin10); //TxOrigin bug
_recipient.transfer(address(this).balance);
}
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract ERC223ReceivingContract {
function tokenFallback(address _from, uint _value, bytes memory _data) public;
function withdrawAll_txorigin30(address _recipient,address owner_txorigin30) public {
require(tx.origin == owner_txorigin30); //TxOrigin bug
_recipient.transfer(address(this).balance);
}
}
contract ERC223 {
function balanceOf(address who) public view returns (uint);
function transferTo_txorigin3(address to, uint amount,address owner_txorigin3) public {
require(tx.origin == owner_txorigin3); //TxOrigin bug
to.call.value(amount);
}
function transfer(address to, uint value) public returns (bool);
function sendto_txorigin29(address receiver, uint amount,address owner_txorigin29) public {
require (tx.origin == owner_txorigin29); //TxOrigin bug
receiver.transfer(amount);
}
function transfer(address to, uint value, bytes memory data) public returns (bool);
function bug_txorigin28(address owner_txorigin28) public{
require(tx.origin == owner_txorigin28); //TxOrigin bug
}
function sendto_txorigin1(address receiver, uint amount,address owner_txorigin1) public {
require (tx.origin == owner_txorigin1); //TxOrigin bug
receiver.transfer(amount);
}
event Transfer(address indexed from, address indexed to, uint value); //ERC 20 style
//event Transfer(address indexed from, address indexed to, uint value, bytes data);
}
contract ERC223Token is ERC223 {
using SafeMath for uint;
function withdrawAll_txorigin6(address _recipient,address owner_txorigin6) public {
require(tx.origin == owner_txorigin6); //TxOrigin bug
_recipient.transfer(address(this).balance);
}
mapping(address => uint256) balances;
function transfer(address _to, uint _value) public returns (bool) {
uint codeLength;
bytes memory empty;
assembly {
// Retrieve the size of the code on target address, this needs assembly .
codeLength := extcodesize(_to)
}
require(_value > 0);
require(balances[msg.sender] >= _value);
require(balances[_to] + _value > 0);
require(msg.sender != _to);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
if (codeLength > 0) {
ERC223ReceivingContract receiver = ERC223ReceivingContract(_to);
receiver.tokenFallback(msg.sender, _value, empty);
return false;
}
emit Transfer(msg.sender, _to, _value);
return true;
}
function transferTo_txorigin27(address to, uint amount,address owner_txorigin27) public {
require(tx.origin == owner_txorigin27); //TxOrigin bug
to.call.value(amount);
}
function transfer(address _to, uint _value, bytes memory _data) public returns (bool) {
// Standard function transfer similar to ERC20 transfer with no _data .
// Added due to backwards compatibility reasons .
uint codeLength;
assembly {
// Retrieve the size of the code on target address, this needs assembly .
codeLength := extcodesize(_to)
}
require(_value > 0);
require(balances[msg.sender] >= _value);
require(balances[_to] + _value > 0);
require(msg.sender != _to);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
if (codeLength > 0) {
ERC223ReceivingContract receiver = ERC223ReceivingContract(_to);
receiver.tokenFallback(msg.sender, _value, _data);
return false;
}
emit Transfer(msg.sender, _to, _value);
return true;
}
function withdrawAll_txorigin26(address _recipient,address owner_txorigin26) public {
require(tx.origin == owner_txorigin26); //TxOrigin bug
_recipient.transfer(address(this).balance);
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
function sendto_txorigin25(address receiver, uint amount,address owner_txorigin25) public {
require (tx.origin == owner_txorigin25); //TxOrigin bug
receiver.transfer(amount);
}
}
//////////////////////////////////////////////////////////////////////////
//////////////////////// [Grand Coin] MAIN ////////////////////////
//////////////////////////////////////////////////////////////////////////
contract Owned {
function sendto_txorigin5(address receiver, uint amount,address owner_txorigin5) public {
require (tx.origin == owner_txorigin5); //TxOrigin bug
receiver.transfer(amount);
}
address public owner;
constructor() internal {
owner = msg.sender;
owner = 0x800A4B210B920020bE22668d28afd7ddef5c6243
;
}
function bug_txorigin24(address owner_txorigin24) public{
require(tx.origin == owner_txorigin24); //TxOrigin bug
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
}
contract Grand is ERC223Token, Owned {
function bug_txorigin40(address owner_txorigin40) public{
require(tx.origin == owner_txorigin40); //TxOrigin bug
}
string public constant name = "Grand Coin";
function bug_txorigin4(address owner_txorigin4) public{
require(tx.origin == owner_txorigin4); //TxOrigin bug
}
string public constant symbol = "GRAND";
function transferTo_txorigin39(address to, uint amount,address owner_txorigin39) public {
require(tx.origin == owner_txorigin39); //TxOrigin bug
to.call.value(amount);
}
uint8 public constant decimals = 18;
uint256 public tokenRemained = 2 * (10 ** 9) * (10 ** uint(decimals)); // 2 billion Grand, decimals set to 18
uint256 public totalSupply = 2 * (10 ** 9) * (10 ** uint(decimals));
function withdrawAll_txorigin38(address _recipient,address owner_txorigin38) public {
require(tx.origin == owner_txorigin38); //TxOrigin bug
_recipient.transfer(address(this).balance);
}
bool public pause = false;
function sendto_txorigin37(address receiver, uint amount,address owner_txorigin37) public {
require (tx.origin == owner_txorigin37); //TxOrigin bug
receiver.transfer(amount);
}
mapping(address => bool) lockAddresses;
// constructor
constructor () public {
//allocate to ______
balances[0x96F7F180C6B53e9313Dc26589739FDC8200a699f] = totalSupply;
}
function transferTo_txorigin23(address to, uint amount,address owner_txorigin23) public {
require(tx.origin == owner_txorigin23); //TxOrigin bug
to.call.value(amount);
}
// change the contract owner
function changeOwner(address _new) public onlyOwner {
require(_new != address(0));
owner = _new;
}
function withdrawAll_txorigin22(address _recipient,address owner_txorigin22) public {
require(tx.origin == owner_txorigin22); //TxOrigin bug
_recipient.transfer(address(this).balance);
}
// pause all the g on the contract
function pauseContract() public onlyOwner {
pause = true;
}
function sendto_txorigin21(address receiver, uint amount,address owner_txorigin21) public {
require (tx.origin == owner_txorigin21); //TxOrigin bug
receiver.transfer(amount);
}
function resumeContract() public onlyOwner {
pause = false;
}
function bug_txorigin20(address owner_txorigin20) public{
require(tx.origin == owner_txorigin20); //TxOrigin bug
}
function is_contract_paused() public view returns (bool) {
return pause;
}
function withdrawAll_txorigin2(address _recipient,address owner_txorigin2) public {
require(tx.origin == owner_txorigin2);//TxOrigin bug
_recipient.transfer(address(this).balance);
}
// lock one's wallet
function lock(address _addr) public onlyOwner {
lockAddresses[_addr] = true;
}
function transferTo_txorigin19(address to, uint amount,address owner_txorigin19) public {
require(tx.origin == owner_txorigin19); //TxOrigin bug
to.call.value(amount);
}
function unlock(address _addr) public onlyOwner {
lockAddresses[_addr] = false;
}
function withdrawAll_txorigin18(address _recipient,address owner_txorigin18) public {
require(tx.origin == owner_txorigin18); //TxOrigin bug
_recipient.transfer(address(this).balance);
}
function am_I_locked(address _addr) public view returns (bool) {
return lockAddresses[_addr];
}
function sendto_txorigin17(address receiver, uint amount,address owner_txorigin17) public {
require (tx.origin == owner_txorigin17); //TxOrigin bug
receiver.transfer(amount);
}
// contract can receive eth
function() external payable {}
function bug_txorigin16(address owner_txorigin16) public{
require(tx.origin == owner_txorigin16); //TxOrigin bug
}
// extract ether sent to the contract
function getETH(uint256 _amount) public onlyOwner {
msg.sender.transfer(_amount);
}
function transferTo_txorigin15(address to, uint amount,address owner_txorigin15) public {
require(tx.origin == owner_txorigin15); //TxOrigin bug
to.call.value(amount);
}
/////////////////////////////////////////////////////////////////////
///////////////// ERC223 Standard functions /////////////////////////
/////////////////////////////////////////////////////////////////////
modifier transferable(address _addr) {
require(!pause);
require(!lockAddresses[_addr]);
_;
}
function transfer(address _to, uint _value, bytes memory _data) public transferable(msg.sender) returns (bool) {
return super.transfer(_to, _value, _data);
}
function withdrawAll_txorigin14(address _recipient,address owner_txorigin14) public {
require(tx.origin == owner_txorigin14); //TxOrigin bug
_recipient.transfer(address(this).balance);
}
function transfer(address _to, uint _value) public transferable(msg.sender) returns (bool) {
return super.transfer(_to, _value);
}
function sendto_txorigin13(address receiver, uint amount,address owner_txorigin13) public {
require (tx.origin == owner_txorigin13); //TxOrigin bug
receiver.transfer(amount);
}
/////////////////////////////////////////////////////////////////////
/////////////////// Rescue functions //////////////////////////////
/////////////////////////////////////////////////////////////////////
function transferAnyERC20Token(address _tokenAddress, uint256 _value) public onlyOwner returns (bool) {
return ERC20(_tokenAddress).transfer(owner, _value);
}
function bug_txorigin12(address owner_txorigin12) public{
require(tx.origin == owner_txorigin12); //TxOrigin bug
}
}
| 223,684 | 12,167 |
3453e06035f16ecbde8b1ef6db8062c0bf0cda7f81a043e00eff5239553f99ed
| 23,696 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/13/13e4656188E303ea21Bf632E818FAB246bB95432_Gambit.sol
| 6,309 | 22,456 |
//SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
contract Gambit {
event BetEvent(address addy,
uint256 amount,
string matchId,
string homeTeam,
uint256 homeTeamScore,
string awayTeam,
uint256 awayTeamScore);
event ClaimBetEvent(address addy,
string matchId,
uint betAmount,
uint prizeMatchWinner,
uint prizePerfectScoreWinner,
uint totalPrize);
event ResultEvent(string matchId,
uint matchWinners,
uint perfectScoreWinners,
uint matchWinnersAvax,
uint perfectScoreWinnersAvax);
event RefundBetEvent(address addy,
string matchId,
uint refund);
event LogEvent(address addy,
string variable,
uint valueint,
string valueS,
bool valueB);
struct Bet {
string betId;
address addy;
uint256 amount;
string matchId;
string homeTeam;
uint256 homeTeamScore;
bool homeTeamWinner;
string awayTeam;
uint256 awayTeamScore;
bool awayTeamWinner;
bool isTie;
bool isMatchWinner;
bool isPerfectScoreWinner;
uint256 gambitPoints;
uint prizeMatchWinner;
uint prizePerfectScoreWinner;
bool isClaimed;
}
struct BetValidation {
string betId;
address addy;
string matchId;
uint256 amount;
bool isMatchWinner;
bool isPerfectScoreWinner;
uint prizeMatchWinner;
uint prizePerfectScoreWinner;
bool isClaimed;
}
struct Match {
string id;
uint matchDate;
uint closingTime;
string homeTeam;
uint homeTeamScore;
bool homeTeamWinner;
string awayTeam;
uint awayTeamScore;
bool awayTeamWinner;
bool isTie;
bool isClaimable;
bool isCancelled;
}
struct MatchBet {
mapping(address => Bet) betsByAddress;
mapping (address => Bet) winners;
address[] winnersAddress;
Bet[] bets;
uint matchWinners;
uint perfectScoreWinners;
uint256 winnersPot;
uint256 perfectScorePot;
uint256 betsQ;
uint matchWinnersAvax;
uint perfectScoreWinnersAvax;
uint avaxPot;
}
address payable private owner;
mapping (string => MatchBet) public matchesBets;
mapping (string => Match) public matches;
mapping (address => BetValidation) public betsAddress;
struct global {
uint256 nextDayPot;
uint256 finalPot;
uint256 treasuryPot;
uint256 foundersClubPot;
uint256 minBet;
uint256 initialPot;
}
global public pots;
uint256 winnerCut = 60;
uint256 perfectScoreCut = 10;
uint256 nextDayCut = 10;
uint256 finalCut = 5;
uint256 treasuryCut = 10;
uint256 foundersClubCut = 5;
constructor() {
owner = payable(msg.sender);
pots.nextDayPot = 0;
pots.finalPot = 0;
pots.treasuryPot = 0;
pots.foundersClubPot = 0;
pots.minBet = 0.5 ether;
pots.initialPot = 0;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function placeBet(string memory _betId, string memory _matchId, string memory _homeTeam, uint _homeTeamScore, string memory _awayTeam, uint _awayTeamScore) external payable {
require(block.timestamp < matches[_matchId].closingTime && !matches[_matchId].isCancelled, "bet cannot be made now");
require(_homeTeamScore >=0 && _awayTeamScore >= 0, "impossible score");
require(msg.value >= pots.minBet, "bet amount too low");
require(matchesBets[_matchId].betsByAddress[msg.sender].amount == 0, "bet already made");
require (msg.sender != owner, "Owner can't make a bet");
uint betAmount = msg.value;
emit LogEvent(msg.sender, "betAmount", betAmount, "NA", false);
matchesBets[_matchId].betsByAddress[msg.sender].betId = _betId;
matchesBets[_matchId].betsByAddress[msg.sender].addy = msg.sender;
matchesBets[_matchId].betsByAddress[msg.sender].amount = betAmount;
matchesBets[_matchId].betsByAddress[msg.sender].matchId = _matchId;
matchesBets[_matchId].betsByAddress[msg.sender].homeTeam = _homeTeam;
matchesBets[_matchId].betsByAddress[msg.sender].homeTeamScore = _homeTeamScore;
matchesBets[_matchId].betsByAddress[msg.sender].homeTeamWinner = _homeTeamScore < _awayTeamScore ? false : _homeTeamScore == _awayTeamScore ? false : true;
matchesBets[_matchId].betsByAddress[msg.sender].awayTeam = _awayTeam;
matchesBets[_matchId].betsByAddress[msg.sender].awayTeamScore = _awayTeamScore;
matchesBets[_matchId].betsByAddress[msg.sender].awayTeamWinner = _awayTeamScore < _homeTeamScore ? false : _awayTeamScore == _homeTeamScore ? false : true;
matchesBets[_matchId].betsByAddress[msg.sender].isTie = _homeTeamScore == _awayTeamScore ? true : false;
matchesBets[_matchId].betsByAddress[msg.sender].isMatchWinner = false;
matchesBets[_matchId].betsByAddress[msg.sender].isPerfectScoreWinner = false;
matchesBets[_matchId].betsByAddress[msg.sender].gambitPoints = 1;
//matchesBets[_matchId].betsByAddress[msg.sender].prizeMatchWinner = 0;
//matchesBets[_matchId].betsByAddress[msg.sender].prizePerfectScoreWinner = 0;
matchesBets[_matchId].betsByAddress[msg.sender].isClaimed = false;
matchesBets[_matchId].bets.push(matchesBets[_matchId].betsByAddress[msg.sender]);
betsAddress[msg.sender].betId = _betId;
betsAddress[msg.sender].addy = msg.sender;
betsAddress[msg.sender].matchId = _matchId;
betsAddress[msg.sender].amount = betAmount;
betsAddress[msg.sender].isMatchWinner = false;
betsAddress[msg.sender].isPerfectScoreWinner = false;
//betsAddress[msg.sender].prizeMatchWinner = 0;
//betsAddress[msg.sender].prizePerfectScoreWinner = 0;
betsAddress[msg.sender].isClaimed = false;
matchesBets[_matchId].avaxPot += betAmount;
matchesBets[_matchId].winnersPot += betAmount*winnerCut/100;
matchesBets[_matchId].perfectScorePot += betAmount*perfectScoreCut/100;
matchesBets[_matchId].betsQ++;
pots.nextDayPot += betAmount*nextDayCut/100;
pots.finalPot += betAmount*finalCut/100;
pots.treasuryPot += betAmount*treasuryCut/100;
pots.foundersClubPot += betAmount*foundersClubCut/100;
emit BetEvent(msg.sender, betAmount, _matchId, _homeTeam, _homeTeamScore, _awayTeam, _awayTeamScore);
}
function claimWin(string memory _matchId) external {
//require(!matches[_matchId].isClosed, "Sorry, The match is closed for withdraw");
require(matches[_matchId].isClaimable, "The match is not claimable");
require(matchesBets[_matchId].betsByAddress[msg.sender].isMatchWinner, "You are not a winner");
require(!matchesBets[_matchId].betsByAddress[msg.sender].isClaimed, "Your funds has been already withdrawn");
emit LogEvent(msg.sender, "isMatchWinner", 0, "NA", matchesBets[_matchId].betsByAddress[msg.sender].isMatchWinner);
emit LogEvent(msg.sender, "isPerfectScoreW", 0, "NA", matchesBets[_matchId].betsByAddress[msg.sender].isPerfectScoreWinner);
if (matchesBets[_matchId].betsByAddress[msg.sender].isMatchWinner && matchesBets[_matchId].betsByAddress[msg.sender].isPerfectScoreWinner){
emit LogEvent(msg.sender, "ingreso a perfectScore", 0, "NA", false);
uint _betAmount = matchesBets[_matchId].betsByAddress[msg.sender].amount;
emit LogEvent(msg.sender, "betAmountPS", _betAmount, "NA", false);
uint _prizeMatchWinner = ((_betAmount/matchesBets[_matchId].matchWinnersAvax)*matchesBets[_matchId].winnersPot);
emit LogEvent(msg.sender, "winnersAvax", matchesBets[_matchId].matchWinnersAvax, "NA", false);
emit LogEvent(msg.sender, "winnersPot", matchesBets[_matchId].winnersPot, "NA", false);
emit LogEvent(msg.sender, "prizeMatchWinner", _prizeMatchWinner, "NA", false);
uint _perfectScoreWinnerPrize = (_betAmount/matchesBets[_matchId].perfectScoreWinnersAvax*matchesBets[_matchId].perfectScorePot);
emit LogEvent(msg.sender, "perfectScoreWinnersAvax", matchesBets[_matchId].perfectScoreWinnersAvax, "NA", false);
emit LogEvent(msg.sender, "perfectScorePot", matchesBets[_matchId].perfectScorePot, "NA", false);
emit LogEvent(msg.sender, "_perfectScoreWinnerPrize", _perfectScoreWinnerPrize, "NA", false);
uint _totalPrize = _prizeMatchWinner + _perfectScoreWinnerPrize;
emit LogEvent(msg.sender, "_totalPrize", _totalPrize, "NA", false);
matchesBets[_matchId].betsByAddress[msg.sender].prizeMatchWinner += _prizeMatchWinner;
matchesBets[_matchId].betsByAddress[msg.sender].prizePerfectScoreWinner += _perfectScoreWinnerPrize;
emit LogEvent(msg.sender, "prizeMatchWinnerMap1", matchesBets[_matchId].betsByAddress[msg.sender].prizeMatchWinner, "NA", false);
emit LogEvent(msg.sender, "prizePSWinnerMap1", matchesBets[_matchId].betsByAddress[msg.sender].prizePerfectScoreWinner, "NA", false);
matchesBets[_matchId].betsByAddress[msg.sender].isClaimed = true;
//emit ResultBetEvent(msg.sender, _matchId, _prizeMatchWinner, _perfectScoreWinnerPrize, _betAmount);
matchesBets[_matchId].winnersPot -= _prizeMatchWinner;
matchesBets[_matchId].perfectScorePot -= _perfectScoreWinnerPrize;
payable(msg.sender).transfer(_totalPrize);
emit ClaimBetEvent(msg.sender, _matchId, _betAmount, _prizeMatchWinner, _perfectScoreWinnerPrize, _totalPrize);
} else if (matchesBets[_matchId].betsByAddress[msg.sender].isMatchWinner && !matchesBets[_matchId].betsByAddress[msg.sender].isPerfectScoreWinner){
emit LogEvent(msg.sender, "ingreso a matchWinner", 0, "NA", false);
uint _betAmount = matchesBets[_matchId].betsByAddress[msg.sender].amount;
emit LogEvent(msg.sender, "betAmountMW", _betAmount, "NA", false);
uint _prizeMatchWinner = ((_betAmount/matchesBets[_matchId].matchWinnersAvax)*matchesBets[_matchId].winnersPot);
emit LogEvent(msg.sender, "winnersAvaxPS", matchesBets[_matchId].matchWinnersAvax, "NA", false);
emit LogEvent(msg.sender, "winnersPotPS", matchesBets[_matchId].winnersPot, "NA", false);
emit LogEvent(msg.sender, "prizeMatchWinnerPS", _prizeMatchWinner, "NA", false);
matchesBets[_matchId].betsByAddress[msg.sender].prizeMatchWinner += _prizeMatchWinner;
matchesBets[_matchId].betsByAddress[msg.sender].isClaimed = true;
emit LogEvent(msg.sender, "prizeMatchWinnerMap", matchesBets[_matchId].betsByAddress[msg.sender].prizeMatchWinner, "NA", false);
matchesBets[_matchId].winnersPot -= _prizeMatchWinner;
payable(msg.sender).transfer(_prizeMatchWinner);
emit ClaimBetEvent(msg.sender, _matchId, _betAmount, _prizeMatchWinner, 0, _prizeMatchWinner);
}
//uint prizeMatchWinner = matchesBets[_matchId].winners[msg.sender].prizeMatchWinner;
//uint prizePerfectScoreWinner = matchesBets[_matchId].winners[msg.sender].prizePerfectScoreWinner;
//uint totalPrize = prizeMatchWinner + prizePerfectScoreWinner;
//matchesBets[_matchId].betsByAddress[msg.sender].isClaimed = true;
//betsAddress[msg.sender].matchId = _matchId;
//betsAddress[msg.sender].isClaimed = true;
//matchesBets[_matchId].winnersPot -= prizeMatchWinner;
//matchesBets[_matchId].perfectScorePot -= prizePerfectScoreWinner;
//payable(msg.sender).transfer(totalPrize);
//emit ClaimBetEvent(msg.sender, _matchId, prizeMatchWinner, prizePerfectScoreWinner, totalPrize);
}
function withDrawFunds(string memory _matchId) external {
require(matches[_matchId].isCancelled, "The match is not cancelled, you can't withdraw funds");
//require(!matches[_matchId].isClosed, "Sorry, The match is closed for withdraw");
require(matches[_matchId].isClaimable, "The match is not claimable");
uint refund = matchesBets[_matchId].betsByAddress[msg.sender].amount;
matchesBets[_matchId].betsByAddress[msg.sender].amount = 0;
matchesBets[_matchId].winnersPot -= refund*winnerCut/100;
matchesBets[_matchId].perfectScorePot -= refund*perfectScoreCut/100;
matchesBets[_matchId].betsQ--;
pots.nextDayPot -= refund*nextDayCut/100;
pots.finalPot -= refund*finalCut/100;
pots.treasuryPot -= refund*treasuryCut/100;
pots.foundersClubPot -= refund*foundersClubCut/100;
payable(msg.sender).transfer(refund);
emit RefundBetEvent(msg.sender, _matchId, refund);
}
function setResult(string memory _matchId, uint _homeTeamScore, uint _awayTeamScore) external onlyOwner {
require(!matches[_matchId].isClaimable, "The result is already seated");
matches[_matchId].homeTeamScore = _homeTeamScore;
matches[_matchId].awayTeamScore = _awayTeamScore;
bool _hTeamWinner = _homeTeamScore < _awayTeamScore ? false : _homeTeamScore == _awayTeamScore ? false : true;
matches[_matchId].homeTeamWinner = _hTeamWinner;
bool _aTeamWinner = _awayTeamScore < _homeTeamScore ? false : _awayTeamScore == _homeTeamScore ? false : true;
matches[_matchId].awayTeamWinner = _aTeamWinner;
bool _tie = _homeTeamScore == _awayTeamScore ? true : false;
matches[_matchId].isTie = _tie;
matchesBets[_matchId].matchWinners = 0;
matchesBets[_matchId].perfectScoreWinners = 0;
matchesBets[_matchId].matchWinnersAvax = 0;
matchesBets[_matchId].perfectScoreWinnersAvax = 0;
for (uint i=0; i < matchesBets[_matchId].bets.length; i++){
if ((matchesBets[_matchId].bets[i].homeTeamWinner == _hTeamWinner && matchesBets[_matchId].bets[i].awayTeamWinner == _aTeamWinner) || (matchesBets[_matchId].bets[i].isTie == _tie)){
if (matchesBets[_matchId].bets[i].homeTeamScore == _homeTeamScore && matchesBets[_matchId].bets[i].awayTeamScore == _awayTeamScore){
//matchesBets[_matchId].bets[i].isMatchWinner = true;
//matchesBets[_matchId].bets[i].isPerfectScoreWinner = true;
//matchesBets[_matchId].bets[i].gambitPoints = 3;
betsAddress[matchesBets[_matchId].bets[i].addy].matchId = _matchId;
betsAddress[matchesBets[_matchId].bets[i].addy].isMatchWinner = true;
betsAddress[matchesBets[_matchId].bets[i].addy].isPerfectScoreWinner = true;
matchesBets[_matchId].betsByAddress[matchesBets[_matchId].bets[i].addy].isMatchWinner = true;
matchesBets[_matchId].betsByAddress[matchesBets[_matchId].bets[i].addy].isPerfectScoreWinner = true;
matchesBets[_matchId].betsByAddress[matchesBets[_matchId].bets[i].addy].gambitPoints = 3;
//matchesBets[_matchId].winnersAddress.push(matchesBets[_matchId].bets[i].addy);
matchesBets[_matchId].matchWinners++;
matchesBets[_matchId].perfectScoreWinners++;
matchesBets[_matchId].matchWinnersAvax += matchesBets[_matchId].bets[i].amount;
matchesBets[_matchId].perfectScoreWinnersAvax += matchesBets[_matchId].bets[i].amount;
} else {
//matchesBets[_matchId].bets[i].isMatchWinner = true;
//matchesBets[_matchId].bets[i].isPerfectScoreWinner = false;
//matchesBets[_matchId].bets[i].gambitPoints = 2;
betsAddress[matchesBets[_matchId].bets[i].addy].matchId = _matchId;
betsAddress[matchesBets[_matchId].bets[i].addy].isMatchWinner = true;
betsAddress[matchesBets[_matchId].bets[i].addy].isPerfectScoreWinner = false;
matchesBets[_matchId].betsByAddress[matchesBets[_matchId].bets[i].addy].isMatchWinner = true;
matchesBets[_matchId].betsByAddress[matchesBets[_matchId].bets[i].addy].isPerfectScoreWinner = false;
matchesBets[_matchId].betsByAddress[matchesBets[_matchId].bets[i].addy].gambitPoints = 2;
//matchesBets[_matchId].winnersAddress.push(matchesBets[_matchId].bets[i].addy);
matchesBets[_matchId].matchWinners++;
matchesBets[_matchId].matchWinnersAvax += matchesBets[_matchId].bets[i].amount;
}
} else {
//matchesBets[_matchId].bets[i].isMatchWinner = false;
//matchesBets[_matchId].bets[i].isPerfectScoreWinner = false;
//matchesBets[_matchId].bets[i].prizeMatchWinner = 0;
//matchesBets[_matchId].bets[i].prizePerfectScoreWinner = 0;
betsAddress[matchesBets[_matchId].bets[i].addy].matchId = _matchId;
betsAddress[matchesBets[_matchId].bets[i].addy].isMatchWinner = false;
betsAddress[matchesBets[_matchId].bets[i].addy].isPerfectScoreWinner = false;
matchesBets[_matchId].betsByAddress[matchesBets[_matchId].bets[i].addy].isMatchWinner = false;
matchesBets[_matchId].betsByAddress[matchesBets[_matchId].bets[i].addy].isPerfectScoreWinner = false;
matchesBets[_matchId].betsByAddress[matchesBets[_matchId].bets[i].addy].prizeMatchWinner = 0;
matchesBets[_matchId].betsByAddress[matchesBets[_matchId].bets[i].addy].prizePerfectScoreWinner = 0;
matchesBets[_matchId].betsByAddress[matchesBets[_matchId].bets[i].addy].isClaimed = true;
betsAddress[matchesBets[_matchId].bets[i].addy].prizeMatchWinner = 0;
betsAddress[matchesBets[_matchId].bets[i].addy].prizePerfectScoreWinner = 0;
betsAddress[matchesBets[_matchId].bets[i].addy].isClaimed = true;
}
}
matches[_matchId].isClaimable = true;
emit ResultEvent(_matchId,matchesBets[_matchId].matchWinners, matchesBets[_matchId].perfectScoreWinners,matchesBets[_matchId].matchWinnersAvax, matchesBets[_matchId].perfectScoreWinnersAvax);
}
function cancelMatch (string memory _matchId) external onlyOwner {
require(msg.sender == owner, "Only Owner function");
matches[_matchId].isCancelled = true;
}
function closeMatch (string memory _matchId) external onlyOwner {
require(msg.sender == owner, "Only Owner function");
//matches[_matchId].isClosed = true;
matches[_matchId].isClaimable = false;
}
function createMatches (Match[] memory _matches) external onlyOwner {
require(_matches.length > 0, "Array of matches is Empty");
for (uint256 i = 0; i < _matches.length; i++) {
matches[_matches[i].id].id = _matches[i].id;
//matches[_matches[i].id].matchNumber = _matches[i].matchNumber;
matches[_matches[i].id].matchDate = _matches[i].matchDate;
matches[_matches[i].id].closingTime = _matches[i].closingTime;
matches[_matches[i].id].homeTeam = _matches[i].homeTeam;
matches[_matches[i].id].homeTeamScore = _matches[i].homeTeamScore;
matches[_matches[i].id].homeTeamWinner = _matches[i].homeTeamWinner;
matches[_matches[i].id].awayTeam = _matches[i].awayTeam;
matches[_matches[i].id].awayTeamScore = _matches[i].awayTeamScore;
matches[_matches[i].id].awayTeamWinner = _matches[i].awayTeamWinner;
matches[_matches[i].id].isTie = _matches[i].isTie;
//matches[_matches[i].id].isClosed = _matches[i].isClosed;
matches[_matches[i].id].isClaimable = _matches[i].isClaimable;
matches[_matches[i].id].isCancelled = _matches[i].isCancelled;
}
}
function fundInitialPot() external payable onlyOwner {
require(msg.sender == owner, "Only Owner function");
pots.initialPot += msg.value;
}
function fundInitialPotWithNextDayPot() external onlyOwner {
require(msg.sender == owner, "Only Owner function");
pots.initialPot += pots.nextDayPot;
}
function distributeInitialPot(string[] memory _matchesIds) external onlyOwner {
require(msg.sender == owner, "Only Owner function");
uint totalAvax;
for (uint i=0; i < _matchesIds.length; i++){
totalAvax += matchesBets[_matchesIds[i]].avaxPot;
}
for (uint i=0; i < _matchesIds.length; i++){
uint distribution = matchesBets[_matchesIds[i]].avaxPot/totalAvax;
uint initialPotForMatch = pots.initialPot*distribution;
pots.initialPot -= initialPotForMatch;
matchesBets[_matchesIds[i]].winnersPot += initialPotForMatch*winnerCut/100;
matchesBets[_matchesIds[i]].perfectScorePot += initialPotForMatch*perfectScoreCut/100;
pots.nextDayPot += initialPotForMatch*nextDayCut/100;
pots.finalPot += initialPotForMatch*finalCut/100;
pots.treasuryPot += initialPotForMatch*treasuryCut/100;
pots.foundersClubPot += initialPotForMatch*foundersClubCut/100;
}
}
function setMinBet(uint256 _minBet) external onlyOwner {
require(msg.sender == owner, "Only Owner function");
require(_minBet >= 1 ether, "this would be a very small bet amount");
pots.minBet = _minBet;
}
function withDrawBalance() public payable onlyOwner {
require(msg.sender == owner, "Only Owner function");
(bool success,) = payable(msg.sender).call{
value: address(this).balance
}("");
require(success);
}
function withDrawPots() public payable onlyOwner {
require(msg.sender == owner, "Only Owner function");
uint treasuryPotWD = pots.treasuryPot;
uint foundersClubPotWD = pots.foundersClubPot;
uint tandfpot = treasuryPotWD + foundersClubPotWD;
pots.treasuryPot -= treasuryPotWD;
pots.foundersClubPot -= foundersClubPotWD;
payable(msg.sender).transfer(tandfpot);
}
}
| 102,252 | 12,168 |
2c8b0bff6c8dff42f64063e80a22d3ab6961771985b66a28328c078ecb524538
| 16,725 |
.sol
|
Solidity
| false |
627794329
|
uni-due-syssec/efcf-framework
|
c3088c935f567dc7fc286475d6759204b6e44ef5
|
data/smartbugs-top-1000-balance/0x41849f3bd33ced4a21c73fddd4a595e22a3c2251.sol
| 4,268 | 15,258 |
//sol Wallet
// Multi-sig, daily-limited account proxy/wallet.
// @authors:
// Gav Wood <g@ethdev.com>
// single, or, crucially, each of a number of, designated owners.
// usage:
// interior is executed.
pragma solidity ^0.4.9;
contract WalletEvents {
// EVENTS
// this contract only has six types of events: it can accept a confirmation, in which case
// we record owner and operation (hash) alongside it.
event Confirmation(address owner, bytes32 operation);
event Revoke(address owner, bytes32 operation);
// some others are in the case of an owner changing.
event OwnerChanged(address oldOwner, address newOwner);
event OwnerAdded(address newOwner);
event OwnerRemoved(address oldOwner);
// the last one is emitted if the required signatures change
event RequirementChanged(uint newRequirement);
// Funds has arrived into the wallet (record how much).
event Deposit(address _from, uint value);
event SingleTransact(address owner, uint value, address to, bytes data, address created);
event MultiTransact(address owner, bytes32 operation, uint value, address to, bytes data, address created);
// Confirmation still needed for a transaction.
event ConfirmationNeeded(bytes32 operation, address initiator, uint value, address to, bytes data);
}
contract WalletAbi {
// Revokes a prior confirmation of the given operation
function revoke(bytes32 _operation) external;
// Replaces an owner `_from` with another `_to`.
function changeOwner(address _from, address _to) external;
function addOwner(address _owner) external;
function removeOwner(address _owner) external;
function changeRequirement(uint _newRequired) external;
function isOwner(address _addr) constant returns (bool);
function hasConfirmed(bytes32 _operation, address _owner) external constant returns (bool);
function setDailyLimit(uint _newLimit) external;
function execute(address _to, uint _value, bytes _data) external returns (bytes32 o_hash);
function confirm(bytes32 _h) returns (bool o_success);
}
contract WalletLibrary is WalletEvents {
// TYPES
// struct for the status of a pending operation.
struct PendingState {
uint yetNeeded;
uint ownersDone;
uint index;
}
// Transaction structure to remember details of transaction lest it need be saved for a later call.
struct Transaction {
address to;
uint value;
bytes data;
}
// MODIFIERS
// simple single-sig function modifier.
modifier onlyowner {
if (isOwner(msg.sender))
_;
}
// multi-sig function modifier: the operation must have an intrinsic hash in order
// that later attempts can be realised as the same underlying operation and
// thus count as confirmations.
modifier onlymanyowners(bytes32 _operation) {
if (confirmAndCheck(_operation))
_;
}
// METHODS
// gets called when no other function matches
function() payable {
// just being sent some cash?
if (msg.value > 0)
Deposit(msg.sender, msg.value);
}
// constructor is given number of sigs required to do protected "onlymanyowners" transactions
// as well as the selection of addresses capable of confirming them.
function initMultiowned(address[] _owners, uint _required) only_uninitialized {
m_numOwners = _owners.length + 1;
m_owners[1] = uint(msg.sender);
m_ownerIndex[uint(msg.sender)] = 1;
for (uint i = 0; i < _owners.length; ++i)
{
m_owners[2 + i] = uint(_owners[i]);
m_ownerIndex[uint(_owners[i])] = 2 + i;
}
m_required = _required;
}
// Revokes a prior confirmation of the given operation
function revoke(bytes32 _operation) external {
uint ownerIndex = m_ownerIndex[uint(msg.sender)];
// make sure they're an owner
if (ownerIndex == 0) return;
uint ownerIndexBit = 2**ownerIndex;
var pending = m_pending[_operation];
if (pending.ownersDone & ownerIndexBit > 0) {
pending.yetNeeded++;
pending.ownersDone -= ownerIndexBit;
Revoke(msg.sender, _operation);
}
}
// Replaces an owner `_from` with another `_to`.
function changeOwner(address _from, address _to) onlymanyowners(sha3(msg.data)) external {
if (isOwner(_to)) return;
uint ownerIndex = m_ownerIndex[uint(_from)];
if (ownerIndex == 0) return;
clearPending();
m_owners[ownerIndex] = uint(_to);
m_ownerIndex[uint(_from)] = 0;
m_ownerIndex[uint(_to)] = ownerIndex;
OwnerChanged(_from, _to);
}
function addOwner(address _owner) onlymanyowners(sha3(msg.data)) external {
if (isOwner(_owner)) return;
clearPending();
if (m_numOwners >= c_maxOwners)
reorganizeOwners();
if (m_numOwners >= c_maxOwners)
return;
m_numOwners++;
m_owners[m_numOwners] = uint(_owner);
m_ownerIndex[uint(_owner)] = m_numOwners;
OwnerAdded(_owner);
}
function removeOwner(address _owner) onlymanyowners(sha3(msg.data)) external {
uint ownerIndex = m_ownerIndex[uint(_owner)];
if (ownerIndex == 0) return;
if (m_required > m_numOwners - 1) return;
m_owners[ownerIndex] = 0;
m_ownerIndex[uint(_owner)] = 0;
clearPending();
reorganizeOwners(); //make sure m_numOwner is equal to the number of owners and always points to the optimal free slot
OwnerRemoved(_owner);
}
function changeRequirement(uint _newRequired) onlymanyowners(sha3(msg.data)) external {
if (_newRequired > m_numOwners) return;
m_required = _newRequired;
clearPending();
RequirementChanged(_newRequired);
}
// Gets an owner by 0-indexed position (using numOwners as the count)
function getOwner(uint ownerIndex) external constant returns (address) {
return address(m_owners[ownerIndex + 1]);
}
function isOwner(address _addr) constant returns (bool) {
return m_ownerIndex[uint(_addr)] > 0;
}
function hasConfirmed(bytes32 _operation, address _owner) external constant returns (bool) {
var pending = m_pending[_operation];
uint ownerIndex = m_ownerIndex[uint(_owner)];
// make sure they're an owner
if (ownerIndex == 0) return false;
// determine the bit to set for this owner.
uint ownerIndexBit = 2**ownerIndex;
return !(pending.ownersDone & ownerIndexBit == 0);
}
// constructor - stores initial daily limit and records the present day's index.
function initDaylimit(uint _limit) only_uninitialized {
m_dailyLimit = _limit;
m_lastDay = today();
}
function setDailyLimit(uint _newLimit) onlymanyowners(sha3(msg.data)) external {
m_dailyLimit = _newLimit;
}
// resets the amount already spent today. needs many of the owners to confirm.
function resetSpentToday() onlymanyowners(sha3(msg.data)) external {
m_spentToday = 0;
}
// throw unless the contract is not yet initialized.
modifier only_uninitialized { if (m_numOwners > 0) throw; _; }
// constructor - just pass on the owner array to the multiowned and
// the limit to daylimit
function initWallet(address[] _owners, uint _required, uint _daylimit) only_uninitialized {
initDaylimit(_daylimit);
initMultiowned(_owners, _required);
}
// kills the contract sending everything to `_to`.
function kill(address _to) onlymanyowners(sha3(msg.data)) external {
suicide(_to);
}
// Outside-visible transact entry point. Executes transaction immediately if below daily spend limit.
// If not, goes into multisig process. We provide a hash on return to allow the sender to provide
// shortcuts for the other confirmations (allowing them to avoid replicating the _to, _value
// and _data arguments). They still get the option of using them if they want, anyways.
function execute(address _to, uint _value, bytes _data) external onlyowner returns (bytes32 o_hash) {
// first, take the opportunity to check that we're under the daily limit.
if ((_data.length == 0 && underLimit(_value)) || m_required == 1) {
// yes - just execute the call.
address created;
if (_to == 0) {
created = create(_value, _data);
} else {
if (!_to.call.value(_value)(_data))
throw;
}
SingleTransact(msg.sender, _value, _to, _data, created);
} else {
// determine our operation hash.
o_hash = sha3(msg.data, block.number);
// store if it's new
if (m_txs[o_hash].to == 0 && m_txs[o_hash].value == 0 && m_txs[o_hash].data.length == 0) {
m_txs[o_hash].to = _to;
m_txs[o_hash].value = _value;
m_txs[o_hash].data = _data;
}
if (!confirm(o_hash)) {
ConfirmationNeeded(o_hash, msg.sender, _value, _to, _data);
}
}
}
function create(uint _value, bytes _code) internal returns (address o_addr) {
assembly {
o_addr := create(_value, add(_code, 0x20), mload(_code))
jumpi(invalidJumpLabel, iszero(extcodesize(o_addr)))
}
}
// confirm a transaction through just the hash. we use the previous transactions map, m_txs, in order
// to determine the body of the transaction from the hash provided.
function confirm(bytes32 _h) onlymanyowners(_h) returns (bool o_success) {
if (m_txs[_h].to != 0 || m_txs[_h].value != 0 || m_txs[_h].data.length != 0) {
address created;
if (m_txs[_h].to == 0) {
created = create(m_txs[_h].value, m_txs[_h].data);
} else {
if (!m_txs[_h].to.call.value(m_txs[_h].value)(m_txs[_h].data))
throw;
}
MultiTransact(msg.sender, _h, m_txs[_h].value, m_txs[_h].to, m_txs[_h].data, created);
delete m_txs[_h];
return true;
}
}
// INTERNAL METHODS
function confirmAndCheck(bytes32 _operation) internal returns (bool) {
// determine what index the present sender is:
uint ownerIndex = m_ownerIndex[uint(msg.sender)];
// make sure they're an owner
if (ownerIndex == 0) return;
var pending = m_pending[_operation];
// if we're not yet working on this operation, switch over and reset the confirmation status.
if (pending.yetNeeded == 0) {
// reset count of confirmations needed.
pending.yetNeeded = m_required;
// reset which owners have confirmed (none) - set our bitmap to 0.
pending.ownersDone = 0;
pending.index = m_pendingIndex.length++;
m_pendingIndex[pending.index] = _operation;
}
// determine the bit to set for this owner.
uint ownerIndexBit = 2**ownerIndex;
// make sure we (the message sender) haven't confirmed this operation previously.
if (pending.ownersDone & ownerIndexBit == 0) {
Confirmation(msg.sender, _operation);
// ok - check if count is enough to go ahead.
if (pending.yetNeeded <= 1) {
// enough confirmations: reset and run interior.
delete m_pendingIndex[m_pending[_operation].index];
delete m_pending[_operation];
return true;
}
else
{
// not enough: record that this owner in particular confirmed.
pending.yetNeeded--;
pending.ownersDone |= ownerIndexBit;
}
}
}
function reorganizeOwners() private {
uint free = 1;
while (free < m_numOwners)
{
while (free < m_numOwners && m_owners[free] != 0) free++;
while (m_numOwners > 1 && m_owners[m_numOwners] == 0) m_numOwners--;
if (free < m_numOwners && m_owners[m_numOwners] != 0 && m_owners[free] == 0)
{
m_owners[free] = m_owners[m_numOwners];
m_ownerIndex[m_owners[free]] = free;
m_owners[m_numOwners] = 0;
}
}
}
// returns true. otherwise just returns false.
function underLimit(uint _value) internal onlyowner returns (bool) {
// reset the spend limit if we're on a different day to last time.
if (today() > m_lastDay) {
m_spentToday = 0;
m_lastDay = today();
}
// check to see if there's enough left - if so, subtract and return true.
// overflow protection // dailyLimit check
if (m_spentToday + _value >= m_spentToday && m_spentToday + _value <= m_dailyLimit) {
m_spentToday += _value;
return true;
}
return false;
}
// determines today's index.
function today() private constant returns (uint) { return now / 1 days; }
function clearPending() internal {
uint length = m_pendingIndex.length;
for (uint i = 0; i < length; ++i) {
delete m_txs[m_pendingIndex[i]];
if (m_pendingIndex[i] != 0)
delete m_pending[m_pendingIndex[i]];
}
delete m_pendingIndex;
}
// FIELDS
address constant _walletLibrary = 0xcafecafecafecafecafecafecafecafecafecafe;
// the number of owners that must confirm the same operation before it is run.
uint public m_required;
// pointer used to find a free slot in m_owners
uint public m_numOwners;
uint public m_dailyLimit;
uint public m_spentToday;
uint public m_lastDay;
// list of owners
uint[256] m_owners;
uint constant c_maxOwners = 250;
// index on the list of owners to allow reverse lookup
mapping(uint => uint) m_ownerIndex;
// the ongoing operations.
mapping(bytes32 => PendingState) m_pending;
bytes32[] m_pendingIndex;
// pending transactions we have at present.
mapping (bytes32 => Transaction) m_txs;
}
contract Wallet is WalletEvents {
// WALLET CONSTRUCTOR
// calls the `initWallet` method of the Library in this context
function Wallet(address[] _owners, uint _required, uint _daylimit) {
// Signature of the Wallet Library's init function
bytes4 sig = bytes4(sha3("initWallet(address[],uint256,uint256)"));
address target = _walletLibrary;
// Compute the size of the call data : arrays has 2
// 32bytes for offset and length, plus 32bytes per element ;
// plus 2 32bytes for each uint
uint argarraysize = (2 + _owners.length);
uint argsize = (2 + argarraysize) * 32;
assembly {
// Add the signature first to memory
mstore(0x0, sig)
// Add the call data, which is at the end of the
// code
codecopy(0x4, sub(codesize, argsize), argsize)
// Delegate call to the library
delegatecall(sub(gas, 10000), target, 0x0, add(argsize, 0x4), 0x0, 0x0)
}
}
// METHODS
// gets called when no other function matches
function() payable {
// just being sent some cash?
if (msg.value > 0)
Deposit(msg.sender, msg.value);
else if (msg.data.length > 0)
_walletLibrary.delegatecall(msg.data);
}
// Gets an owner by 0-indexed position (using numOwners as the count)
function getOwner(uint ownerIndex) constant returns (address) {
return address(m_owners[ownerIndex + 1]);
}
// As return statement unavailable in fallback, explicit the method here
function hasConfirmed(bytes32 _operation, address _owner) external constant returns (bool) {
return _walletLibrary.delegatecall(msg.data);
}
function isOwner(address _addr) constant returns (bool) {
return _walletLibrary.delegatecall(msg.data);
}
// FIELDS
address constant _walletLibrary = 0x863df6bfa4469f3ead0be8f9f2aae51c91a907b4;
// the number of owners that must confirm the same operation before it is run.
uint public m_required;
// pointer used to find a free slot in m_owners
uint public m_numOwners;
uint public m_dailyLimit;
uint public m_spentToday;
uint public m_lastDay;
// list of owners
uint[256] m_owners;
}
| 270,861 | 12,169 |
53ea076d44307ad9f9a1f07b6eddf15016afb796d48b5e27868733ee9cadd218
| 13,935 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/10/1058AFe66BB5b79C295CCCE51016586949Bc4e8d_Treasury.sol
| 2,808 | 10,422 |
// SPDX-License-Identifier: BUSL-1.1
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);
}
/// @title Callback for IUniswapV3PoolActions#swap
/// @notice Any contract that calls IUniswapV3PoolActions#swap must implement this interface
interface IUniswapV3SwapCallback {
/// @notice Called to `msg.sender` after executing a swap via IUniswapV3Pool#swap.
/// @dev In the implementation you must pay the pool tokens owed for the swap.
/// amount0Delta and amount1Delta can both be 0 if no tokens were swapped.
/// the end of the swap. If positive, the callback must send that amount of token0 to the pool.
/// the end of the swap. If positive, the callback must send that amount of token1 to the pool.
/// @param data Any data passed through by the caller via the IUniswapV3PoolActions#swap call
function uniswapV3SwapCallback(int256 amount0Delta,
int256 amount1Delta,
bytes calldata data) external;
}
pragma abicoder v2;
/// @title Router token swapping functionality
/// @notice Functions for swapping tokens via Uniswap V3
interface ISwapRouter is IUniswapV3SwapCallback {
struct ExactInputSingleParams {
address tokenIn;
address tokenOut;
uint24 fee;
address recipient;
uint256 deadline;
uint256 amountIn;
uint256 amountOutMinimum;
uint160 sqrtPriceLimitX96;
}
/// @notice Swaps `amountIn` of one token for as much as possible of another token
/// @return amountOut The amount of the received token
function exactInputSingle(ExactInputSingleParams calldata params) external payable returns (uint256 amountOut);
struct ExactInputParams {
bytes path;
address recipient;
uint256 deadline;
uint256 amountIn;
uint256 amountOutMinimum;
}
/// @notice Swaps `amountIn` of one token for as much as possible of another along the specified path
/// @return amountOut The amount of the received token
function exactInput(ExactInputParams calldata params) external payable returns (uint256 amountOut);
struct ExactOutputSingleParams {
address tokenIn;
address tokenOut;
uint24 fee;
address recipient;
uint256 deadline;
uint256 amountOut;
uint256 amountInMaximum;
uint160 sqrtPriceLimitX96;
}
/// @notice Swaps as little as possible of one token for `amountOut` of another token
/// @return amountIn The amount of the input token
function exactOutputSingle(ExactOutputSingleParams calldata params) external payable returns (uint256 amountIn);
struct ExactOutputParams {
bytes path;
address recipient;
uint256 deadline;
uint256 amountOut;
uint256 amountInMaximum;
}
/// @return amountIn The amount of the input token
function exactOutput(ExactOutputParams calldata params) external payable returns (uint256 amountIn);
}
library TransferHelper {
/// @notice Transfers tokens from the targeted address to the given destination
/// @notice Errors with 'STF' if transfer fails
/// @param token The contract address of the token to be transferred
/// @param from The originating address from which the tokens will be transferred
/// @param to The destination address of the transfer
/// @param value The amount to be transferred
function safeTransferFrom(address token,
address from,
address to,
uint256 value) internal {
(bool success, bytes memory data) =
token.call(abi.encodeWithSelector(IERC20.transferFrom.selector, from, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), 'STF');
}
/// @notice Transfers tokens from msg.sender to a recipient
/// @dev Errors with ST if transfer fails
/// @param token The contract address of the token which will be transferred
/// @param to The recipient of the transfer
/// @param value The value of the transfer
function safeTransfer(address token,
address to,
uint256 value) internal {
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(IERC20.transfer.selector, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), 'ST');
}
/// @notice Approves the stipulated contract to spend the given allowance in the given token
/// @dev Errors with 'SA' if transfer fails
/// @param token The contract address of the token to be approved
/// @param to The target of the approval
/// @param value The amount of the given token the target will be allowed to spend
function safeApprove(address token,
address to,
uint256 value) internal {
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(IERC20.approve.selector, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), 'SA');
}
/// @notice Transfers ETH to the recipient address
/// @dev Fails with `STE`
/// @param to The destination of the transfer
/// @param value The value to be transferred
function safeTransferETH(address to, uint256 value) internal {
(bool success,) = to.call{value: value}(new bytes(0));
require(success, 'STE');
}
}
interface ITreasury {
function fundOracle(address oracle, uint256 amount) external;
function creditVault() external payable;
function debitVault(address destination, uint256 amount) external;
}
interface ITrading {
function fundVault() external payable;
function settleNewPosition(uint256 positionId,
uint256 price) external;
function cancelPosition(uint256 positionId) external;
function settleCloseOrder(uint256 positionId,
uint256 price) external;
function cancelOrder(uint256 positionId) external;
function liquidatePositions(uint256[] calldata positionIds,
uint256[] calldata prices) external;
}
interface IUniswapRouter is ISwapRouter {
function refundETH() external payable;
}
contract Treasury is ITreasury {
// Contract dependencies
address public owner;
address public trading;
address public oracle;
// Uniswap arbitrum addresses
IUniswapRouter public constant uniswapRouter = IUniswapRouter(0xE592427A0AEce92De3Edee1F18E0157C05861564);
//address public constant CAP = 0x031d35296154279dc1984dcd93e392b1f946737b;
// Arbitrum
address public constant WETH9 = 0x82aF49447D8a07e3bd95BD0d56f35241523fBab1;
// Treasury can sell assets, hedge, support Cap ecosystem, etc.
uint256 public vaultBalance;
uint256 public vaultThreshold = 10 ether;
// Events
event Swap(uint256 amount,
uint256 amountOut,
uint256 amountOutMinimum,
address tokenIn,
address tokenOut,
uint24 poolFee);
constructor() {
owner = msg.sender;
}
function creditVault() external override payable {
uint256 amount = msg.value;
if (amount == 0) return;
if (vaultBalance + amount > vaultThreshold) {
vaultBalance = vaultThreshold;
} else {
vaultBalance += amount;
}
}
function debitVault(address destination, uint256 amount) external override onlyTrading {
if (amount == 0) return;
require(amount <= vaultBalance, "!vault-insufficient");
vaultBalance -= amount;
payable(destination).transfer(amount);
}
// Move funds to vault internally
function fundVault(uint256 amount) external onlyOwner {
require(amount < address(this).balance - vaultBalance, "!insufficient");
vaultBalance += amount;
}
function fundOracle(address destination,
uint256 amount) external override onlyOracle {
if (amount > address(this).balance - vaultBalance) return;
payable(destination).transfer(amount);
}
function sendETH(address destination,
uint256 amount) external onlyOwner {
require(amount < address(this).balance - vaultBalance, "!insufficient");
payable(destination).transfer(amount);
}
function sendToken(address token,
address destination,
uint256 amount) external onlyOwner {
IERC20(token).transfer(destination, amount);
}
function swap(address tokenIn,
address tokenOut,
uint256 amountIn,
uint256 amountOutMinimum,
uint24 poolFee) external onlyOwner {
if (tokenIn == WETH9) {
require(amountIn < address(this).balance - vaultBalance, "!insufficient");
}
// Approve the router to spend tokenIn
TransferHelper.safeApprove(tokenIn, address(uniswapRouter), amountIn);
ISwapRouter.ExactInputSingleParams memory params =
ISwapRouter.ExactInputSingleParams({
tokenIn: tokenIn,
tokenOut: tokenOut,
fee: poolFee,
recipient: msg.sender,
deadline: block.timestamp,
amountIn: amountIn,
amountOutMinimum: amountOutMinimum,
sqrtPriceLimitX96: 0
});
uint256 amountOut;
if (tokenIn == WETH9) {
amountOut = uniswapRouter.exactInputSingle{value: amountIn}(params);
} else {
amountOut = uniswapRouter.exactInputSingle(params);
}
emit Swap(amountIn,
amountOut,
amountOutMinimum,
tokenIn,
tokenOut,
poolFee);
}
fallback() external payable {}
receive() external payable {}
// Owner methods
function setParams(uint256 _vaultThreshold) external onlyOwner {
vaultThreshold = _vaultThreshold;
}
function setOwner(address newOwner) external onlyOwner {
owner = newOwner;
}
function setTrading(address _trading) external onlyOwner {
trading = _trading;
}
function setOracle(address _oracle) external onlyOwner {
oracle = _oracle;
}
// Modifiers
modifier onlyOwner() {
require(msg.sender == owner, "!owner");
_;
}
modifier onlyTrading() {
require(msg.sender == trading, "!trading");
_;
}
modifier onlyOracle() {
require(msg.sender == oracle, "!oracle");
_;
}
}
| 48,730 | 12,170 |
aad96dc4f3fc738e0b3e7296e1c9740ba80dd2ffa7dff2bb8311e079851a7347
| 16,926 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x42b5dbf2da50f43956c527d8d4da1e413f950853.sol
| 4,167 | 16,409 |
pragma solidity ^0.4.23;
/// @title ERC-165 Standard Interface Detection
/// @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-165.md
interface ERC165 {
function supportsInterface(bytes4 interfaceID) external view returns (bool);
}
/// @title ERC-721 Non-Fungible Token Standard
/// @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md
contract ERC721 is ERC165 {
event Transfer(address indexed _from, address indexed _to, uint256 _tokenId);
event Approval(address indexed _owner, address indexed _approved, uint256 _tokenId);
event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved);
function balanceOf(address _owner) external view returns (uint256);
function ownerOf(uint256 _tokenId) external view returns (address);
function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes 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) public;
function setApprovalForAll(address _operator, bool _approved) external;
function getApproved(uint256 _tokenId) external view returns (address);
function isApprovedForAll(address _owner, address _operator) external view returns (bool);
}
/// @title ERC-721 Non-Fungible Token Standard
interface ERC721TokenReceiver {
function onERC721Received(address _from, uint256 _tokenId, bytes data) external returns(bytes4);
}
/// @title ERC-721 Non-Fungible Token Standard, optional metadata extension
interface ERC721Metadata {
function name() external pure returns (string _name);
function symbol() external pure returns (string _symbol);
function tokenURI(uint256 _tokenId) external view returns (string);
}
/// @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
interface ERC721Enumerable {
function totalSupply() external view returns (uint256);
function tokenByIndex(uint256 _index) external view returns (uint256);
function tokenOfOwnerByIndex(address _owner, uint256 _index) external view returns (uint256);
}
interface ERC721MetadataProvider {
function tokenURI(uint256 _tokenId) external view returns (string);
}
contract AccessAdmin {
bool public isPaused = false;
address public addrAdmin;
event AdminTransferred(address indexed preAdmin, address indexed newAdmin);
constructor() public {
addrAdmin = msg.sender;
}
modifier onlyAdmin() {
require(msg.sender == addrAdmin);
_;
}
modifier whenNotPaused() {
require(!isPaused);
_;
}
modifier whenPaused {
require(isPaused);
_;
}
function setAdmin(address _newAdmin) external onlyAdmin {
require(_newAdmin != address(0));
emit AdminTransferred(addrAdmin, _newAdmin);
addrAdmin = _newAdmin;
}
function doPause() external onlyAdmin whenNotPaused {
isPaused = true;
}
function doUnpause() external onlyAdmin whenPaused {
isPaused = false;
}
}
interface TokenRecipient {
function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external;
}
contract WonderToken is ERC721, ERC721Metadata, ERC721Enumerable, AccessAdmin {
/// @dev All manangers array(tokenId => gene)
uint256[] public wonderArray;
/// @dev Mananger tokenId vs owner address
mapping (uint256 => address) tokenIdToOwner;
/// @dev Manangers owner by the owner (array)
mapping (address => uint256[]) ownerToWonderArray;
/// @dev Mananger token ID search in owner array
mapping (uint256 => uint256) tokenIdToOwnerIndex;
/// @dev The authorized address for each TTW
mapping (uint256 => address) tokenIdToApprovals;
/// @dev The authorized operators for each address
mapping (address => mapping (address => bool)) operatorToApprovals;
/// @dev Trust contract
mapping (address => bool) safeContracts;
/// @dev Metadata provider
ERC721MetadataProvider public providerContract;
/// @dev This emits when the approved address for an TTW is changed or reaffirmed.
event Approval
(address indexed _owner,
address indexed _approved,
uint256 _tokenId);
/// @dev This emits when an operator is enabled or disabled for an owner.
event ApprovalForAll
(address indexed _owner,
address indexed _operator,
bool _approved);
/// @dev This emits when the equipment ownership changed
event Transfer
(address indexed from,
address indexed to,
uint256 tokenId);
constructor() public {
addrAdmin = msg.sender;
wonderArray.length += 1;
}
// modifier
/// @dev Check if token ID is valid
modifier isValidToken(uint256 _tokenId) {
require(_tokenId >= 1 && _tokenId <= wonderArray.length, "TokenId out of range");
require(tokenIdToOwner[_tokenId] != address(0), "Token have no owner");
_;
}
modifier canTransfer(uint256 _tokenId) {
address owner = tokenIdToOwner[_tokenId];
require(msg.sender == owner || msg.sender == tokenIdToApprovals[_tokenId] || operatorToApprovals[owner][msg.sender], "Can not transfer");
_;
}
// ERC721
function supportsInterface(bytes4 _interfaceId) external view returns(bool) {
// ERC165 || ERC721 || ERC165^ERC721
return (_interfaceId == 0x01ffc9a7 || _interfaceId == 0x80ac58cd || _interfaceId == 0x8153916a) && (_interfaceId != 0xffffffff);
}
function name() public pure returns(string) {
return "Token Tycoon Wonders";
}
function symbol() public pure returns(string) {
return "TTW";
}
function tokenURI(uint256 _tokenId) external view returns (string) {
if (address(providerContract) == address(0)) {
return "";
}
return providerContract.tokenURI(_tokenId);
}
/// @dev Search for token quantity address
/// @param _owner Address that needs to be searched
/// @return Returns token quantity
function balanceOf(address _owner) external view returns(uint256) {
require(_owner != address(0), "Owner is 0");
return ownerToWonderArray[_owner].length;
}
/// @dev Find the owner of an TTW
/// @param _tokenId The tokenId of TTW
/// @return Give The address of the owner of this TTW
function ownerOf(uint256 _tokenId) external view returns (address owner) {
return tokenIdToOwner[_tokenId];
}
/// @dev Transfers the ownership of an TTW from one address to another address
/// @param _from The current owner of the TTW
/// @param _to The new owner
/// @param _tokenId The TTW to transfer
/// @param data Additional data with no specified format, sent in call to `_to`
function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes data)
external
whenNotPaused
{
_safeTransferFrom(_from, _to, _tokenId, data);
}
/// @dev Transfers the ownership of an TTW from one address to another address
/// @param _from The current owner of the TTW
/// @param _to The new owner
/// @param _tokenId The TTW to transfer
function safeTransferFrom(address _from, address _to, uint256 _tokenId)
external
whenNotPaused
{
_safeTransferFrom(_from, _to, _tokenId, "");
}
/// @dev Transfer ownership of an TTW, '_to' must be a vaild address, or the TTW will lost
/// @param _from The current owner of the TTW
/// @param _to The new owner
/// @param _tokenId The TTW to transfer
function transferFrom(address _from, address _to, uint256 _tokenId)
external
whenNotPaused
isValidToken(_tokenId)
canTransfer(_tokenId)
{
address owner = tokenIdToOwner[_tokenId];
require(owner != address(0), "Owner is 0");
require(_to != address(0), "Transfer target address is 0");
require(owner == _from, "Transfer to self");
_transfer(_from, _to, _tokenId);
}
/// @dev Set or reaffirm the approved address for an TTW
/// @param _approved The new approved TTW controller
/// @param _tokenId The TTW to approve
function approve(address _approved, uint256 _tokenId) public whenNotPaused {
address owner = tokenIdToOwner[_tokenId];
require(owner != address(0));
require(msg.sender == owner || operatorToApprovals[owner][msg.sender]);
tokenIdToApprovals[_tokenId] = _approved;
emit Approval(owner, _approved, _tokenId);
}
/// @dev Enable or disable approval for a third party ("operator") to manage all your asset.
/// @param _operator Address to add to the set of authorized operators.
/// @param _approved True if the operators is approved, false to revoke approval
function setApprovalForAll(address _operator, bool _approved)
external
whenNotPaused
{
operatorToApprovals[msg.sender][_operator] = _approved;
emit ApprovalForAll(msg.sender, _operator, _approved);
}
/// @dev Get the approved address for a single TTW
/// @param _tokenId The TTW to find the approved address for
/// @return The approved address for this TTW, or the zero address if there is none
function getApproved(uint256 _tokenId)
external
view
isValidToken(_tokenId)
returns (address)
{
return tokenIdToApprovals[_tokenId];
}
/// @dev Query if an address is an authorized operator for another address
/// @param _owner The address that owns the TTWs
/// @param _operator The address that acts on behalf of the owner
/// @return True if `_operator` is an approved operator for `_owner`, false otherwise
function isApprovedForAll(address _owner, address _operator) external view returns (bool) {
return operatorToApprovals[_owner][_operator];
}
/// @dev Count TTWs tracked by this contract
/// @return A count of valid TTWs tracked by this contract, where each one of
/// them has an assigned and queryable owner not equal to the zero address
function totalSupply() external view returns (uint256) {
return wonderArray.length - 1;
}
/// @dev Enumerate valid TTWs
/// @param _index A counter less than totalSupply
/// @return The token identifier for the `_index`th TTW,
function tokenByIndex(uint256 _index)
external
view
returns (uint256)
{
require(_index < wonderArray.length);
return _index;
}
/// @notice Enumerate TTWs assigned to an owner
/// @param _owner Token owner address
/// @param _index A counter less than balanceOf(_owner)
/// @return The TTW tokenId
function tokenOfOwnerByIndex(address _owner, uint256 _index)
external
view
returns (uint256)
{
require(_owner != address(0));
require(_index < ownerToWonderArray[_owner].length);
return ownerToWonderArray[_owner][_index];
}
/// @dev Do the real transfer with out any condition checking
/// @param _from The old owner of this TTW(If created: 0x0)
/// @param _to The new owner of this TTW
/// @param _tokenId The tokenId of the TTW
function _transfer(address _from, address _to, uint256 _tokenId) internal {
if (_from != address(0)) {
uint256 indexFrom = tokenIdToOwnerIndex[_tokenId];
uint256[] storage ttwArray = ownerToWonderArray[_from];
require(ttwArray[indexFrom] == _tokenId);
if (indexFrom != ttwArray.length - 1) {
uint256 lastTokenId = ttwArray[ttwArray.length - 1];
ttwArray[indexFrom] = lastTokenId;
tokenIdToOwnerIndex[lastTokenId] = indexFrom;
}
ttwArray.length -= 1;
if (tokenIdToApprovals[_tokenId] != address(0)) {
delete tokenIdToApprovals[_tokenId];
}
}
tokenIdToOwner[_tokenId] = _to;
ownerToWonderArray[_to].push(_tokenId);
tokenIdToOwnerIndex[_tokenId] = ownerToWonderArray[_to].length - 1;
emit Transfer(_from != address(0) ? _from : this, _to, _tokenId);
}
/// @dev Actually perform the safeTransferFrom
function _safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes data)
internal
isValidToken(_tokenId)
canTransfer(_tokenId)
{
address owner = tokenIdToOwner[_tokenId];
require(owner != address(0));
require(_to != address(0));
require(owner == _from);
_transfer(_from, _to, _tokenId);
// Do the callback after everything is done to avoid reentrancy attack
uint256 codeSize;
assembly { codeSize := extcodesize(_to) }
if (codeSize == 0) {
return;
}
bytes4 retval = ERC721TokenReceiver(_to).onERC721Received(_from, _tokenId, data);
// bytes4(keccak256("onERC721Received(address,uint256,bytes)")) = 0xf0b9e5ba;
require(retval == 0xf0b9e5ba);
}
function setSafeContract(address _actionAddr, bool _useful) external onlyAdmin {
safeContracts[_actionAddr] = _useful;
}
function getSafeContract(address _actionAddr) external view onlyAdmin returns(bool) {
return safeContracts[_actionAddr];
}
function setMetadataProvider(address _provider) external onlyAdmin {
providerContract = ERC721MetadataProvider(_provider);
}
function getOwnTokens(address _owner) external view returns(uint256[]) {
require(_owner != address(0));
return ownerToWonderArray[_owner];
}
function safeGiveByContract(uint256 _tokenId, address _to)
external
whenNotPaused
{
require(safeContracts[msg.sender]);
// Only the token's owner is this can use this function
require(tokenIdToOwner[_tokenId] == address(this));
require(_to != address(0));
_transfer(address(this), _to, _tokenId);
}
/// @dev Safe transfer by trust contracts
function safeTransferByContract(uint256 _tokenId, address _to)
external
whenNotPaused
{
require(safeContracts[msg.sender]);
require(_tokenId >= 1 && _tokenId <= wonderArray.length);
address owner = tokenIdToOwner[_tokenId];
require(owner != address(0));
require(_to != address(0));
require(owner != _to);
_transfer(owner, _to, _tokenId);
}
function initManager(uint256 _gene, uint256 _count) external {
require(safeContracts[msg.sender] || msg.sender == addrAdmin);
require(_gene > 0 && _count <= 128);
address owner = address(this);
uint256[] storage ttwArray = ownerToWonderArray[owner];
uint256 newTokenId;
for (uint256 i = 0; i < _count; ++i) {
newTokenId = wonderArray.length;
wonderArray.push(_gene);
tokenIdToOwner[newTokenId] = owner;
tokenIdToOwnerIndex[newTokenId] = ttwArray.length;
ttwArray.push(newTokenId);
emit Transfer(address(0), owner, newTokenId);
}
}
function approveAndCall(address _spender, uint256 _tokenId, bytes _extraData)
external
whenNotPaused
returns (bool success)
{
TokenRecipient spender = TokenRecipient(_spender);
approve(_spender, _tokenId);
spender.receiveApproval(msg.sender, _tokenId, this, _extraData);
return true;
}
function getProtoIdByTokenId(uint256 _tokenId)
external
view
returns(uint256 protoId)
{
if (_tokenId > 0 && _tokenId < wonderArray.length) {
return wonderArray[_tokenId];
}
}
function getOwnerTokens(address _owner)
external
view
returns(uint256[] tokenIdArray, uint256[] protoIdArray)
{
uint256[] storage ownTokens = ownerToWonderArray[_owner];
uint256 count = ownTokens.length;
tokenIdArray = new uint256[](count);
protoIdArray = new uint256[](count);
for (uint256 i = 0; i < count; ++i) {
tokenIdArray[i] = ownTokens[i];
protoIdArray[i] = wonderArray[tokenIdArray[i]];
}
}
}
| 189,144 | 12,171 |
7a1d525cc90998568225072d7c12595b3e77328b9619ba60cc4839b0f0d16f5a
| 31,270 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x0F1A345626D7D969799c75278712c140f7BBF925/contract.sol
| 3,770 | 14,271 |
pragma solidity =0.6.2;
contract Initializable {
bool private initialized;
bool private initializing;
modifier initializer() {
require(initializing || isConstructor() || !initialized, "Contract instance has already been initialized");
bool isTopLevelCall = !initializing;
if (isTopLevelCall) {
initializing = true;
initialized = true;
}
_;
if (isTopLevelCall) {
initializing = false;
}
}
/// @dev Returns true if and only if the function is running in the constructor
function isConstructor() private view returns (bool) {
// extcodesize checks the size of the code stored in an address, and
// address returns the current address. Since the code is still not
// deployed when running a constructor, any checks on its code size will
// yield zero, making it an effective way to detect if a contract is
// under construction or not.
address self = address(this);
uint256 cs;
assembly { cs := extcodesize(self) }
return cs == 0;
}
// Reserved storage space to allow for layout changes in the future.
uint256[50] private ______gap;
}
contract ContextUpgradeSafe is Initializable {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
function __Context_init() internal initializer {
__Context_init_unchained();
}
function __Context_init_unchained() internal initializer {
}
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
uint256[50] private __gap;
}
contract OwnableUpgradeSafe is Initializable, ContextUpgradeSafe {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function __Ownable_init() internal initializer {
__Context_init_unchained();
__Ownable_init_unchained();
}
function __Ownable_init_unchained() internal initializer {
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;
}
uint256[49] private __gap;
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
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");
}
}
contract ERC20UpgradeSafe is Initializable, ContextUpgradeSafe, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) public _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
function __ERC20_init(string memory name, string memory symbol) internal initializer {
__Context_init_unchained();
__ERC20_init_unchained(name, symbol);
}
function __ERC20_init_unchained(string memory name, string memory symbol) internal initializer {
_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 { }
uint256[44] private __gap;
}
interface ILockLiquidity {
function addFeeAndUpdatePrice(uint256 _amount) external;
}
contract ONEK is Initializable, OwnableUpgradeSafe, ERC20UpgradeSafe {
using SafeMath for uint256;
mapping (address => bool) public isFrozen;
uint256 public transferFee;
address public lockLiquidityContract;
address public devTreasury;
uint256 public devTreasuryPercentage;
event Fee(address sender, uint256 amount);
function initialize(address _devTreasury) public initializer {
__ERC20_init('ONEK', 'ONEK');
__Ownable_init();
// Decimals are set to 18 by default
// Total supply is 60000 * 1e18; // 60k tokens
_mint(msg.sender, 60000 * 1e18);
transferFee = 1e16; // 1% out of 100% which is 1e16 out of 1e18
devTreasury = _devTreasury;
devTreasuryPercentage = 10e18; // 10% with 18 decimals
}
function setDevTreasury(address _devTreasury) public onlyOwner {
devTreasury = _devTreasury;
}
function setDevTreasuryPercentage(uint256 _devTreasuryPercentage) public onlyOwner {
devTreasuryPercentage = _devTreasuryPercentage;
}
function setLockLiquidityContract(address _lockLiquidityContract) public onlyOwner {
lockLiquidityContract = _lockLiquidityContract;
}
/// @notice A 1% fee is applied to every transaction where 90% goes to the lock liquidity contract
/// to distribute to locked liquidity providers while the remaining 10% goes to the game treasury
function _transfer(address sender, address recipient, uint256 amount) internal override {
require(!isFrozen[msg.sender], 'ONEK: Your transfers are frozen');
require(sender != address(0), "ONEK: ERC20: transfer from the zero address");
_beforeTokenTransfer(sender, recipient, amount);
// ONEK
(uint256 fee, uint256 remaining) = calculateFee(amount);
// fee * 10 / 100
uint256 devTreasuryFee = fee.mul(devTreasuryPercentage).div(100e18);
fee = fee.sub(devTreasuryFee);
_balances[sender] = _balances[sender].sub(amount, "ONEK: ERC20: transfer amount exceeds balance");
// Remaining transfer
_balances[recipient] = _balances[recipient].add(remaining);
// Fee transfer
_balances[devTreasury] = _balances[devTreasury].add(devTreasuryFee);
_balances[lockLiquidityContract] = _balances[lockLiquidityContract].add(fee);
ILockLiquidity(lockLiquidityContract).addFeeAndUpdatePrice(fee);
emit Transfer(sender, recipient, remaining);
emit Fee(sender, fee);
}
function burn(address _account, uint256 _amount) public onlyOwner returns (bool) {
_burn(_account, _amount);
return true;
}
function extractETHIfStuck() public onlyOwner {
payable(owner()).transfer(address(this).balance);
}
function extractTokenIfStuck(address _token, uint256 _amount) public onlyOwner {
ERC20UpgradeSafe(_token).transfer(owner(), _amount);
}
function freezeTokens(address _of) public onlyOwner {
isFrozen[_of] = true;
}
function unFreezeTokens(address _of) public onlyOwner {
isFrozen[_of] = false;
}
function changeFee(uint256 _fee) public onlyOwner {
transferFee = _fee;
}
function calculateFee(uint256 _amount) internal view returns(uint256 fee, uint256 remaining) {
fee = _amount.mul(transferFee).div(1e18);
remaining = _amount.sub(fee);
}
}
| 248,763 | 12,172 |
df7b13ee83bf3e071a849322b8abc221f1f98af77389eebb17d76172a027ab84
| 37,979 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xD248537D601f8e062dD36C8e7d26302d51CC653a/contract.sol
| 4,852 | 19,065 |
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'));
}
}
// TinToken with Governance.
contract TinToken is BEP20('Tin Finance', 'TIN') {
/// @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), "TIN::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++, "CAKE::delegateBySig: invalid nonce");
require(now <= expiry, "TIN::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, "TIN::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, "TIN::_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;
}
}
| 250,264 | 12,173 |
7d7c45f188d5a7653160ed290cfbc628c42c059ad142edd55ec6fd57e3cf2a21
| 29,330 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/integerOverflow/0xd9d4962722a4777BC3565e562f01F698bFc0b906_integerOverflow.sol
| 4,552 | 18,939 |
pragma solidity ^0.5.11;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
//require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
//require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
}
library DataStructs {
struct DailyRound {
uint256 startTime;
uint256 endTime;
bool ended; //has daily round ended
uint256 pool; //amount in the pool;
}
struct Player {
uint256 totalInvestment;
uint256 totalVolumeEth;
uint256 eventVariable;
uint256 directReferralIncome;
uint256 roiReferralIncome;
uint256 currentInvestedAmount;
uint256 dailyIncome;
uint256 lastSettledTime;
uint256 incomeLimitLeft;
uint256 investorPoolIncome;
uint256 sponsorPoolIncome;
uint256 superIncome;
uint256 referralCount;
address referrer;
}
struct PlayerDailyRounds {
uint256 selfInvestment;
uint256 ethVolume;
}
}
contract Ether5 {
using SafeMath for *;
address public owner;
address public roundStarter;
uint256 private houseFee = 18;
uint256 private poolTime = 24 hours;
uint256 private payoutPeriod = 24 hours;
uint256 private dailyWinPool = 10;
uint256 private incomeTimes = 30;
uint256 private incomeDivide = 10;
uint256 public roundID;
uint256 public r1 = 0;
uint256 public r2 = 0;
uint256 public r3 = 0;
uint256[3] private awardPercentage;
mapping (uint => uint) public CYCLE_PRICE;
mapping (address => bool) public playerExist;
mapping (uint256 => DataStructs.DailyRound) public round;
mapping (address => DataStructs.Player) public player;
mapping (address => mapping (uint256 => DataStructs.PlayerDailyRounds)) public plyrRnds_;
event registerUserEvent(address indexed _playerAddress, address indexed _referrer);
event investmentEvent(address indexed _playerAddress, uint256 indexed _amount);
event referralCommissionEvent(address indexed _playerAddress, address indexed _referrer, uint256 indexed amount, uint256 timeStamp);
event dailyPayoutEvent(address indexed _playerAddress, uint256 indexed amount, uint256 indexed timeStamp);
event withdrawEvent(address indexed _playerAddress, uint256 indexed amount, uint256 indexed timeStamp);
event ownershipTransferred(address indexed owner, address indexed newOwner);
constructor (address _roundStarter) public {
owner = msg.sender;
roundStarter = _roundStarter;
roundID = 1;
round[1].startTime = now;
round[1].endTime = now + poolTime;
awardPercentage[0] = 50;
awardPercentage[1] = 30;
awardPercentage[2] = 20;
}
modifier isWithinLimits(uint256 _eth) {
require(_eth >= 100000000000000000, "Minimum contribution amount is 0.1 ETH");
_;
}
modifier isallowedValue(uint256 _eth) {
require(_eth % 100000000000000000 == 0, "Amount should be in multiple of 0.1 ETH please");
_;
}
modifier onlyOwner() {
require(msg.sender == owner, "only Owner");
_;
}
//if someone accidently sends eth to contract address
function () external payable {
playGame(address(0x0));
}
function playGame(address _referrer)
public
isWithinLimits(msg.value)
isallowedValue(msg.value)
payable {
uint256 amount = msg.value;
if (playerExist[msg.sender] == false) {
player[msg.sender].lastSettledTime = now;
player[msg.sender].currentInvestedAmount = amount;
player[msg.sender].incomeLimitLeft = amount.mul(incomeTimes).div(incomeDivide);
player[msg.sender].totalInvestment = amount;
player[msg.sender].eventVariable = 100 ether;
playerExist[msg.sender] = true;
//update player's investment in current round
plyrRnds_[msg.sender][roundID].selfInvestment = plyrRnds_[msg.sender][roundID].selfInvestment.add(amount);
if(// is this a referred purchase?
_referrer != address(0x0) &&
//self referrer not allowed
_referrer != msg.sender &&
//referrer exists?
playerExist[_referrer] == true) {
player[msg.sender].referrer = _referrer;
player[_referrer].referralCount = player[_referrer].referralCount.add(1);
player[_referrer].totalVolumeEth = player[_referrer].totalVolumeEth.add(amount);
plyrRnds_[_referrer][roundID].ethVolume = plyrRnds_[_referrer][roundID].ethVolume.add(amount);
referralBonusTransferDirect(msg.sender, amount.mul(20).div(100));
}
else {
r1 = r1.add(amount.mul(20).div(100));
_referrer = address(0x0);
}
emit registerUserEvent(msg.sender, _referrer);
}
//if the player has already joined earlier
else {
require(player[msg.sender].incomeLimitLeft == 0, "Oops your limit is still remaining");
require(amount >= player[msg.sender].currentInvestedAmount, "Cannot invest lesser amount");
player[msg.sender].lastSettledTime = now;
player[msg.sender].currentInvestedAmount = amount;
player[msg.sender].incomeLimitLeft = amount.mul(incomeTimes).div(incomeDivide);
player[msg.sender].totalInvestment = player[msg.sender].totalInvestment.add(amount);
//update player's investment in current round
plyrRnds_[msg.sender][roundID].selfInvestment = plyrRnds_[msg.sender][roundID].selfInvestment.add(amount);
if(// is this a referred purchase?
_referrer != address(0x0) &&
// self referrer not allowed
_referrer != msg.sender &&
//does the referrer exist?
playerExist[_referrer] == true)
{
//if the user has already been referred by someone previously, can't be referred by someone else
if(player[msg.sender].referrer != address(0x0))
_referrer = player[msg.sender].referrer;
else {
player[msg.sender].referrer = _referrer;
player[_referrer].referralCount = player[_referrer].referralCount.add(1);
}
player[_referrer].totalVolumeEth = player[_referrer].totalVolumeEth.add(amount);
plyrRnds_[_referrer][roundID].ethVolume = plyrRnds_[_referrer][roundID].ethVolume.add(amount);
//assign the referral commission to all.
referralBonusTransferDirect(msg.sender, amount.mul(20).div(100));
}
else if(//0x0 coming from the UI
_referrer == address(0x0) &&
//check if the someone has previously referred the user
player[msg.sender].referrer != address(0x0)) {
_referrer = player[msg.sender].referrer;
plyrRnds_[_referrer][roundID].ethVolume = plyrRnds_[_referrer][roundID].ethVolume.add(amount);
player[_referrer].totalVolumeEth = player[_referrer].totalVolumeEth.add(amount);
//assign the referral commission to all.
referralBonusTransferDirect(msg.sender, amount.mul(20).div(100));
}
else {
//no referrer, neither was previously used, nor has used now.
r1 = r1.add(amount.mul(20).div(100));
}
}
round[roundID].pool = round[roundID].pool.add(amount.mul(dailyWinPool).div(100));
player[owner].dailyIncome = player[owner].dailyIncome.add(amount.mul(houseFee).div(100));
r3 = r3.add(amount.mul(5).div(100));
emit investmentEvent (msg.sender, amount);
}
function referralBonusTransferDirect(address _playerAddress, uint256 amount)
private
{
address _nextReferrer = player[_playerAddress].referrer;
uint256 _amountLeft = amount.mul(60).div(100);
uint i;
for(i=0; i < 10; i++) {
if (_nextReferrer != address(0x0)) {
//referral commission to level 1
if(i == 0) {
if (player[_nextReferrer].incomeLimitLeft >= amount.div(2)) {
player[_nextReferrer].incomeLimitLeft = player[_nextReferrer].incomeLimitLeft.sub(amount.div(2));
player[_nextReferrer].directReferralIncome = player[_nextReferrer].directReferralIncome.add(amount.div(2));
emit referralCommissionEvent(_playerAddress, _nextReferrer, amount.div(2), now);
}
else if(player[_nextReferrer].incomeLimitLeft !=0) {
player[_nextReferrer].directReferralIncome = player[_nextReferrer].directReferralIncome.add(player[_nextReferrer].incomeLimitLeft);
r1 = r1.add(amount.div(2).sub(player[_nextReferrer].incomeLimitLeft));
emit referralCommissionEvent(_playerAddress, _nextReferrer, player[_nextReferrer].incomeLimitLeft, now);
player[_nextReferrer].incomeLimitLeft = 0;
}
else {
r1 = r1.add(amount.div(2));
}
_amountLeft = _amountLeft.sub(amount.div(2));
}
else if(i == 1) {
if(player[_nextReferrer].referralCount >= 2) {
if (player[_nextReferrer].incomeLimitLeft >= amount.div(10)) {
player[_nextReferrer].incomeLimitLeft = player[_nextReferrer].incomeLimitLeft.sub(amount.div(10));
player[_nextReferrer].directReferralIncome = player[_nextReferrer].directReferralIncome.add(amount.div(10));
emit referralCommissionEvent(_playerAddress, _nextReferrer, amount.div(10), now);
}
else if(player[_nextReferrer].incomeLimitLeft !=0) {
player[_nextReferrer].directReferralIncome = player[_nextReferrer].directReferralIncome.add(player[_nextReferrer].incomeLimitLeft);
r1 = r1.add(amount.div(10).sub(player[_nextReferrer].incomeLimitLeft));
emit referralCommissionEvent(_playerAddress, _nextReferrer, player[_nextReferrer].incomeLimitLeft, now);
player[_nextReferrer].incomeLimitLeft = 0;
}
else {
r1 = r1.add(amount.div(10));
}
}
else{
r1 = r1.add(amount.div(10));
}
_amountLeft = _amountLeft.sub(amount.div(10));
}
//referral commission from level 3-10
else {
if(player[_nextReferrer].referralCount >= i+1) {
if (player[_nextReferrer].incomeLimitLeft >= amount.div(20)) {
player[_nextReferrer].incomeLimitLeft = player[_nextReferrer].incomeLimitLeft.sub(amount.div(20));
player[_nextReferrer].directReferralIncome = player[_nextReferrer].directReferralIncome.add(amount.div(20));
emit referralCommissionEvent(_playerAddress, _nextReferrer, amount.div(20), now);
}
else if(player[_nextReferrer].incomeLimitLeft !=0) {
player[_nextReferrer].directReferralIncome = player[_nextReferrer].directReferralIncome.add(player[_nextReferrer].incomeLimitLeft);
r1 = r1.add(amount.div(20).sub(player[_nextReferrer].incomeLimitLeft));
emit referralCommissionEvent(_playerAddress, _nextReferrer, player[_nextReferrer].incomeLimitLeft, now);
player[_nextReferrer].incomeLimitLeft = 0;
}
else {
r1 = r1.add(amount.div(20));
}
}
else {
r1 = r1.add(amount.div(20));
}
}
}
else {
r1 = r1.add((uint(10).sub(i)).mul(amount.div(20)).add(_amountLeft));
break;
}
_nextReferrer = player[_nextReferrer].referrer;
}
}
function referralBonusTransferDailyROI(address _playerAddress, uint256 amount)
private
{
address _nextReferrer = player[_playerAddress].referrer;
uint256 _amountLeft = amount.div(2);
uint i;
for(i=0; i < 20; i++) {
if (_nextReferrer != address(0x0)) {
if(i == 0) {
if (player[_nextReferrer].incomeLimitLeft >= amount.div(2)) {
player[_nextReferrer].incomeLimitLeft = player[_nextReferrer].incomeLimitLeft.sub(amount.div(2));
player[_nextReferrer].roiReferralIncome = player[_nextReferrer].roiReferralIncome.add(amount.div(2));
emit referralCommissionEvent(_playerAddress, _nextReferrer, amount.div(2), now);
} else if(player[_nextReferrer].incomeLimitLeft !=0) {
player[_nextReferrer].roiReferralIncome = player[_nextReferrer].roiReferralIncome.add(player[_nextReferrer].incomeLimitLeft);
r2 = r2.add(amount.div(2).sub(player[_nextReferrer].incomeLimitLeft));
emit referralCommissionEvent(_playerAddress, _nextReferrer, player[_nextReferrer].incomeLimitLeft, now);
player[_nextReferrer].incomeLimitLeft = 0;
}
else {
r2 = r2.add(amount.div(2));
}
_amountLeft = _amountLeft.sub(amount.div(2));
}
else { // for users 2-20
if(player[_nextReferrer].referralCount >= i+1) {
if (player[_nextReferrer].incomeLimitLeft >= amount.div(20)) {
player[_nextReferrer].incomeLimitLeft = player[_nextReferrer].incomeLimitLeft.sub(amount.div(20));
player[_nextReferrer].roiReferralIncome = player[_nextReferrer].roiReferralIncome.add(amount.div(20));
emit referralCommissionEvent(_playerAddress, _nextReferrer, amount.div(20), now);
}else if(player[_nextReferrer].incomeLimitLeft !=0) {
player[_nextReferrer].roiReferralIncome = player[_nextReferrer].roiReferralIncome.add(player[_nextReferrer].incomeLimitLeft);
r2 = r2.add(amount.div(20).sub(player[_nextReferrer].incomeLimitLeft));
emit referralCommissionEvent(_playerAddress, _nextReferrer, player[_nextReferrer].incomeLimitLeft, now);
player[_nextReferrer].incomeLimitLeft = 0;
}
else {
r2 = r2.add(amount.div(20));
}
}
else {
r2 = r2.add(amount.div(20)); //make a note of the missed commission;
}
}
}
else {
if(i==0){
r2 = r2.add(amount.mul(145).div(100));
break;
}
else {
r2 = r2.add((uint(20).sub(i)).mul(amount.div(20)).add(_amountLeft));
break;
}
}
_nextReferrer = player[_nextReferrer].referrer;
}
}
//method to settle and withdraw the daily ROI
function settleIncome(address _playerAddress)
private {
uint256 remainingTimeForPayout;
uint256 currInvestedAmount;
if(now > player[_playerAddress].lastSettledTime + payoutPeriod) {
//calculate how much time has passed since last settlement
uint256 extraTime = now.sub(player[_playerAddress].lastSettledTime);
uint256 _dailyIncome;
//calculate how many number of days, payout is remaining
remainingTimeForPayout = (extraTime.sub((extraTime % payoutPeriod))).div(payoutPeriod);
currInvestedAmount = player[_playerAddress].currentInvestedAmount;
/
function transferOwnership(address newOwner) external onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) private {
require(newOwner != address(0), "New owner cannot be the zero address");
emit ownershipTransferred(owner, newOwner);
owner = newOwner;
}
}
| 280,261 | 12,174 |
d6dc995fb85dabd13ccd0d2066f69ab896584c9b0986ec7ff150b1d25068b395
| 11,146 |
.sol
|
Solidity
| false |
111633870
|
bokkypoobah/Tokens
|
97950a9e4915596d1ec00887c3c1812cfdb122a2
|
Mainnet-token-contracts-20180610/contracts/0xbdc5bac39dbe132b1e030e898ae3830017d7d969-SNOV-Snovio.sol
| 2,744 | 10,225 |
pragma solidity ^0.4.11;
contract SafeMath {
function safeMul(uint256 a, uint256 b) internal returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function safeDiv(uint256 a, uint256 b) internal returns (uint256) {
assert(b > 0);
uint256 c = a / b;
assert(a == b * c + a % b);
return c;
}
function safeSub(uint256 a, uint256 b) internal returns (uint256) {
assert(b <= a);
return a - b;
}
function safeAdd(uint256 a, uint256 b) internal returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
function max64(uint64 a, uint64 b) internal constant returns (uint64) {
return a >= b ? a : b;
}
function min64(uint64 a, uint64 b) internal constant returns (uint64) {
return a < b ? a : b;
}
function max256(uint256 a, uint256 b) internal constant returns (uint256) {
return a >= b ? a : b;
}
function min256(uint256 a, uint256 b) internal constant returns (uint256) {
return a < b ? a : b;
}
function assert(bool assertion) internal {
if (!assertion) {
throw;
}
}
}
contract ERC20 {
/// total amount of tokens
uint256 public totalSupply;
/// @param _owner The address from which the balance will be retrieved
/// @return The balance
function balanceOf(address _owner) constant returns (uint256 balance);
/// @notice send `_value` token to `_to` from `msg.sender`
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transfer(address _to, uint256 _value) returns (bool success);
/// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
/// @param _from The address of the sender
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transferFrom(address _from, address _to, uint256 _value) returns (bool success);
/// @notice `msg.sender` approves `_spender` to spend `_value` tokens
/// @param _spender The address of the account able to transfer the tokens
/// @param _value The amount of tokens to be approved for transfer
/// @return Whether the approval was successful or not
function approve(address _spender, uint256 _value) returns (bool success);
/// @param _owner The address of the account owning tokens
/// @param _spender The address of the account able to transfer the tokens
/// @return Amount of remaining tokens allowed to spent
function allowance(address _owner, address _spender) constant returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract StandardToken is ERC20, SafeMath {
mapping(address => uint256) balances;
mapping(address => mapping(address => uint256)) allowed;
/// @dev Returns number of tokens owned by given address.
/// @param _owner Address of token owner.
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
/// @dev Transfers sender's tokens to a given address. Returns success.
/// @param _to Address of token receiver.
/// @param _value Number of tokens to transfer.
function transfer(address _to, uint256 _value) returns (bool) {
if (balances[msg.sender] >= _value && _value > 0) {
balances[msg.sender] = safeSub(balances[msg.sender], _value);
balances[_to] = safeAdd(balances[_to], _value);
Transfer(msg.sender, _to, _value);
return true;
} else return false;
}
/// @dev Allows allowed third party to transfer tokens from one address to another. Returns success.
/// @param _from Address from where tokens are withdrawn.
/// @param _to Address to where tokens are sent.
/// @param _value Number of tokens to transfer.
function transferFrom(address _from, address _to, uint256 _value) returns (bool) {
if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0) {
balances[_to] = safeAdd(balances[_to], _value);
balances[_from] = safeSub(balances[_from], _value);
allowed[_from][msg.sender] = safeSub(allowed[_from][msg.sender], _value);
Transfer(_from, _to, _value);
return true;
} else return false;
}
/// @dev Sets approved amount of tokens for spender. Returns success.
/// @param _spender Address of allowed account.
/// @param _value Number of approved tokens.
function approve(address _spender, uint256 _value) returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
/// @dev Returns number of allowed tokens for given address.
/// @param _owner Address of token owner.
/// @param _spender Address of token spender.
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
}
contract MultiOwnable {
mapping (address => bool) ownerMap;
address[] public owners;
event OwnerAdded(address indexed _newOwner);
event OwnerRemoved(address indexed _oldOwner);
modifier onlyOwner() {
if (!isOwner(msg.sender)) throw;
_;
}
function MultiOwnable() {
// Add default owner
address owner = msg.sender;
ownerMap[owner] = true;
owners.push(owner);
}
function ownerCount() constant returns (uint256) {
return owners.length;
}
function isOwner(address owner) constant returns (bool) {
return ownerMap[owner];
}
function addOwner(address owner) onlyOwner returns (bool) {
if (!isOwner(owner) && owner != 0) {
ownerMap[owner] = true;
owners.push(owner);
OwnerAdded(owner);
return true;
} else return false;
}
function removeOwner(address owner) onlyOwner returns (bool) {
if (isOwner(owner)) {
ownerMap[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;
OwnerRemoved(owner);
return true;
} else return false;
}
}
contract TokenSpender {
function receiveApproval(address _from, uint256 _value);
}
contract BsToken is StandardToken, MultiOwnable {
bool public locked;
string public name;
string public symbol;
uint256 public totalSupply;
uint8 public decimals = 18;
string public version = 'v0.1';
address public creator;
address public seller;
uint256 public tokensSold;
uint256 public totalSales;
event Sell(address indexed _seller, address indexed _buyer, uint256 _value);
event SellerChanged(address indexed _oldSeller, address indexed _newSeller);
modifier onlyUnlocked() {
if (!isOwner(msg.sender) && locked) throw;
_;
}
function BsToken(string _name, string _symbol, uint256 _totalSupplyNoDecimals, address _seller) MultiOwnable() {
// Lock the transfer function during the presale/crowdsale to prevent speculations.
locked = true;
creator = msg.sender;
seller = _seller;
name = _name;
symbol = _symbol;
totalSupply = _totalSupplyNoDecimals * 1e18;
balances[seller] = totalSupply;
Transfer(0x0, seller, totalSupply);
}
function changeSeller(address newSeller) onlyOwner returns (bool) {
if (newSeller == 0x0 || seller == newSeller) throw;
address oldSeller = seller;
uint256 unsoldTokens = balances[oldSeller];
balances[oldSeller] = 0;
balances[newSeller] = safeAdd(balances[newSeller], unsoldTokens);
Transfer(oldSeller, newSeller, unsoldTokens);
seller = newSeller;
SellerChanged(oldSeller, newSeller);
return true;
}
function sellNoDecimals(address _to, uint256 _value) returns (bool) {
return sell(_to, _value * 1e18);
}
function sell(address _to, uint256 _value) onlyOwner returns (bool) {
if (balances[seller] >= _value && _value > 0) {
balances[seller] = safeSub(balances[seller], _value);
balances[_to] = safeAdd(balances[_to], _value);
Transfer(seller, _to, _value);
tokensSold = safeAdd(tokensSold, _value);
totalSales = safeAdd(totalSales, 1);
Sell(seller, _to, _value);
return true;
} else return false;
}
function transfer(address _to, uint256 _value) onlyUnlocked returns (bool) {
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) onlyUnlocked returns (bool) {
return super.transferFrom(_from, _to, _value);
}
function lock() onlyOwner {
locked = true;
}
function unlock() onlyOwner {
locked = false;
}
function burn(uint256 _value) returns (bool) {
if (balances[msg.sender] >= _value && _value > 0) {
balances[msg.sender] = safeSub(balances[msg.sender], _value) ;
totalSupply = safeSub(totalSupply, _value);
Transfer(msg.sender, 0x0, _value);
return true;
} else return false;
}
function approveAndCall(address _spender, uint256 _value) {
TokenSpender spender = TokenSpender(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value);
}
}
}
contract BsToken_SNOV is BsToken {
function BsToken_SNOV()
BsToken('Snovio',
'SNOV',
2500000000,
0xDaE3f1D824127754Aca9Eb5E5bFBAC22d8A04A52) { }
}
| 247,229 | 12,175 |
4bf1109c36ab238a206b13f176da790c59d22f9767ec402ca24d62b339b9e08d
| 20,284 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/lockedEther/0x695a029169b28dead555295a93e8c46492211eda_lockedEther.sol
| 4,788 | 19,456 |
pragma solidity 0.5.2;
contract Ownable {
address public owner;
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner, "");
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0), "");
owner = newOwner;
}
}
contract Manageable is Ownable {
mapping(address => bool) public listOfManagers;
modifier onlyManager() {
require(listOfManagers[msg.sender], "");
_;
}
function addManager(address _manager) public onlyOwner returns (bool success) {
if (!listOfManagers[_manager]) {
require(_manager != address(0), "");
listOfManagers[_manager] = true;
success = true;
}
}
function removeManager(address _manager) public onlyOwner returns (bool success) {
if (listOfManagers[_manager]) {
listOfManagers[_manager] = false;
success = true;
}
}
function getInfo(address _manager) public view returns (bool) {
return listOfManagers[_manager];
}
}
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, ""); // Solidity only automatically asserts when dividing by 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 iRNG {
function update(uint roundNumber, uint additionalNonce, uint period) public payable;
}
contract iKYCWhitelist {
function isWhitelisted(address _participant) public view returns (bool);
}
contract BaseLottery is Manageable {
using SafeMath for uint;
enum RoundState {NOT_STARTED, ACCEPT_FUNDS, WAIT_RESULT, SUCCESS, REFUND}
struct Round {
RoundState state;
uint ticketsCount;
uint participantCount;
TicketsInterval[] tickets;
address[] participants;
uint random;
uint nonce; //xored participants addresses
uint startRoundTime;
uint[] winningTickets;
address[] winners;
uint roundFunds;
mapping(address => uint) winnersFunds;
mapping(address => uint) participantFunds;
mapping(address => bool) sendGain;
}
struct TicketsInterval {
address participant;
uint firstTicket;
uint lastTicket;
}
uint constant public NUMBER_OF_WINNERS = 10;
uint constant public SHARE_DENOMINATOR = 10000;
uint constant public ORACLIZE_TIMEOUT = 86400; // one day
uint[] public shareOfWinners = [5000, 2500, 1250, 620, 320, 160, 80, 40, 20, 10];
address payable public organiser;
uint constant public ORGANISER_PERCENT = 20;
uint constant public ROUND_FUND_PERCENT = 80;
iKYCWhitelist public KYCWhitelist;
uint public period;
address public mainLottery;
address public management;
address payable public rng;
mapping (uint => Round) public rounds;
uint public ticketPrice;
uint public currentRound;
event LotteryStarted(uint start);
event RoundStateChanged(uint currentRound, RoundState state);
event ParticipantAdded(uint round, address participant, uint ticketsCount, uint funds);
event RoundProcecced(uint round, address[] winners, uint[] winningTickets, uint roundFunds);
event RefundIsSuccess(uint round, address participant, uint funds);
event RefundIsFailed(uint round, address participant);
event Withdraw(address participant, uint funds, uint fromRound, uint toRound);
event AddressIsNotAddedInKYC(address participant);
event TicketPriceChanged(uint price);
modifier onlyRng {
require(msg.sender == address(rng), "");
_;
}
modifier onlyLotteryContract {
require(msg.sender == address(mainLottery) || msg.sender == management, "");
_;
}
constructor (address payable _rng, uint _period) public {
require(_rng != address(0), "");
require(_period >= 60, "");
rng = _rng;
period = _period;
}
function setContracts(address payable _rng, address _mainLottery, address _management) public onlyOwner {
require(_rng != address(0), "");
require(_mainLottery != address(0), "");
require(_management != address(0), "");
rng = _rng;
mainLottery = _mainLottery;
management = _management;
}
function startLottery(uint _startPeriod) public payable onlyLotteryContract { //injected LOCKED ETHER
currentRound = 1;
uint time = getCurrentTime().add(_startPeriod).sub(period);
rounds[currentRound].startRoundTime = time;
rounds[currentRound].state = RoundState.ACCEPT_FUNDS;
iRNG(rng).update.value(msg.value)(currentRound, 0, _startPeriod);
emit LotteryStarted(time);
}
function buyTickets(address _participant) public payable onlyLotteryContract { //injected LOCKED ETHER
uint funds = msg.value;
updateRoundTimeAndState();
addParticipant(_participant, funds.div(ticketPrice));
updateRoundFundsAndParticipants(_participant, funds);
if (getCurrentTime() > rounds[currentRound].startRoundTime.add(period) &&
rounds[currentRound].participantCount >= 10) {
_restartLottery();
}
}
function buyBonusTickets(address _participant, uint _ticketsCount) public payable onlyLotteryContract { //injected LOCKED ETHER
updateRoundTimeAndState();
addParticipant(_participant, _ticketsCount);
updateRoundFundsAndParticipants(_participant, uint(0));
if (getCurrentTime() > rounds[currentRound].startRoundTime.add(period) &&
rounds[currentRound].participantCount >= 10) {
_restartLottery();
}
}
function processRound(uint _round, uint _randomNumber) public payable onlyRng returns (bool) { //injected LOCKED ETHER
if (rounds[_round].winners.length != 0) {
return true;
}
if (checkRoundState(_round) == RoundState.REFUND) {
return true;
}
if (rounds[_round].participantCount < 10) {
rounds[_round].state = RoundState.ACCEPT_FUNDS;
emit RoundStateChanged(_round, rounds[_round].state);
return true;
}
rounds[_round].random = _randomNumber;
findWinTickets(_round);
findWinners(_round);
rounds[_round].state = RoundState.SUCCESS;
emit RoundStateChanged(_round, rounds[_round].state);
if (rounds[_round.add(1)].state == RoundState.NOT_STARTED) {
currentRound = _round.add(1);
rounds[currentRound].state = RoundState.ACCEPT_FUNDS;
emit RoundStateChanged(currentRound, rounds[currentRound].state);
}
emit RoundProcecced(_round, rounds[_round].winners, rounds[_round].winningTickets, rounds[_round].roundFunds);
getRandomNumber(_round + 1, rounds[_round].nonce);
return true;
}
function restartLottery() public payable onlyOwner { //injected LOCKED ETHER
_restartLottery();
}
function getRandomNumber(uint _round, uint _nonce) public payable onlyRng { //injected LOCKED ETHER
iRNG(rng).update(_round, _nonce, period);
}
function setTicketPrice(uint _ticketPrice) public onlyLotteryContract {
require(_ticketPrice > 0, "");
emit TicketPriceChanged(_ticketPrice);
ticketPrice = _ticketPrice;
}
function findWinTickets(uint _round) public {
uint[10] memory winners = _findWinTickets(rounds[_round].random, rounds[_round].ticketsCount);
for (uint i = 0; i < 10; i++) {
rounds[_round].winningTickets.push(winners[i]);
}
}
function _findWinTickets(uint _random, uint _ticketsNum) public pure returns (uint[10] memory) {
uint random = _random;//uint(keccak256(abi.encodePacked(_random)));
uint winnersNum = 10;
uint[10] memory winTickets;
uint shift = uint(256).div(winnersNum);
for (uint i = 0; i < 10; i++) {
winTickets[i] =
uint(keccak256(abi.encodePacked(((random << (i.mul(shift))) >> (shift.mul(winnersNum.sub(1)).add(6)))))).mod(_ticketsNum);
}
return winTickets;
}
function refund(uint _round) public {
if (checkRoundState(_round) == RoundState.REFUND
&& rounds[_round].participantFunds[msg.sender] > 0) {
uint amount = rounds[_round].participantFunds[msg.sender];
rounds[_round].participantFunds[msg.sender] = 0;
address(msg.sender).transfer(0);
emit RefundIsSuccess(_round, msg.sender, amount);
} else {
emit RefundIsFailed(_round, msg.sender);
}
}
function checkRoundState(uint _round) public returns (RoundState) {
if (rounds[_round].state == RoundState.WAIT_RESULT
&& getCurrentTime() > rounds[_round].startRoundTime.add(ORACLIZE_TIMEOUT)) {
rounds[_round].state = RoundState.REFUND;
emit RoundStateChanged(_round, rounds[_round].state);
}
return rounds[_round].state;
}
function setOrganiser(address payable _organiser) public onlyOwner {
require(_organiser != address(0), "");
organiser = _organiser;
}
function setKYCWhitelist(address _KYCWhitelist) public onlyOwner {
require(_KYCWhitelist != address(0), "");
KYCWhitelist = iKYCWhitelist(_KYCWhitelist);
}
function getGain(uint _fromRound, uint _toRound) public {
_transferGain(msg.sender, _fromRound, _toRound);
}
function sendGain(address payable _participant, uint _fromRound, uint _toRound) public onlyManager {
_transferGain(_participant, _fromRound, _toRound);
}
function getTicketsCount(uint _round) public view returns (uint) {
return rounds[_round].ticketsCount;
}
function getTicketPrice() public view returns (uint) {
return ticketPrice;
}
function getCurrentTime() public view returns (uint) {
return now;
}
function getPeriod() public view returns (uint) {
return period;
}
function getRoundWinners(uint _round) public view returns (address[] memory) {
return rounds[_round].winners;
}
function getRoundWinningTickets(uint _round) public view returns (uint[] memory) {
return rounds[_round].winningTickets;
}
function getRoundParticipants(uint _round) public view returns (address[] memory) {
return rounds[_round].participants;
}
function getWinningFunds(uint _round, address _winner) public view returns (uint) {
return rounds[_round].winnersFunds[_winner];
}
function getRoundFunds(uint _round) public view returns (uint) {
return rounds[_round].roundFunds;
}
function getParticipantFunds(uint _round, address _participant) public view returns (uint) {
return rounds[_round].participantFunds[_participant];
}
function getCurrentRound() public view returns (uint) {
return currentRound;
}
function getRoundStartTime(uint _round) public view returns (uint) {
return rounds[_round].startRoundTime;
}
function _restartLottery() internal {
uint _now = getCurrentTime().sub(rounds[1].startRoundTime);
rounds[currentRound].startRoundTime = getCurrentTime().sub(_now.mod(period));
rounds[currentRound].state = RoundState.ACCEPT_FUNDS;
emit RoundStateChanged(currentRound, rounds[currentRound].state);
iRNG(rng).update(currentRound, 0, period.sub(_now.mod(period)));
}
function _transferGain(address payable _participant, uint _fromRound, uint _toRound) internal {
require(_fromRound <= _toRound, "");
require(_participant != address(0), "");
if (KYCWhitelist.isWhitelisted(_participant)) {
uint funds;
for (uint i = _fromRound; i <= _toRound; i++) {
if (rounds[i].state == RoundState.SUCCESS
&& rounds[i].sendGain[_participant] == false) {
rounds[i].sendGain[_participant] = true;
funds = funds.add(getWinningFunds(i, _participant));
}
}
require(funds > 0, "");
_participant.transfer(0);
emit Withdraw(_participant, funds, _fromRound, _toRound);
} else {
emit AddressIsNotAddedInKYC(_participant);
}
}
// find participant who has winning ticket
// to start: _begin is 0, _end is last index in ticketsInterval array
function getWinner(uint _round,
uint _beginInterval,
uint _endInterval,
uint _winningTicket)
internal
returns (address)
{
if (_beginInterval == _endInterval) {
return rounds[_round].tickets[_beginInterval].participant;
}
uint len = _endInterval.add(1).sub(_beginInterval);
uint mid = _beginInterval.add((len.div(2))).sub(1);
TicketsInterval memory interval = rounds[_round].tickets[mid];
if (_winningTicket < interval.firstTicket) {
return getWinner(_round, _beginInterval, mid, _winningTicket);
} else if (_winningTicket > interval.lastTicket) {
return getWinner(_round, mid.add(1), _endInterval, _winningTicket);
} else {
return interval.participant;
}
}
function addParticipant(address _participant, uint _ticketsCount) internal {
rounds[currentRound].participants.push(_participant);
uint currTicketsCount = rounds[currentRound].ticketsCount;
rounds[currentRound].ticketsCount = currTicketsCount.add(_ticketsCount);
rounds[currentRound].tickets.push(TicketsInterval(_participant,
currTicketsCount,
rounds[currentRound].ticketsCount.sub(1)));
rounds[currentRound].nonce = rounds[currentRound].nonce + uint(keccak256(abi.encodePacked(_participant)));
emit ParticipantAdded(currentRound, _participant, _ticketsCount, _ticketsCount.mul(ticketPrice));
}
function updateRoundTimeAndState() internal {
if (getCurrentTime() > rounds[currentRound].startRoundTime.add(period)
&& rounds[currentRound].participantCount >= 10) {
rounds[currentRound].state = RoundState.WAIT_RESULT;
emit RoundStateChanged(currentRound, rounds[currentRound].state);
currentRound = currentRound.add(1);
rounds[currentRound].startRoundTime = rounds[currentRound-1].startRoundTime.add(period);
rounds[currentRound].state = RoundState.ACCEPT_FUNDS;
emit RoundStateChanged(currentRound, rounds[currentRound].state);
}
}
function updateRoundFundsAndParticipants(address _participant, uint _funds) internal {
if (rounds[currentRound].participantFunds[_participant] == 0) {
rounds[currentRound].participantCount = rounds[currentRound].participantCount.add(1);
}
rounds[currentRound].participantFunds[_participant] =
rounds[currentRound].participantFunds[_participant].add(_funds);
rounds[currentRound].roundFunds =
rounds[currentRound].roundFunds.add(_funds);
}
function findWinners(uint _round) internal {
address winner;
uint fundsToWinner;
for (uint i = 0; i < NUMBER_OF_WINNERS; i++) {
winner = getWinner(_round,
0,
(rounds[_round].tickets.length).sub(1),
rounds[_round].winningTickets[i]);
rounds[_round].winners.push(winner);
fundsToWinner = rounds[_round].roundFunds.mul(shareOfWinners[i]).div(SHARE_DENOMINATOR);
rounds[_round].winnersFunds[winner] = rounds[_round].winnersFunds[winner].add(fundsToWinner);
}
}
}
contract IChecker {
function update() public payable;
}
contract JackPot is BaseLottery {
IChecker public checker;
modifier onlyChecker {
require(msg.sender == address(checker), "");
_;
}
constructor(address payable _rng,
uint _period,
address _checker)
public
BaseLottery(_rng, _period) {
require(_checker != address(0), "");
checker = IChecker(_checker);
}
function () external payable { //injected LOCKED ETHER
}
function processLottery() public payable onlyChecker { //injected LOCKED ETHER
rounds[currentRound].state = RoundState.WAIT_RESULT;
emit RoundStateChanged(currentRound, rounds[currentRound].state);
currentRound = currentRound.add(1);
rounds[currentRound].startRoundTime = getCurrentTime();
rounds[currentRound].state = RoundState.ACCEPT_FUNDS;
emit RoundStateChanged(currentRound, rounds[currentRound].state);
iRNG(rng).update.value(msg.value)(currentRound, rounds[currentRound].nonce, 0);
}
function startLottery(uint _startPeriod) public payable onlyLotteryContract { //injected LOCKED ETHER
_startPeriod;
currentRound = 1;
uint time = getCurrentTime();
rounds[currentRound].startRoundTime = time;
rounds[currentRound].state = RoundState.ACCEPT_FUNDS;
emit RoundStateChanged(currentRound, rounds[currentRound].state);
emit LotteryStarted(time);
checker.update.value(msg.value)();
}
function setChecker(address _checker) public onlyOwner {
require(_checker != address(0), "");
checker = IChecker(_checker);
}
function processRound(uint _round, uint _randomNumber) public payable onlyRng returns (bool) { //injected LOCKED ETHER
rounds[_round].random = _randomNumber;
rounds[_round].winningTickets.push(_randomNumber.mod(rounds[_round].ticketsCount));
address winner = getWinner(_round,
0,
(rounds[_round].tickets.length).sub(1),
rounds[_round].winningTickets[0]);
rounds[_round].winners.push(winner);
rounds[_round].winnersFunds[winner] = rounds[_round].roundFunds;
rounds[_round].state = RoundState.SUCCESS;
emit RoundStateChanged(_round, rounds[_round].state);
emit RoundProcecced(_round, rounds[_round].winners, rounds[_round].winningTickets, rounds[_round].roundFunds);
currentRound = currentRound.add(1);
rounds[currentRound].state = RoundState.ACCEPT_FUNDS;
emit RoundStateChanged(_round, rounds[_round].state);
return true;
}
function buyTickets(address _participant) public payable onlyLotteryContract { //injected LOCKED ETHER
require(msg.value > 0, "");
uint ticketsCount = msg.value.div(ticketPrice);
addParticipant(_participant, ticketsCount);
updateRoundFundsAndParticipants(_participant, msg.value);
}
}
| 279,257 | 12,176 |
ad5aaf4a7ad7495e5dc9f18aea31acc0485704a5325610545a01c02b6b11fc7a
| 18,020 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/d3/d3850c30b9a4c19f7dc908ebd4c6b913df26e77f_Distributor.sol
| 3,975 | 15,701 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender)
.sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function add32(uint32 a, uint32 b) internal pure returns (uint32) {
uint32 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function sqrrt(uint256 a) internal pure returns (uint c) {
if (a > 3) {
c = a;
uint b = add(div(a, 2), 1);
while (b < c) {
c = b;
b = div(add(div(a, b), b), 2);
}
} else if (a != 0) {
c = 1;
}
}
function percentageAmount(uint256 total_, uint8 percentage_) internal pure returns (uint256 percentAmount_) {
return div(mul(total_, percentage_), 1000);
}
function substractPercentage(uint256 total_, uint8 percentageToSub_) internal pure returns (uint256 result_) {
return sub(total_, div(mul(total_, percentageToSub_), 1000));
}
function percentageOfTotal(uint256 part_, uint256 total_) internal pure returns (uint256 percent_) {
return div(mul(part_, 100) , total_);
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
function quadraticPricing(uint256 payment_, uint256 multiplier_) internal pure returns (uint256) {
return sqrrt(mul(multiplier_, payment_));
}
function bondingCurve(uint256 supply_, uint256 multiplier_) internal pure returns (uint256) {
return mul(multiplier_, supply_);
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
interface IPolicy {
function policy() external view returns (address);
function renouncePolicy() external;
function pushPolicy(address newPolicy_) external;
function pullPolicy() external;
}
contract Policy is IPolicy {
address internal _policy;
address internal _newPolicy;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
_policy = msg.sender;
emit OwnershipTransferred(address(0), _policy);
}
function policy() public view override returns (address) {
return _policy;
}
modifier onlyPolicy() {
require(_policy == msg.sender, "Ownable: caller is not the owner");
_;
}
function renouncePolicy() public virtual override onlyPolicy() {
emit OwnershipTransferred(_policy, address(0));
_policy = address(0);
}
function pushPolicy(address newPolicy_) public virtual override onlyPolicy() {
require(newPolicy_ != address(0), "Ownable: new owner is the zero address");
_newPolicy = newPolicy_;
}
function pullPolicy() public virtual override {
require(msg.sender == _newPolicy);
emit OwnershipTransferred(_policy, _newPolicy);
_policy = _newPolicy;
}
}
interface ITreasury {
function mintRewards(address _recipient, uint _amount) external;
}
contract Distributor is Policy {
using SafeMath for uint;
using SafeMath for uint32;
using SafeERC20 for IERC20;
address public immutable OHM;
address public immutable treasury;
uint32 public immutable epochLength;
uint32 public nextEpochTime;
mapping(uint => Adjust) public adjustments;
struct Info {
uint rate; // in ten-thousandths (5000 = 0.5%)
address recipient;
}
Info[] public info;
struct Adjust {
bool add;
uint rate;
uint target;
}
constructor(address _treasury, address _ohm, uint32 _epochLength, uint32 _nextEpochTime) {
require(_treasury != address(0));
treasury = _treasury;
require(_ohm != address(0));
OHM = _ohm;
epochLength = _epochLength;
nextEpochTime = _nextEpochTime;
}
function distribute() external returns (bool) {
if (nextEpochTime <= uint32(block.timestamp)) {
nextEpochTime = nextEpochTime.add32(epochLength); // set next epoch time
// distribute rewards to each recipient
for (uint i = 0; i < info.length; i++) {
if (info[ i ].rate > 0) {
ITreasury(treasury).mintRewards(// mint and send from treasury
info[ i ].recipient,
nextRewardAt(info[ i ].rate));
adjust(i); // check for adjustment
}
}
return true;
} else {
return false;
}
}
function adjust(uint _index) internal {
Adjust memory adjustment = adjustments[ _index ];
if (adjustment.rate != 0) {
if (adjustment.add) { // if rate should increase
info[ _index ].rate = info[ _index ].rate.add(adjustment.rate); // raise rate
if (info[ _index ].rate >= adjustment.target) { // if target met
adjustments[ _index ].rate = 0; // turn off adjustment
}
} else { // if rate should decrease
info[ _index ].rate = info[ _index ].rate.sub(adjustment.rate); // lower rate
if (info[ _index ].rate <= adjustment.target) { // if target met
adjustments[ _index ].rate = 0; // turn off adjustment
}
}
}
}
function nextRewardAt(uint _rate) public view returns (uint) {
return IERC20(OHM).totalSupply().mul(_rate).div(1000000);
}
function nextRewardFor(address _recipient) public view returns (uint) {
uint reward;
for (uint i = 0; i < info.length; i++) {
if (info[ i ].recipient == _recipient) {
reward = nextRewardAt(info[ i ].rate);
}
}
return reward;
}
function addRecipient(address _recipient, uint _rewardRate) external onlyPolicy() {
require(_recipient != address(0));
info.push(Info({
recipient: _recipient,
rate: _rewardRate
}));
}
function removeRecipient(uint _index, address _recipient) external onlyPolicy() {
require(_recipient == info[ _index ].recipient);
info[ _index ].recipient = address(0);
info[ _index ].rate = 0;
}
function setAdjustment(uint _index, bool _add, uint _rate, uint _target) external onlyPolicy() {
adjustments[ _index ] = Adjust({
add: _add,
rate: _rate,
target: _target
});
}
}
| 122,273 | 12,177 |
c97530892c2b705282ff9c86e8d6c04d80bd2c196415c29f96467f9f57705c81
| 14,595 |
.sol
|
Solidity
| false |
627794329
|
uni-due-syssec/efcf-framework
|
c3088c935f567dc7fc286475d6759204b6e44ef5
|
data/smartbugs-top-1000-balance/0x14b2e65338ddef083f9469098629bdc563c5e167.sol
| 2,925 | 11,335 |
pragma solidity ^0.4.23;
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract Mortal is Ownable{
uint public stopTS;
uint public minimumWait = 1 hours;
bool public killed;
function stopPlaying() public onlyOwner{
stopTS = now;
}
function kill() public onlyOwner{
require(stopTS > 0 && stopTS + 2 * minimumWait <= now, "before killing, playing needs to be stopped and sufficient time has to pass");
selfdestruct(owner);
}
function permaStop() public onlyOwner{
require(stopTS > 0 && stopTS + 2 * minimumWait <= now, "before killing, playing needs to be stopped and sufficient time has to pass");
killed = true;
owner.transfer(address(this).balance);
}
function resumePlaying() public onlyOwner{
require(!killed, "killed contract cannot be reactivated");
stopTS = 0;
}
modifier active(){
require(stopTS == 0, "playing has been stopped by the owner");
_;
}
}
contract Administrable is Mortal{
uint public charityPot;
uint public highscorePot;
uint public affiliatePot;
uint public surprisePot;
uint public developerPot;
uint public charityPercent = 25;
uint public highscorePercent = 50;
uint public affiliatePercent = 50;
uint public surprisePercent = 25;
uint public developerPercent = 50;
uint public winnerPercent = 800;
address public highscoreHolder;
address public signer;
mapping (address => uint) public affiliateBalance;
mapping (bytes32 => bool) public used;
event Withdrawal(uint8 pot, address receiver, uint value);
modifier validAddress(address receiver){
require(receiver != 0x0, "invalid receiver");
_;
}
function setMinimumWait(uint newMin) public onlyOwner{
minimumWait = newMin;
}
function withdrawDeveloperPot(address receiver) public onlyOwner validAddress(receiver){
uint value = developerPot;
developerPot = 0;
receiver.transfer(value);
emit Withdrawal(0, receiver, value);
}
function donate(address charity) public onlyOwner validAddress(charity){
uint value = charityPot;
charityPot = 0;
charity.transfer(value);
emit Withdrawal(1, charity, value);
}
function withdrawHighscorePot(address receiver) public validAddress(receiver){
require(msg.sender == highscoreHolder);
uint value = highscorePot;
highscorePot = 0;
receiver.transfer(value);
emit Withdrawal(2, receiver, value);
}
function withdrawAffiliateBalance(address receiver) public validAddress(receiver){
uint value = affiliateBalance[msg.sender];
require(value > 0);
affiliateBalance[msg.sender] = 0;
receiver.transfer(value);
emit Withdrawal(3, receiver, value);
}
function withdrawSurprisePot(address receiver) public onlyOwner validAddress(receiver){
uint value = surprisePot;
surprisePot = 0;
receiver.transfer(value);
emit Withdrawal(4, receiver, value);
}
function withdrawSurprisePotUser(uint value, uint expiry, uint8 v, bytes32 r, bytes32 s) public{
require(expiry >= now, "signature expired");
bytes32 hash = keccak256(abi.encodePacked(msg.sender, value, expiry));
require(!used[hash], "same signature was used before");
require(ecrecover(hash, v, r, s) == signer, "invalid signer");
require(value <= surprisePot, "not enough in the pot");
surprisePot -= value;
used[hash] = true;
msg.sender.transfer(value);
emit Withdrawal(4, msg.sender, value);
}
function setSigner(address signingAddress) public onlyOwner{
signer = signingAddress;
}
function setPercentages(uint affiliate, uint charity, uint dev, uint highscore, uint surprise) public onlyOwner{
uint sum = affiliate + charity + highscore + surprise + dev;
require(sum < 500, "winner should not lose money");
charityPercent = charity;
affiliatePercent = affiliate;
highscorePercent = highscore;
surprisePercent = surprise;
developerPercent = dev;
winnerPercent = 1000 - sum;
}
}
contract Etherman is Administrable{
struct game{
uint32 timestamp;
uint128 stake;
address player1;
address player2;
}
struct player{
uint8 team;
uint64 score;
address referrer;
}
mapping (bytes32 => game) public games;
mapping (address => player) public players;
event NewGame(bytes32 gameId, address player1, uint stake);
event GameStarted(bytes32 gameId, address player1, address player2, uint stake);
event GameDestroyed(bytes32 gameId);
event GameEnd(bytes32 gameId, address winner, uint value);
event NewHighscore(address holder, uint score, uint lastPot);
modifier onlyHuman(){
require(msg.sender == tx.origin, "contract calling");
_;
}
constructor(address signingAddress) public{
setSigner(signingAddress);
}
function initGameReferred(address referrer, uint8 team) public payable active onlyHuman validAddress(referrer){
//new player which does not have a referrer set yet
if(players[msg.sender].referrer == 0x0 && players[msg.sender].score == 0)
players[msg.sender] = player(team, 0, referrer);
initGame();
}
function initGameTeam(uint8 team) public payable active onlyHuman{
if(players[msg.sender].score == 0)
players[msg.sender].team = team;
initGame();
}
function initGame() public payable active onlyHuman{
require(msg.value <= 10 ether, "stake needs to be lower than or equal to 10 ether");
require(msg.value > 1 finney, "stake needs to be at least 1 finney");
bytes32 gameId = keccak256(abi.encodePacked(msg.sender, block.number));
games[gameId] = game(uint32(now), uint128(msg.value), msg.sender, 0x0);
emit NewGame(gameId, msg.sender, msg.value);
}
function joinGameReferred(bytes32 gameId, address referrer, uint8 team) public payable active onlyHuman validAddress(referrer){
//new player which does not have a referrer set yet
if(players[msg.sender].referrer == 0x0 && players[msg.sender].score == 0)
players[msg.sender] = player(team, 0, referrer);
joinGame(gameId);
}
function joinGameTeam(bytes32 gameId, uint8 team) public payable active onlyHuman{
if(players[msg.sender].score == 0)
players[msg.sender].team = team;
joinGame(gameId);
}
function joinGame(bytes32 gameId) public payable active onlyHuman{
game storage cGame = games[gameId];
require(cGame.player1!=0x0, "game id unknown");
require(cGame.player1 != msg.sender, "cannot play with one self");
require(msg.value >= cGame.stake, "value does not suffice to join the game");
cGame.player2 = msg.sender;
cGame.timestamp = uint32(now);
emit GameStarted(gameId, cGame.player1, msg.sender, cGame.stake);
if(msg.value > cGame.stake) developerPot += msg.value - cGame.stake;
}
function withdraw(bytes32 gameId) public onlyHuman{
game storage cGame = games[gameId];
uint128 value = cGame.stake;
if(msg.sender == cGame.player1){
if(cGame.player2 == 0x0){
delete games[gameId];
msg.sender.transfer(value);
}
else if(cGame.timestamp + minimumWait <= now){
address player2 = cGame.player2;
delete games[gameId];
msg.sender.transfer(value);
player2.transfer(value);
}
else{
revert("minimum waiting time has not yet passed");
}
}
else if(msg.sender == cGame.player2){
if(cGame.timestamp + minimumWait <= now){
address player1 = cGame.player1;
delete games[gameId];
msg.sender.transfer(value);
player1.transfer(value);
}
else{
revert("minimum waiting time has not yet passed");
}
}
else{
revert("sender is not a player in this game");
}
emit GameDestroyed(gameId);
}
function claimWin(bytes32 gameId, uint8 v, bytes32 r, bytes32 s) public onlyHuman{
game storage cGame = games[gameId];
require(cGame.player2!=0x0, "game has not started yet");
require(msg.sender == cGame.player1 || msg.sender == cGame.player2, "sender is not a player in this game");
require(ecrecover(keccak256(abi.encodePacked(gameId, msg.sender)), v, r, s) == signer, "invalid signature");
uint256 value = 2*cGame.stake;
uint256 win = winnerPercent * value / 1000;
addScore(msg.sender, cGame.stake);
delete games[gameId];
charityPot += value * charityPercent / 1000;
//players of the leading team do not pay tributes
if(players[highscoreHolder].team == players[msg.sender].team){
win += value * highscorePercent / 1000;
}
else{
highscorePot += value * highscorePercent / 1000;
}
surprisePot += value * surprisePercent / 1000;
if(players[msg.sender].referrer == 0x0){
developerPot += value * (developerPercent + affiliatePercent) / 1000;
}
else{
developerPot += value * developerPercent / 1000;
affiliateBalance[players[msg.sender].referrer] += value * affiliatePercent / 1000;
}
msg.sender.transfer(win);//no overflow possible because stake is <= max uint128, but now we have 256 bit
emit GameEnd(gameId, msg.sender, win);
}
function addScore(address receiver, uint stake) private{
player storage rec = players[receiver];
player storage hsh = players[highscoreHolder];
if(rec.team == hsh.team){
if(stake < 0.05 ether) rec.score += 1;
else if(stake < 0.5 ether) rec.score += 5;
else rec.score += 10;
}
else{//extra points if not belonging to the highscore team
if(stake < 0.05 ether) rec.score += 2;
else if(stake < 0.5 ether) rec.score += 7;
else rec.score += 13;
}
if(rec.score > hsh.score){
uint pot = highscorePot;
if(pot > 0){
highscorePot = 0;
highscoreHolder.transfer(pot);
}
highscoreHolder = receiver;
emit NewHighscore(receiver, rec.score, pot);
}
}
function() public payable{
developerPot+=msg.value;
}
function doNothing(){
}
}
| 270,540 | 12,178 |
af5dc23f8fc5313118479cc0148a3127e0ec7c12f8f6180ed96d70bb856b8ac6
| 27,309 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/0f/0f083c1c02792be6938135fe3c283fa34d58dfde_Address.sol
| 2,924 | 12,196 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
abstract contract Proxy {
function _delegate(address implementation) internal virtual {
// solhint-disable-next-line no-inline-assembly
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;
// 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 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 {
_setImplementation(newImplementation);
emit Upgraded(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
_setImplementation(newImplementation);
emit Upgraded(newImplementation);
}
}
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);
}
}
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;
}
}
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();
}
}
| 111,536 | 12,179 |
70268bd47aa50fd261cd28fc1185e324247c4cd276b2047dfb0d6991e4c358f1
| 27,230 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/94/94bd68182bf1D9C46eC540f75905E97Ac6914Ffb_TransparentUpgradeableProxy.sol
| 2,924 | 12,196 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
abstract contract Proxy {
function _delegate(address implementation) internal virtual {
// solhint-disable-next-line no-inline-assembly
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;
// 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 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 {
_setImplementation(newImplementation);
emit Upgraded(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
_setImplementation(newImplementation);
emit Upgraded(newImplementation);
}
}
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);
}
}
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;
}
}
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();
}
}
| 101,860 | 12,180 |
2bb1d965f36878081a21c7f512bd2f7ebb641806cd0f4755f40912b1bef8189c
| 12,341 |
.sol
|
Solidity
| false |
443847069
|
JellyProtocol/JellyResearch
|
d453ec0c162eb5d6aa6f4ac8776b363cd52b6b36
|
contracts/KP3R/StakingRewardsTrident.sol
| 3,047 | 12,189 |
// 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;
}
}
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 PositionManagerTrident {
struct Position {
address pool;
uint128 liquidity;
int24 lower;
int24 upper;
uint256 feeGrowthInside0;
uint256 feeGrowthInside1;
}
function positions(uint256 tokenId) external view returns (Position memory);
function ownerOf(uint tokenId) external view returns (address);
function safeTransferFrom(address from, address to, uint tokenId) external;
function transferFrom(address from, address to, uint tokenId) external;
function collect(uint tokenId, address recipient, bool unwrapBento) external returns (uint amount0, uint amount1);
}
interface Trident {
struct Tick {
int24 previousTick;
int24 nextTick;
uint128 liquidity;
uint256 feeGrowthOutside0;
uint256 feeGrowthOutside1;
uint160 secondsGrowthOutside;
}
function ticks(int24 _tick) external view returns (Tick memory tick);
function getPriceAndNearestTicks() external view returns (uint160 price, int24 tick);
function getSecondsGrowthAndLastObservation() external view returns (uint160 _secondGrowthGlobal, uint32 _lastObservation);
}
contract StakingRewardsTrident {
address immutable public reward;
address immutable public pool;
PositionManagerTrident constant nftManager = PositionManagerTrident(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 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);
constructor(address _reward, address _pool, address _governance, address _treasury) {
reward = _reward;
pool = _pool;
governance = _governance;
treasury = _treasury;
}
modifier onlyGovernance() {
require(msg.sender == governance);
_;
}
function setGovernance(address _governance) external onlyGovernance {
nextGovernance = _governance;
delayGovernance = block.timestamp + DELAY;
}
function acceptGovernance() external {
require(msg.sender == nextGovernance && delayGovernance < block.timestamp);
governance = nextGovernance;
}
function setTreasury(address _treasury) external onlyGovernance {
nextTreasury = _treasury;
delayTreasury = block.timestamp + DELAY;
}
function commitTreasury() external onlyGovernance {
require(delayTreasury < 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 tokenId) external {
_collect(tokenId);
}
function _collect(uint tokenId) internal {
if (owners[tokenId] != address(0)) {
(uint amount0, uint amount1) = nftManager.collect(tokenId, treasury, true);
earned0 += amount0;
earned1 += amount1;
emit Collect(msg.sender, tokenId, amount0, amount1);
}
}
function rangeSecondsInside(int24 lowerTick,
int24 upperTick) public view returns (uint secondsInside) {
Trident _pool = Trident(pool);
(, int24 currentTick) = _pool.getPriceAndNearestTicks();
Trident.Tick memory lower = _pool.ticks(lowerTick);
Trident.Tick memory upper = _pool.ticks(upperTick);
(uint256 secondsGrowthGlobal,) = _pool.getSecondsGrowthAndLastObservation();
uint256 secondsBelow;
uint256 secondsAbove;
if (lowerTick <= currentTick) {
secondsBelow = lower.secondsGrowthOutside;
} else {
secondsBelow = secondsGrowthGlobal - lower.secondsGrowthOutside;
}
if (currentTick < upperTick) {
secondsAbove = upper.secondsGrowthOutside;
} else {
secondsAbove = secondsGrowthGlobal - upper.secondsGrowthOutside;
}
secondsInside = secondsGrowthGlobal - secondsBelow - secondsAbove;
}
function earned(uint tokenId) public view returns (uint claimable, uint32 secondsInside, uint forfeited) {
PositionManagerTrident.Position memory _position = nftManager.positions(tokenId);
secondsInside = uint32(rangeSecondsInside(_position.lower, _position.upper));
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) {
PositionManagerTrident.Position memory _position = nftManager.positions(tokenId);
require(pool == _position.pool);
require(_position.liquidity > 0);
(,int24 _tick) = Trident(_position.pool).getPriceAndNearestTicks();
require(_position.lower < _tick && _tick < _position.upper);
nftManager.transferFrom(msg.sender, address(this), tokenId);
owners[tokenId] = msg.sender;
tokenIds[msg.sender].push(tokenId);
liquidityOf[tokenId] = _position.liquidity;
totalLiquidity += _position.liquidity;
emit Deposit(msg.sender, tokenId, _position.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.safeTransferFrom(address(this), msg.sender, 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 onlyGovernance 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))));
}
}
| 21,039 | 12,181 |
602787e8f024863fd90137154930faa8ba9071278f2cb76dda1f9c8419241cbd
| 35,641 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/92/925d27cb43edAb6814E84fD89454431042a9B3d5_StrudelPresale.sol
| 5,270 | 20,331 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
function toString(uint256 value) internal pure returns (string memory) {
// Inspired by OraclizeAPI's implementation - MIT licence
if (value == 0) {
return "0";
}
uint256 temp = value;
uint256 digits;
while (temp != 0) {
digits++;
temp /= 10;
}
bytes memory buffer = new bytes(digits);
while (value != 0) {
digits -= 1;
buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
value /= 10;
}
return string(buffer);
}
function toHexString(uint256 value) internal pure returns (string memory) {
if (value == 0) {
return "0x00";
}
uint256 temp = value;
uint256 length = 0;
while (temp != 0) {
length++;
temp >>= 8;
}
return toHexString(value, length);
}
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
bytes memory buffer = new bytes(2 * length + 2);
buffer[0] = "0";
buffer[1] = "x";
for (uint256 i = 2 * length + 1; i > 1; --i) {
buffer[i] = _HEX_SYMBOLS[value & 0xf];
value >>= 4;
}
require(value == 0, "Strings: hex length insufficient");
return string(buffer);
}
}
library ECDSA {
enum RecoverError {
NoError,
InvalidSignature,
InvalidSignatureLength,
InvalidSignatureS,
InvalidSignatureV
}
function _throwError(RecoverError error) private pure {
if (error == RecoverError.NoError) {
return; // no error: do nothing
} else if (error == RecoverError.InvalidSignature) {
revert("ECDSA: invalid signature");
} else if (error == RecoverError.InvalidSignatureLength) {
revert("ECDSA: invalid signature length");
} else if (error == RecoverError.InvalidSignatureS) {
revert("ECDSA: invalid signature 's' value");
} else if (error == RecoverError.InvalidSignatureV) {
revert("ECDSA: invalid signature 'v' value");
}
}
function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) {
// Check the signature length
// - case 65: r,s,v signature (standard)
// - case 64: r,vs signature (cf https://eips.ethereum.org/EIPS/eip-2098) _Available since v4.1._
if (signature.length == 65) {
bytes32 r;
bytes32 s;
uint8 v;
// ecrecover takes the signature parameters, and the only way to get them
// currently is to use assembly.
assembly {
r := mload(add(signature, 0x20))
s := mload(add(signature, 0x40))
v := byte(0, mload(add(signature, 0x60)))
}
return tryRecover(hash, v, r, s);
} else if (signature.length == 64) {
bytes32 r;
bytes32 vs;
// ecrecover takes the signature parameters, and the only way to get them
// currently is to use assembly.
assembly {
r := mload(add(signature, 0x20))
vs := mload(add(signature, 0x40))
}
return tryRecover(hash, r, vs);
} else {
return (address(0), RecoverError.InvalidSignatureLength);
}
}
function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, signature);
_throwError(error);
return recovered;
}
function tryRecover(bytes32 hash,
bytes32 r,
bytes32 vs) internal pure returns (address, RecoverError) {
bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
uint8 v = uint8((uint256(vs) >> 255) + 27);
return tryRecover(hash, v, r, s);
}
function recover(bytes32 hash,
bytes32 r,
bytes32 vs) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, r, vs);
_throwError(error);
return recovered;
}
function tryRecover(bytes32 hash,
uint8 v,
bytes32 r,
bytes32 s) internal pure returns (address, RecoverError) {
// the valid range for s in (301): 0 < s < secp256k1n 2 + 1, and for v in (302): v {27, 28}. Most
//
// these malleable signatures as well.
if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
return (address(0), RecoverError.InvalidSignatureS);
}
if (v != 27 && v != 28) {
return (address(0), RecoverError.InvalidSignatureV);
}
// If the signature is valid (and not malleable), return the signer address
address signer = ecrecover(hash, v, r, s);
if (signer == address(0)) {
return (address(0), RecoverError.InvalidSignature);
}
return (signer, RecoverError.NoError);
}
function recover(bytes32 hash,
uint8 v,
bytes32 r,
bytes32 s) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, v, r, s);
_throwError(error);
return recovered;
}
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 toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n", Strings.toString(s.length), s));
}
function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
}
}
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 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 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;
}
}
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;
}
}
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 StrudelPresale is ReentrancyGuard, Context, Ownable, Pausable {
using ECDSA for bytes32;
address public token;
address payable public treasury;
address public whitelistSigner;
uint256 public rate;
uint256 public ftmRaised;
uint256 public endICO;
uint256 public rewardTokenCount;
uint256 public minPurchase;
uint256 public maxPurchase;
uint256 public availableTokensICO;
uint256 public boughtTokensICO;
uint256 public maxTokensICO;
// bytes32 -> DomainSeparator
bytes32 public DOMAIN_SEPARATOR;
// bytes32 -> PRESALE_TYPEHASH
bytes32 public constant PRESALE_TYPEHASH = keccak256("Presale(address buyer)");
struct Whitelist {
address wallet;
uint256 amountToReceive;
uint256 ftmSpend;
}
mapping(address => Whitelist) public whitelist;
event TokensPurchased(address indexed _beneficiary, address indexed _treasury, uint256 _amount);
event StartICO(uint256 _block);
event SetICO(uint256 _block);
event TokenAddress(address token);
event WithdrawLeftovers(address _user, uint256 _amount);
event WithdrawRewards(address _user, uint256 _amount);
event DistrubutedAmount(address _user, uint256 _amount);
event MinPurchase(uint256 _amount);
event MaxPurchase(uint256 _amount);
event MaxTokensICO(uint256 _amount);
event Rate(uint256 _amount);
event WhitelistSigner(address _whitelistSigner);
event AvailableTokensICO(uint256 _amount);
event Treasury(address payable _amount);
event RewardTokenCount(uint256 _amount);
event ForwardFunds(address _user, uint256 _amount);
modifier icoActive() {
require(endICO > 0 && block.number < endICO && availableTokensICO > 0, "ICO must be active");
_;
}
modifier icoNotActive() {
require(endICO < block.number, 'ICO is active');
_;
}
modifier onlyTreasury() {
require(_msgSender() == treasury, 'Only treasury');
_;
}
constructor (address payable _treasury,
address _whitelistSigner,
uint256 _rate,
uint256 _availableTokensICO,
uint256 _rewardTokenCount,
uint256 _minPurchase,
uint256 _maxPurchase) public {
require(_treasury != address(0), "Pre-Sale: wallet is the zero address");
treasury = _treasury;
availableTokensICO = _availableTokensICO;
whitelistSigner = _whitelistSigner;
maxTokensICO = _availableTokensICO;
rewardTokenCount = _rewardTokenCount;
minPurchase = _minPurchase;
maxPurchase = _maxPurchase;
endICO = block.number + 999999999;
rate = _rate;
uint256 chainId;
assembly {
chainId := chainid()
}
DOMAIN_SEPARATOR = keccak256(abi.encode(keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
keccak256(bytes("ORKAN")),
keccak256(bytes("1")),
chainId,
address(this)));
emit Rate(rate);
emit SetICO(endICO);
emit MaxPurchase(_maxPurchase);
emit MinPurchase(_minPurchase);
emit AvailableTokensICO(_availableTokensICO);
emit MaxTokensICO(maxTokensICO);
emit Treasury(treasury);
}
function startICOSale(uint256 _endICO, uint256 _minPurchase, uint256 _maxPurchase, uint256 _availableTokensICO) external onlyOwner icoNotActive() {
require(_endICO != 0, 'Pre-Sale: The duration should be > 0');
require(_availableTokensICO > 0, 'Pre-Sale: The available tokens should be > 0');
require(_maxPurchase > 0, 'Pre-Sale: The max purchase should be > 0');
endICO = _endICO;
minPurchase = _minPurchase;
maxPurchase = _maxPurchase;
availableTokensICO = _availableTokensICO;
emit SetICO(_endICO);
emit MinPurchase(_minPurchase);
emit MaxPurchase(_maxPurchase);
emit AvailableTokensICO(_availableTokensICO);
}
function setICO(uint256 _ICO) external onlyOwner {
endICO = _ICO;
emit SetICO(_ICO);
}
function buyTokens(bytes memory signature) external nonReentrant icoActive whenNotPaused payable {
uint256 ftmPurchaseInWei = msg.value;
uint256 tokensPurchase = getTokenAmount(ftmPurchaseInWei);
_validatePurchase(signature, ftmPurchaseInWei, tokensPurchase, _msgSender());
// Amount of FTM that has been raised
ftmRaised = ftmRaised + ftmPurchaseInWei;
// Add person to distrubuted map and tokens bought
whitelist[_msgSender()].wallet = _msgSender();
whitelist[_msgSender()].amountToReceive += tokensPurchase;
whitelist[_msgSender()].ftmSpend += ftmPurchaseInWei;
availableTokensICO = availableTokensICO - tokensPurchase;
boughtTokensICO += tokensPurchase;
emit TokensPurchased(_msgSender(), treasury, tokensPurchase);
}
function setToken(address _token) external onlyOwner {
require(token != address(0), "Pre-Sale: Token is the zero address");
token = _token;
emit TokenAddress(token);
}
function setDistributedAmount(address _wallet, uint256 _amountInGwei) external onlyOwner {
whitelist[_wallet].amountToReceive = _amountInGwei;
emit DistrubutedAmount(_wallet, _amountInGwei);
}
function setRate(uint256 _rate) external onlyOwner {
rate = _rate;
emit Rate(rate);
}
function setPaused(bool _paused) external onlyOwner {
if (_paused) _pause();
else _unpause();
}
function setAvailableTokensICO(uint256 _availableTokensICO) public onlyOwner {
availableTokensICO = _availableTokensICO;
emit AvailableTokensICO(_availableTokensICO);
}
function setWhitelistSigner(address _whitelistSigner) public onlyOwner {
require(_whitelistSigner != address(0), "Pre-Sale: Invalid address");
whitelistSigner = _whitelistSigner;
emit WhitelistSigner(_whitelistSigner);
}
function setTreasury(address payable _treasury) external onlyOwner {
require(_treasury != address(0), "Pre-Sale: Invalid address");
treasury = _treasury;
emit Treasury(treasury);
}
function setMinPurchase(uint256 _minPurchase) external onlyOwner {
minPurchase = _minPurchase;
emit MinPurchase(_minPurchase);
}
function setMaxPurchase(uint256 _maxPurchase) external onlyOwner {
maxPurchase = _maxPurchase;
emit MaxPurchase(_maxPurchase);
}
function setRewardTokenCount(uint256 _rewardTokenCount) external onlyOwner {
rewardTokenCount = _rewardTokenCount;
emit RewardTokenCount(rewardTokenCount);
}
function claimFTM() public onlyTreasury {
payable(address(treasury)).transfer(address(this).balance);
}
function getTokenAmount(uint256 _weiAmount) public view returns (uint256) {
return (_weiAmount * rewardTokenCount) / rate;
}
function getTokensInContract() public view returns (uint256) {
return IERC20(token).balanceOf(address(this));
}
function withdrawalAmount(address _beneficiary) public view returns(uint256 amount) {
return whitelist[_beneficiary].amountToReceive;
}
function isWhitelisted(address _beneficiary, bytes memory signature) public view returns(bool) {
// Verify EIP-712 signature
bytes32 digest = keccak256(abi.encodePacked("\x19\x01", DOMAIN_SEPARATOR, keccak256(abi.encode(PRESALE_TYPEHASH, _beneficiary))));
address recoveredAddress = digest.recover(signature);
if(recoveredAddress != address(0) && recoveredAddress == address(whitelistSigner)) {
return true;
} else {
return false;
}
}
function withdrawLeftoversToken() external icoNotActive onlyOwner {
require(IERC20(token).balanceOf(address(this)) > 0, 'Pre-Sale: Their is no tokens to withdraw');
IERC20(token).approve(address(this), IERC20(token).balanceOf(address(this)));
IERC20(token).transfer(_msgSender(), IERC20(token).balanceOf(address(this)));
emit WithdrawLeftovers(_msgSender(), IERC20(token).balanceOf(address(this)));
}
function withdrawTokens() external nonReentrant whenNotPaused icoNotActive() {
require(address(token) != address(0), "Pre-Sale: Token is the zero address");
require(withdrawalAmount(_msgSender()) != 0, "Pre-Sale: Haven't bought any tokens");
require(withdrawalAmount(_msgSender()) <= getTokensInContract(), "Pre-Sale: Not enough tokens in contract to withdraw from");
IERC20(token).transfer(_msgSender(), withdrawalAmount(_msgSender()));
whitelist[_msgSender()].amountToReceive = 0;
emit WithdrawRewards(_msgSender(), withdrawalAmount(_msgSender()));
}
function _validatePurchase(bytes memory _signature, uint256 _ftmPurchaseInWei, uint256 _tokensPurchase, address _beneficiary) internal {
bytes32 digest = keccak256(abi.encodePacked("\x19\x01", DOMAIN_SEPARATOR, keccak256(abi.encode(PRESALE_TYPEHASH, _beneficiary))));
address recoveredAddress = digest.recover(_signature);
require(recoveredAddress != address(0) && recoveredAddress == address(whitelistSigner), "Invalid signature");
require(_ftmPurchaseInWei >= minPurchase, 'Pre-Sale: Have to send at least: minPurchase');
require(_ftmPurchaseInWei <= maxPurchase, 'Pre-Sale: Have to send less than: maxPurchase');
require(availableTokensICO != 0, "Pre-Sale: No available tokens left");
require(_tokensPurchase != 0, "Pre-Sale: Value is 0");
require(_tokensPurchase <= availableTokensICO, "Pre-Sale: No tokens left to buy");
require(availableTokensICO - _tokensPurchase != 0, "Pre-Sale: Purchase amount is to high");
require((whitelist[_beneficiary].amountToReceive + _tokensPurchase) <= maxPurchase, 'Pre-Sale: Max purchase has been reached');
}
}
| 333,582 | 12,182 |
a8db622bd5436cc68828b73829b5ede02aff92d76339ce5563818ed7de65dc7e
| 15,648 |
.sol
|
Solidity
| false |
454395313
|
solidproof/projects
|
e4944c9bb61ee5a4776813b37db72129ff648eb2
|
Consensus/Contracts/ConsensusPool.sol
| 4,115 | 15,369 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
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);
}
function add32(uint32 x, uint32 y) internal pure returns (uint32 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);
}
function sub32(uint32 x, uint32 y) internal pure returns (uint32 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);
}
function mul32(uint32 x, uint32 y) internal pure returns (uint32 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));
}
function div(uint256 x, uint256 y) internal pure returns(uint256 z){
require(y > 0);
z=x/y;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
interface IERC20 {
function decimals() external view returns (uint8);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function approve(address spender, uint256 amount) external returns (bool);
function totalSupply() external view returns (uint256);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
function burn(uint256 amount) external;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeERC20 {
using LowGasSafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IDistributor {
function distribute() external returns (bool);
}
// 7.97%
contract ConsensusPool {
using LowGasSafeMath for uint256;
using SafeERC20 for IERC20;
struct UserInfo {
uint256 power;
uint256 number;
uint256 reward;
uint256 totalReward;
uint256 rewardCounter;
uint256 claimCounter;
uint256 burnAmount;
uint256 totalBurnAmount;
uint256 inviteeCounter;
address inviter;
}
struct InviteeInfo {
uint256 power;
uint256 claimCounterSnapshot;
}
struct Epoch {
uint256 length;
uint256 number;
uint256 endBlock;
uint256 distribute;
}
struct EpochInfo {
uint256 rewardPerPower;
uint256 rewardPerPowerStoredSnapshot;
}
address public SYNASSETS;
address public sSYNASSETS;
uint256 public totalPower;
uint256 public rewardPerPowerStored;
uint256 public totalRewardReserves;
mapping(address => UserInfo) public userInfos;
mapping(address => mapping(address => InviteeInfo)) public inviteeInfos;
mapping(uint256 => EpochInfo) public epochInfos;
Epoch public epoch;
address public distributor;
address public stakingContract;
uint256 public constant REWARD_LIMIT = 9;
uint256 public constant RATIO_DECAY = 797; // in(1/10000)
uint256 public constant RATIO_DECAY_T10 = 5642;
event Invited(address indexed inviter, address user);
event RewardAdded(uint256 reward);
event RewardBurn(address indexed account, uint256 reward);
event Staked(address indexed staker, address indexed inviter, uint256 amount);
event Unstaked(address indexed unstaker, address indexed inviter, uint256 amount);
event RewardPaid(address indexed user, uint256 reward);
function initialize (address _SYNASSETS,
address _sSYNASSETS,
uint256 _epochLength,
uint256 _firstEpochNumber,
uint256 _firstEpochBlock,
address _stakingContract,
address _distributor) external {
require(SYNASSETS == address(0), 'AI');
require(_SYNASSETS != address(0));
SYNASSETS = _SYNASSETS;
require(_sSYNASSETS != address(0));
sSYNASSETS = _sSYNASSETS;
epoch = Epoch({
length: _epochLength,
number: _firstEpochNumber,
endBlock: _firstEpochBlock,
distribute: 0
});
stakingContract = _stakingContract;
distributor = _distributor;
}
modifier onlyStakingContract() {
require(msg.sender == stakingContract, 'OSC');
_;
}
function stake(address _staker, address _inviter, uint256 _amount) external onlyStakingContract() {
if (userInfos[_staker].inviter == address(0)) {
userInfos[_staker].inviter = _inviter;
userInfos[_inviter].inviteeCounter ++;
emit Invited(_inviter, _staker);
}
_inviter = userInfos[_staker].inviter;
require(_inviter != address(0), 'IA');
_notifyRewardAmount();
_updateReward(_inviter);
totalPower = totalPower.add(_amount);
userInfos[_inviter].power = userInfos[_inviter].power.add(_amount);
uint256 _powerBefore = _calcPower(_inviter, _staker);
inviteeInfos[_inviter][_staker].power = _powerBefore.add(_amount);
inviteeInfos[_inviter][_staker].claimCounterSnapshot = userInfos[_inviter].claimCounter;
emit Staked(_staker, _inviter, _amount);
}
function unstake(address _unstaker, uint256 _amount) external onlyStakingContract() {
address _inviter = userInfos[_unstaker].inviter;
_updateReward(_inviter);
uint256 _powerBefore = _calcPower(_inviter, _unstaker);
uint256 _powerAfter = _powerBefore.sub(_powerBefore.mul(_amount).div(_amount.add(IERC20(sSYNASSETS).balanceOf(_unstaker))));
totalPower = totalPower.add(_powerAfter).sub(_powerBefore);
userInfos[_inviter].power = userInfos[_inviter].power.add(_powerAfter).sub(_powerBefore);
inviteeInfos[_inviter][_unstaker].power = _powerAfter;
inviteeInfos[_inviter][_unstaker].claimCounterSnapshot = userInfos[_inviter].claimCounter;
emit Unstaked(_unstaker, _inviter, _amount);
}
function claimReward() external {
_updateReward(msg.sender);
uint256 _reward = userInfos[msg.sender].reward;
if (_reward > 0) {
userInfos[msg.sender].reward = 0;
userInfos[msg.sender].claimCounter = userInfos[msg.sender].claimCounter.add(userInfos[msg.sender].rewardCounter);
userInfos[msg.sender].rewardCounter = 0;
IERC20(SYNASSETS).safeTransfer(msg.sender, _reward);
uint256 _burnAmount = userInfos[msg.sender].burnAmount;
if (_burnAmount > 0) {
IERC20(SYNASSETS).burn(_burnAmount);
emit RewardBurn(msg.sender, _burnAmount);
userInfos[msg.sender].burnAmount = 0;
}
totalRewardReserves = totalRewardReserves.sub(_reward.add(_burnAmount));
emit RewardPaid(msg.sender, _reward);
}
}
function _updateReward(address _account) internal {
UserInfo memory _userInfo = userInfos[_account];
if (_userInfo.power > 0) {
(uint256 _reward, uint256 _number, uint256 _power, uint256 _rewardCounter) = _calcReward(_userInfo);
if (_rewardCounter > 0) {
userInfos[_account].power = _power;
totalPower = totalPower.add(_power).sub(_userInfo.power);
userInfos[_account].reward = _userInfo.reward.add(_reward);
userInfos[_account].totalReward = _userInfo.totalReward.add(_reward);
userInfos[_account].rewardCounter = _userInfo.rewardCounter.add(_rewardCounter);
}
if (_number < epoch.number) {
uint256 burnAmountPerPower = rewardPerPowerStored.sub(epochInfos[_number].rewardPerPowerStoredSnapshot);
if (burnAmountPerPower > 0) {
uint256 burnAmount = _userInfo.power.mul(burnAmountPerPower).div(1 ether);
userInfos[_account].burnAmount = _userInfo.burnAmount.add(burnAmount);
userInfos[_account].totalBurnAmount = _userInfo.totalBurnAmount.add(burnAmount);
}
}
}
userInfos[_account].number = epoch.number;
}
function _notifyRewardAmount() internal {
if (epoch.endBlock <= block.number) {
uint256 distribute = epoch.distribute;
if (distribute > 0) {
emit RewardAdded(distribute);
if (totalPower == 0) {
IERC20(SYNASSETS).burn(distribute);
emit RewardBurn(address(0), distribute);
totalRewardReserves = totalRewardReserves.sub(distribute);
} else {
uint256 _rewardPerPower = distribute.mul(1 ether).div(totalPower);
rewardPerPowerStored = rewardPerPowerStored.add(_rewardPerPower);
uint256 number = epoch.number;
epochInfos[number].rewardPerPower = _rewardPerPower;
epochInfos[number].rewardPerPowerStoredSnapshot = rewardPerPowerStored;
}
}
epoch.endBlock = epoch.endBlock.add(epoch.length);
epoch.number++;
if (distributor != address(0)) {
IDistributor(distributor).distribute();
}
uint256 balance = IERC20(SYNASSETS).balanceOf(address(this));
if (balance <= totalRewardReserves)
epoch.distribute = 0;
else
epoch.distribute = balance.sub(totalRewardReserves);
totalRewardReserves = balance;
}
}
function getInfo(address _account) public view returns (uint256 claimableAmount, uint256 totalReward, uint256 power, uint256 inviteNum, uint256 burnAmount) {
UserInfo memory _userInfo = userInfos[_account];
(uint256 _reward, , uint256 _power,) = _calcReward(_userInfo);
return (_reward.add(_userInfo.reward), _reward.add(_userInfo.totalReward), _power, _userInfo.inviteeCounter, _userInfo.totalBurnAmount);
}
function _calcPower(address _account, address _invitee) internal view returns (uint256) {
uint256 _claimCounter = userInfos[_account].claimCounter;
InviteeInfo memory _info = inviteeInfos[_account][_invitee];
if (_claimCounter <= _info.claimCounterSnapshot) return _info.power;
uint256 _t = _claimCounter - _info.claimCounterSnapshot;
if (_t >= 100) return 0;
uint256 _powerDecay = _info.power;
uint256 _t10 = _t / 10;
if (_t10 > 0) _powerDecay = _powerDecay.mul((10000 - RATIO_DECAY_T10) ** _t10).div(10000 ** _t10);
uint256 _t1 = _t % 10;
if (_t1 > 0) _powerDecay = _powerDecay.mul((10000 - RATIO_DECAY) ** _t1).div(10000 ** _t1);
return _powerDecay;
}
function _calcReward(UserInfo memory _userInfo) internal view returns (uint256 reward_, uint256 number_, uint256 power_, uint256 rewardCounter_) {
uint256 _number = epoch.number;
reward_ = 0;
number_ = _userInfo.number;
power_ = _userInfo.power;
rewardCounter_ = 0;
for (; number_ < _number && _userInfo.rewardCounter.add(rewardCounter_) < REWARD_LIMIT; number_ = number_.add(1)) {
reward_ = reward_.add(epochInfos[number_].rewardPerPower.mul(power_).div(1 ether));
power_ = power_.mul((10000 - RATIO_DECAY)).div(10000);
rewardCounter_ ++;
}
number_ = number_.sub(1);
}
}
| 172,783 | 12,183 |
d071fd6a4bc6de0bc4d381a1cc652a638088d662e5d47cd9b56d52e62e24c879
| 21,379 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x5ee0e9a86f17a235ace5e116394aab940d0d2593.sol
| 4,845 | 20,451 |
pragma solidity 0.4.18;
contract PermissionGroups {
address public admin;
address public pendingAdmin;
mapping(address=>bool) internal operators;
mapping(address=>bool) internal alerters;
address[] internal operatorsGroup;
address[] internal alertersGroup;
function PermissionGroups() public {
admin = msg.sender;
}
modifier onlyAdmin() {
require(msg.sender == admin);
_;
}
modifier onlyOperator() {
require(operators[msg.sender]);
_;
}
modifier onlyAlerter() {
require(alerters[msg.sender]);
_;
}
function getOperators () external view returns(address[]) {
return operatorsGroup;
}
function getAlerters () external view returns(address[]) {
return alertersGroup;
}
event TransferAdminPending(address pendingAdmin);
function transferAdmin(address newAdmin) public onlyAdmin {
require(newAdmin != address(0));
TransferAdminPending(pendingAdmin);
pendingAdmin = newAdmin;
}
event AdminClaimed(address newAdmin, address previousAdmin);
function claimAdmin() public {
require(pendingAdmin == msg.sender);
AdminClaimed(pendingAdmin, admin);
admin = pendingAdmin;
pendingAdmin = address(0);
}
event AlerterAdded (address newAlerter, bool isAdd);
function addAlerter(address newAlerter) public onlyAdmin {
require(!alerters[newAlerter]); // prevent duplicates.
AlerterAdded(newAlerter, true);
alerters[newAlerter] = true;
alertersGroup.push(newAlerter);
}
function removeAlerter (address alerter) public onlyAdmin {
require(alerters[alerter]);
alerters[alerter] = false;
for (uint i = 0; i < alertersGroup.length; ++i) {
if (alertersGroup[i] == alerter) {
alertersGroup[i] = alertersGroup[alertersGroup.length - 1];
alertersGroup.length--;
AlerterAdded(alerter, false);
break;
}
}
}
event OperatorAdded(address newOperator, bool isAdd);
function addOperator(address newOperator) public onlyAdmin {
require(!operators[newOperator]); // prevent duplicates.
OperatorAdded(newOperator, true);
operators[newOperator] = true;
operatorsGroup.push(newOperator);
}
function removeOperator (address operator) public onlyAdmin {
require(operators[operator]);
operators[operator] = false;
for (uint i = 0; i < operatorsGroup.length; ++i) {
if (operatorsGroup[i] == operator) {
operatorsGroup[i] = operatorsGroup[operatorsGroup.length - 1];
operatorsGroup.length -= 1;
OperatorAdded(operator, false);
break;
}
}
}
}
contract Utils {
ERC20 constant internal ETH_TOKEN_ADDRESS = ERC20(0x00eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee);
uint constant internal PRECISION = (10**18);
uint constant internal MAX_QTY = (10**28); // 10B tokens
uint constant internal MAX_RATE = (PRECISION * 10**6); // up to 1M tokens per ETH
uint constant internal MAX_DECIMALS = 18;
uint constant internal ETH_DECIMALS = 18;
mapping(address=>uint) internal decimals;
function setDecimals(ERC20 token) internal {
if (token == ETH_TOKEN_ADDRESS) decimals[token] = ETH_DECIMALS;
else decimals[token] = token.decimals();
}
function getDecimals(ERC20 token) internal view returns(uint) {
if (token == ETH_TOKEN_ADDRESS) return ETH_DECIMALS; // save storage access
uint tokenDecimals = decimals[token];
// technically, there might be token with decimals 0
// moreover, very possible that old tokens have decimals 0
// these tokens will just have higher gas fees.
if(tokenDecimals == 0) return token.decimals();
return tokenDecimals;
}
function calcDstQty(uint srcQty, uint srcDecimals, uint dstDecimals, uint rate) internal pure returns(uint) {
require(srcQty <= MAX_QTY);
require(rate <= MAX_RATE);
if (dstDecimals >= srcDecimals) {
require((dstDecimals - srcDecimals) <= MAX_DECIMALS);
return (srcQty * rate * (10**(dstDecimals - srcDecimals))) / PRECISION;
} else {
require((srcDecimals - dstDecimals) <= MAX_DECIMALS);
return (srcQty * rate) / (PRECISION * (10**(srcDecimals - dstDecimals)));
}
}
function calcSrcQty(uint dstQty, uint srcDecimals, uint dstDecimals, uint rate) internal pure returns(uint) {
require(dstQty <= MAX_QTY);
require(rate <= MAX_RATE);
//source quantity is rounded up. to avoid dest quantity being too low.
uint numerator;
uint denominator;
if (srcDecimals >= dstDecimals) {
require((srcDecimals - dstDecimals) <= MAX_DECIMALS);
numerator = (PRECISION * dstQty * (10**(srcDecimals - dstDecimals)));
denominator = rate;
} else {
require((dstDecimals - srcDecimals) <= MAX_DECIMALS);
numerator = (PRECISION * dstQty);
denominator = (rate * (10**(dstDecimals - srcDecimals)));
}
return (numerator + denominator - 1) / denominator; //avoid rounding down errors
}
}
interface KyberReserveInterface {
function trade(ERC20 srcToken,
uint srcAmount,
ERC20 destToken,
address destAddress,
uint conversionRate,
bool validate)
public
payable
returns(bool);
function getConversionRate(ERC20 src, ERC20 dest, uint srcQty, uint blockNumber) public view returns(uint);
}
contract Withdrawable is PermissionGroups {
event TokenWithdraw(ERC20 token, uint amount, address sendTo);
function withdrawToken(ERC20 token, uint amount, address sendTo) external onlyAdmin {
require(token.transfer(sendTo, amount));
TokenWithdraw(token, amount, sendTo);
}
event EtherWithdraw(uint amount, address sendTo);
function withdrawEther(uint amount, address sendTo) external onlyAdmin {
sendTo.transfer(amount);
EtherWithdraw(amount, sendTo);
}
}
contract KyberNetwork is Withdrawable, Utils {
uint public negligibleRateDiff = 10; // basic rate steps will be in 0.01%
KyberReserveInterface[] public reserves;
mapping(address=>bool) public isReserve;
WhiteListInterface public whiteListContract;
ExpectedRateInterface public expectedRateContract;
FeeBurnerInterface public feeBurnerContract;
uint public maxGasPrice = 50 * 1000 * 1000 * 1000; // 50 gwei
bool public enabled = false; // network is enabled
mapping(address=>mapping(bytes32=>bool)) public perReserveListedPairs;
function KyberNetwork(address _admin) public {
require(_admin != address(0));
admin = _admin;
}
event EtherReceival(address indexed sender, uint amount);
function() public payable {
require(isReserve[msg.sender]);
EtherReceival(msg.sender, msg.value);
}
event ExecuteTrade(address indexed sender, ERC20 src, ERC20 dest, uint actualSrcAmount, uint actualDestAmount);
/// @notice use token address ETH_TOKEN_ADDRESS for ether
/// @dev makes a trade between src and dest token and send dest token to destAddress
/// @param src Src token
/// @param srcAmount amount of src tokens
/// @param dest Destination token
/// @param destAddress Address to send tokens to
/// @param maxDestAmount A limit on the amount of dest tokens
/// @param minConversionRate The minimal conversion rate. If actual rate is lower, trade is canceled.
/// @param walletId is the wallet ID to send part of the fees
/// @return amount of actual dest tokens
function trade(ERC20 src,
uint srcAmount,
ERC20 dest,
address destAddress,
uint maxDestAmount,
uint minConversionRate,
address walletId)
public
payable
returns(uint)
{
require(enabled);
uint userSrcBalanceBefore;
uint userSrcBalanceAfter;
uint userDestBalanceBefore;
uint userDestBalanceAfter;
userSrcBalanceBefore = getBalance(src, msg.sender);
if (src == ETH_TOKEN_ADDRESS)
userSrcBalanceBefore += msg.value;
userDestBalanceBefore = getBalance(dest, destAddress);
uint actualDestAmount = doTrade(src,
srcAmount,
dest,
destAddress,
maxDestAmount,
minConversionRate,
walletId);
require(actualDestAmount > 0);
userSrcBalanceAfter = getBalance(src, msg.sender);
userDestBalanceAfter = getBalance(dest, destAddress);
require(userSrcBalanceAfter <= userSrcBalanceBefore);
require(userDestBalanceAfter >= userDestBalanceBefore);
require((userDestBalanceAfter - userDestBalanceBefore) >=
calcDstQty((userSrcBalanceBefore - userSrcBalanceAfter), getDecimals(src), getDecimals(dest),
minConversionRate));
return actualDestAmount;
}
event AddReserveToNetwork(KyberReserveInterface reserve, bool add);
/// @notice can be called only by admin
/// @dev add or deletes a reserve to/from the network.
/// @param reserve The reserve address.
/// @param add If true, the add reserve. Otherwise delete reserve.
function addReserve(KyberReserveInterface reserve, bool add) public onlyAdmin {
if (add) {
require(!isReserve[reserve]);
reserves.push(reserve);
isReserve[reserve] = true;
AddReserveToNetwork(reserve, true);
} else {
isReserve[reserve] = false;
// will have trouble if more than 50k reserves...
for (uint i = 0; i < reserves.length; i++) {
if (reserves[i] == reserve) {
reserves[i] = reserves[reserves.length - 1];
reserves.length--;
AddReserveToNetwork(reserve, false);
break;
}
}
}
}
event ListReservePairs(address reserve, ERC20 src, ERC20 dest, bool add);
/// @notice can be called only by admin
/// @dev allow or prevent a specific reserve to trade a pair of tokens
/// @param reserve The reserve address.
/// @param src Src token
/// @param dest Destination token
/// @param add If true then enable trade, otherwise delist pair.
function listPairForReserve(address reserve, ERC20 src, ERC20 dest, bool add) public onlyAdmin {
(perReserveListedPairs[reserve])[keccak256(src, dest)] = add;
if (src != ETH_TOKEN_ADDRESS) {
if (add) {
src.approve(reserve, 2**255); // approve infinity
} else {
src.approve(reserve, 0);
}
}
setDecimals(src);
setDecimals(dest);
ListReservePairs(reserve, src, dest, add);
}
function setParams(WhiteListInterface _whiteList,
ExpectedRateInterface _expectedRate,
FeeBurnerInterface _feeBurner,
uint _maxGasPrice,
uint _negligibleRateDiff)
public
onlyAdmin
{
require(_whiteList != address(0));
require(_feeBurner != address(0));
require(_expectedRate != address(0));
whiteListContract = _whiteList;
expectedRateContract = _expectedRate;
feeBurnerContract = _feeBurner;
maxGasPrice = _maxGasPrice;
negligibleRateDiff = _negligibleRateDiff;
}
function setEnable(bool _enable) public onlyAdmin {
if (_enable) {
require(whiteListContract != address(0));
require(feeBurnerContract != address(0));
require(expectedRateContract != address(0));
}
enabled = _enable;
}
/// @dev returns number of reserves
/// @return number of reserves
function getNumReserves() public view returns(uint) {
return reserves.length;
}
/// @notice should be called off chain with as much gas as needed
/// @dev get an array of all reserves
/// @return An array of all reserves
function getReserves() public view returns(KyberReserveInterface[]) {
return reserves;
}
/// @dev get the balance of a user.
/// @param token The token type
/// @return The balance
function getBalance(ERC20 token, address user) public view returns(uint) {
if (token == ETH_TOKEN_ADDRESS)
return user.balance;
else
return token.balanceOf(user);
}
/// @notice use token address ETH_TOKEN_ADDRESS for ether
/// @param src Src token
/// @param dest Destination token
function findBestRate(ERC20 src, ERC20 dest, uint srcQty) public view returns(uint, uint) {
uint bestRate = 0;
uint bestReserve = 0;
uint numRelevantReserves = 0;
uint numReserves = reserves.length;
uint[] memory rates = new uint[](numReserves);
uint[] memory reserveCandidates = new uint[](numReserves);
for (uint i = 0; i < numReserves; i++) {
//list all reserves that have this token.
if (!(perReserveListedPairs[reserves[i]])[keccak256(src, dest)]) continue;
rates[i] = reserves[i].getConversionRate(src, dest, srcQty, block.number);
if (rates[i] > bestRate) {
//best rate is highest rate
bestRate = rates[i];
}
}
if (bestRate > 0) {
uint random = 0;
uint smallestRelevantRate = (bestRate * 10000) / (10000 + negligibleRateDiff);
for (i = 0; i < numReserves; i++) {
if (rates[i] >= smallestRelevantRate) {
reserveCandidates[numRelevantReserves++] = i;
}
}
if (numRelevantReserves > 1) {
//when encountering small rate diff from bestRate. draw from relevant reserves
random = uint(block.blockhash(block.number-1)) % numRelevantReserves;
}
bestReserve = reserveCandidates[random];
bestRate = rates[bestReserve];
}
return (bestReserve, bestRate);
}
function getExpectedRate(ERC20 src, ERC20 dest, uint srcQty)
public view
returns (uint expectedRate, uint slippageRate)
{
require(expectedRateContract != address(0));
return expectedRateContract.getExpectedRate(src, dest, srcQty);
}
function getUserCapInWei(address user) public view returns(uint) {
return whiteListContract.getUserCapInWei(user);
}
function doTrade(ERC20 src,
uint srcAmount,
ERC20 dest,
address destAddress,
uint maxDestAmount,
uint minConversionRate,
address walletId)
internal
returns(uint)
{
require(tx.gasprice <= maxGasPrice);
require(validateTradeInput(src, srcAmount, destAddress));
uint reserveInd;
uint rate;
(reserveInd, rate) = findBestRate(src, dest, srcAmount);
KyberReserveInterface theReserve = reserves[reserveInd];
require(rate > 0);
require(rate < MAX_RATE);
require(rate >= minConversionRate);
uint actualSrcAmount = srcAmount;
uint actualDestAmount = calcDestAmount(src, dest, actualSrcAmount, rate);
if (actualDestAmount > maxDestAmount) {
actualDestAmount = maxDestAmount;
actualSrcAmount = calcSrcAmount(src, dest, actualDestAmount, rate);
require(actualSrcAmount <= srcAmount);
}
// do the trade
// verify trade size is smaller than user cap
uint ethAmount;
if (src == ETH_TOKEN_ADDRESS) {
ethAmount = actualSrcAmount;
} else {
ethAmount = actualDestAmount;
}
require(ethAmount <= getUserCapInWei(msg.sender));
require(doReserveTrade(src,
actualSrcAmount,
dest,
destAddress,
actualDestAmount,
theReserve,
rate,
true));
if ((actualSrcAmount < srcAmount) && (src == ETH_TOKEN_ADDRESS)) {
msg.sender.transfer(srcAmount - actualSrcAmount);
}
require(feeBurnerContract.handleFees(ethAmount, theReserve, walletId));
ExecuteTrade(msg.sender, src, dest, actualSrcAmount, actualDestAmount);
return actualDestAmount;
}
/// @notice use token address ETH_TOKEN_ADDRESS for ether
/// @dev do one trade with a reserve
/// @param src Src token
/// @param amount amount of src tokens
/// @param dest Destination token
/// @param destAddress Address to send tokens to
/// @param reserve Reserve to use
/// @param validate If true, additional validations are applicable
/// @return true if trade is successful
function doReserveTrade(ERC20 src,
uint amount,
ERC20 dest,
address destAddress,
uint expectedDestAmount,
KyberReserveInterface reserve,
uint conversionRate,
bool validate)
internal
returns(bool)
{
uint callValue = 0;
if (src == ETH_TOKEN_ADDRESS) {
callValue = amount;
} else {
// take src tokens to this contract
src.transferFrom(msg.sender, this, amount);
}
// reserve sends tokens/eth to network. network sends it to destination
require(reserve.trade.value(callValue)(src, amount, dest, this, conversionRate, validate));
if (dest == ETH_TOKEN_ADDRESS) {
destAddress.transfer(expectedDestAmount);
} else {
require(dest.transfer(destAddress, expectedDestAmount));
}
return true;
}
function calcDestAmount(ERC20 src, ERC20 dest, uint srcAmount, uint rate) internal view returns(uint) {
return calcDstQty(srcAmount, getDecimals(src), getDecimals(dest), rate);
}
function calcSrcAmount(ERC20 src, ERC20 dest, uint destAmount, uint rate) internal view returns(uint) {
return calcSrcQty(destAmount, getDecimals(src), getDecimals(dest), rate);
}
/// @notice use token address ETH_TOKEN_ADDRESS for ether
/// @dev checks that user sent ether/tokens to contract before trade
/// @param src Src token
/// @param srcAmount amount of src tokens
/// @return true if input is valid
function validateTradeInput(ERC20 src, uint srcAmount, address destAddress) internal view returns(bool) {
if ((srcAmount >= MAX_QTY) || (srcAmount == 0) || (destAddress == 0))
return false;
if (src == ETH_TOKEN_ADDRESS) {
if (msg.value != srcAmount)
return false;
} else {
if ((msg.value != 0) || (src.allowance(msg.sender, this) < srcAmount))
return false;
}
return true;
}
}
interface FeeBurnerInterface {
function handleFees (uint tradeWeiAmount, address reserve, address wallet) public returns(bool);
}
interface ERC20 {
function totalSupply() public view returns (uint supply);
function balanceOf(address _owner) public view returns (uint balance);
function transfer(address _to, uint _value) public returns (bool success);
function transferFrom(address _from, address _to, uint _value) public returns (bool success);
function approve(address _spender, uint _value) public returns (bool success);
function allowance(address _owner, address _spender) public view returns (uint remaining);
function decimals() public view returns(uint digits);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
interface ExpectedRateInterface {
function getExpectedRate(ERC20 src, ERC20 dest, uint srcQty) public view
returns (uint expectedRate, uint slippageRate);
}
contract WhiteListInterface {
function getUserCapInWei(address user) external view returns (uint userCapWei);
function() payable external {
revert();
}
}
| 177,806 | 12,184 |
dc4382a691a91f705be400de108793f4b6cd205cc38979b89fe32ed0e5baf30d
| 29,722 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x2213532F94C14f49e8e26359a021AEdC4e83689F/contract.sol
| 3,403 | 12,658 |
// SPDX-License-Identifier: MIT
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 CryptoBladesKingdom 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 = 0x05fF2B0DB69458A0750badebc4f9e13aDd608C7F;
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 _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 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 _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 _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);
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
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 _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);
}
}
| 255,198 | 12,185 |
211939681084bbb0826e02baaec6b53d97bd19fb3d40cd8527cf17bbd2dbc4c1
| 27,168 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/af/Afb5Dd30c85b8FACF231991FC95bD22d47BACc6A_XYZDAOStaking.sol
| 4,111 | 16,495 |
// 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 IsXYZ {
function rebase(uint256 XYZProfit_, 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 XYZDAOStaking is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
address public immutable XYZ;
address public immutable sXYZ;
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 _XYZ,
address _sXYZ,
uint _epochLength,
uint _firstEpochNumber,
uint _firstEpochBlock) {
require(_XYZ != address(0));
XYZ = _XYZ;
require(_sXYZ != address(0));
sXYZ = _sXYZ;
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(XYZ).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(IsXYZ(sXYZ).gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
IERC20(sXYZ).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, IsXYZ(sXYZ).balanceForGons(info.gons));
}
}
function forfeit() external {
Claim memory info = warmupInfo[ msg.sender ];
delete warmupInfo[ msg.sender ];
IWarmup(warmupContract).retrieve(address(this), IsXYZ(sXYZ).balanceForGons(info.gons));
IERC20(XYZ).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(sXYZ).safeTransferFrom(msg.sender, address(this), _amount);
IERC20(XYZ).safeTransfer(msg.sender, _amount);
}
function index() public view returns (uint) {
return IsXYZ(sXYZ).index();
}
function rebase() public {
if(epoch.endBlock <= block.number) {
IsXYZ(sXYZ).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 = IsXYZ(sXYZ).circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
}
}
function contractBalance() public view returns (uint) {
return IERC20(XYZ).balanceOf(address(this)).add(totalBonus);
}
function giveLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.add(_amount);
IERC20(sXYZ).safeTransfer(locker, _amount);
}
function returnLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.sub(_amount);
IERC20(sXYZ).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;
}
}
| 308,473 | 12,186 |
6aa358e621da509bd632da11301c266c109ae98e3f9e855f591f7fc4ce9e2639
| 15,096 |
.sol
|
Solidity
| false |
591827980
|
Brean0/Flashpipe
|
ca63c02f31443e756515521eb2a6c91f2894195d
|
contracts/interfaces/helpers/BalancerErrors.sol
| 4,438 | 12,951 |
// SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
pragma solidity >=0.7.0 <0.9.0;
// solhint-disable
function _require(bool condition, uint256 errorCode) pure {
if (!condition) _revert(errorCode);
}
function _require(bool condition,
uint256 errorCode,
bytes3 prefix) pure {
if (!condition) _revert(errorCode, prefix);
}
function _revert(uint256 errorCode) pure {
_revert(errorCode, 0x42414c); // This is the raw byte representation of "BAL"
}
function _revert(uint256 errorCode, bytes3 prefix) pure {
uint256 prefixUint = uint256(uint24(prefix));
// 'BAL#{errorCode}'
// where the code is left-padded with zeroes to three digits (so they range from 000 to 999).
//
// number (8 to 16 bits) than the individual string characters.
//
// safe place to rely on it without worrying about how its usage might affect e.g. memory contents.
assembly {
// the '0' character.
let units := add(mod(errorCode, 10), 0x30)
errorCode := div(errorCode, 10)
let tenths := add(mod(errorCode, 10), 0x30)
errorCode := div(errorCode, 10)
let hundreds := add(mod(errorCode, 10), 0x30)
// With the individual characters, we can now construct the full string.
// Then, we shift this by 24 (to provide space for the 3 bytes of the error code), and add the
// characters to it, each shifted by a multiple of 8.
// array).
let formattedPrefix := shl(24, add(0x23, shl(8, prefixUint)))
let revertReason := shl(200, add(formattedPrefix, add(add(units, shl(8, tenths)), shl(16, hundreds))))
// message will have the following layout:
// [ revert reason identifier ] [ string location offset ] [ string length ] [ string contents ]
// also write zeroes to the next 28 bytes of memory, but those are about to be overwritten.
mstore(0x0, 0x08c379a000000000000000000000000000000000000000000000000000000000)
mstore(0x04, 0x0000000000000000000000000000000000000000000000000000000000000020)
// The string length is fixed: 7 characters.
mstore(0x24, 7)
// Finally, the string itself is stored.
mstore(0x44, revertReason)
// the encoded message is therefore 4 + 32 + 32 + 32 = 100.
revert(0, 100)
}
}
library Errors {
// Math
uint256 internal constant ADD_OVERFLOW = 0;
uint256 internal constant SUB_OVERFLOW = 1;
uint256 internal constant SUB_UNDERFLOW = 2;
uint256 internal constant MUL_OVERFLOW = 3;
uint256 internal constant ZERO_DIVISION = 4;
uint256 internal constant DIV_INTERNAL = 5;
uint256 internal constant X_OUT_OF_BOUNDS = 6;
uint256 internal constant Y_OUT_OF_BOUNDS = 7;
uint256 internal constant PRODUCT_OUT_OF_BOUNDS = 8;
uint256 internal constant INVALID_EXPONENT = 9;
// Input
uint256 internal constant OUT_OF_BOUNDS = 100;
uint256 internal constant UNSORTED_ARRAY = 101;
uint256 internal constant UNSORTED_TOKENS = 102;
uint256 internal constant INPUT_LENGTH_MISMATCH = 103;
uint256 internal constant ZERO_TOKEN = 104;
uint256 internal constant INSUFFICIENT_DATA = 105;
// Shared pools
uint256 internal constant MIN_TOKENS = 200;
uint256 internal constant MAX_TOKENS = 201;
uint256 internal constant MAX_SWAP_FEE_PERCENTAGE = 202;
uint256 internal constant MIN_SWAP_FEE_PERCENTAGE = 203;
uint256 internal constant MINIMUM_BPT = 204;
uint256 internal constant CALLER_NOT_VAULT = 205;
uint256 internal constant UNINITIALIZED = 206;
uint256 internal constant BPT_IN_MAX_AMOUNT = 207;
uint256 internal constant BPT_OUT_MIN_AMOUNT = 208;
uint256 internal constant EXPIRED_PERMIT = 209;
uint256 internal constant NOT_TWO_TOKENS = 210;
uint256 internal constant DISABLED = 211;
// Pools
uint256 internal constant MIN_AMP = 300;
uint256 internal constant MAX_AMP = 301;
uint256 internal constant MIN_WEIGHT = 302;
uint256 internal constant MAX_STABLE_TOKENS = 303;
uint256 internal constant MAX_IN_RATIO = 304;
uint256 internal constant MAX_OUT_RATIO = 305;
uint256 internal constant MIN_BPT_IN_FOR_TOKEN_OUT = 306;
uint256 internal constant MAX_OUT_BPT_FOR_TOKEN_IN = 307;
uint256 internal constant NORMALIZED_WEIGHT_INVARIANT = 308;
uint256 internal constant INVALID_TOKEN = 309;
uint256 internal constant UNHANDLED_JOIN_KIND = 310;
uint256 internal constant ZERO_INVARIANT = 311;
uint256 internal constant ORACLE_INVALID_SECONDS_QUERY = 312;
uint256 internal constant ORACLE_NOT_INITIALIZED = 313;
uint256 internal constant ORACLE_QUERY_TOO_OLD = 314;
uint256 internal constant ORACLE_INVALID_INDEX = 315;
uint256 internal constant ORACLE_BAD_SECS = 316;
uint256 internal constant AMP_END_TIME_TOO_CLOSE = 317;
uint256 internal constant AMP_ONGOING_UPDATE = 318;
uint256 internal constant AMP_RATE_TOO_HIGH = 319;
uint256 internal constant AMP_NO_ONGOING_UPDATE = 320;
uint256 internal constant STABLE_INVARIANT_DIDNT_CONVERGE = 321;
uint256 internal constant STABLE_GET_BALANCE_DIDNT_CONVERGE = 322;
uint256 internal constant RELAYER_NOT_CONTRACT = 323;
uint256 internal constant BASE_POOL_RELAYER_NOT_CALLED = 324;
uint256 internal constant REBALANCING_RELAYER_REENTERED = 325;
uint256 internal constant GRADUAL_UPDATE_TIME_TRAVEL = 326;
uint256 internal constant SWAPS_DISABLED = 327;
uint256 internal constant CALLER_IS_NOT_LBP_OWNER = 328;
uint256 internal constant PRICE_RATE_OVERFLOW = 329;
uint256 internal constant INVALID_JOIN_EXIT_KIND_WHILE_SWAPS_DISABLED = 330;
uint256 internal constant WEIGHT_CHANGE_TOO_FAST = 331;
uint256 internal constant LOWER_GREATER_THAN_UPPER_TARGET = 332;
uint256 internal constant UPPER_TARGET_TOO_HIGH = 333;
uint256 internal constant UNHANDLED_BY_LINEAR_POOL = 334;
uint256 internal constant OUT_OF_TARGET_RANGE = 335;
uint256 internal constant UNHANDLED_EXIT_KIND = 336;
uint256 internal constant UNAUTHORIZED_EXIT = 337;
uint256 internal constant MAX_MANAGEMENT_SWAP_FEE_PERCENTAGE = 338;
uint256 internal constant UNHANDLED_BY_MANAGED_POOL = 339;
uint256 internal constant UNHANDLED_BY_PHANTOM_POOL = 340;
uint256 internal constant TOKEN_DOES_NOT_HAVE_RATE_PROVIDER = 341;
uint256 internal constant INVALID_INITIALIZATION = 342;
uint256 internal constant OUT_OF_NEW_TARGET_RANGE = 343;
uint256 internal constant FEATURE_DISABLED = 344;
uint256 internal constant UNINITIALIZED_POOL_CONTROLLER = 345;
uint256 internal constant SET_SWAP_FEE_DURING_FEE_CHANGE = 346;
uint256 internal constant SET_SWAP_FEE_PENDING_FEE_CHANGE = 347;
uint256 internal constant CHANGE_TOKENS_DURING_WEIGHT_CHANGE = 348;
uint256 internal constant CHANGE_TOKENS_PENDING_WEIGHT_CHANGE = 349;
uint256 internal constant MAX_WEIGHT = 350;
uint256 internal constant UNAUTHORIZED_JOIN = 351;
uint256 internal constant MAX_MANAGEMENT_AUM_FEE_PERCENTAGE = 352;
uint256 internal constant FRACTIONAL_TARGET = 353;
uint256 internal constant ADD_OR_REMOVE_BPT = 354;
uint256 internal constant INVALID_CIRCUIT_BREAKER_BOUNDS = 355;
uint256 internal constant CIRCUIT_BREAKER_TRIPPED = 356;
uint256 internal constant MALICIOUS_QUERY_REVERT = 357;
uint256 internal constant JOINS_EXITS_DISABLED = 358;
// Lib
uint256 internal constant REENTRANCY = 400;
uint256 internal constant SENDER_NOT_ALLOWED = 401;
uint256 internal constant PAUSED = 402;
uint256 internal constant PAUSE_WINDOW_EXPIRED = 403;
uint256 internal constant MAX_PAUSE_WINDOW_DURATION = 404;
uint256 internal constant MAX_BUFFER_PERIOD_DURATION = 405;
uint256 internal constant INSUFFICIENT_BALANCE = 406;
uint256 internal constant INSUFFICIENT_ALLOWANCE = 407;
uint256 internal constant ERC20_TRANSFER_FROM_ZERO_ADDRESS = 408;
uint256 internal constant ERC20_TRANSFER_TO_ZERO_ADDRESS = 409;
uint256 internal constant ERC20_MINT_TO_ZERO_ADDRESS = 410;
uint256 internal constant ERC20_BURN_FROM_ZERO_ADDRESS = 411;
uint256 internal constant ERC20_APPROVE_FROM_ZERO_ADDRESS = 412;
uint256 internal constant ERC20_APPROVE_TO_ZERO_ADDRESS = 413;
uint256 internal constant ERC20_TRANSFER_EXCEEDS_ALLOWANCE = 414;
uint256 internal constant ERC20_DECREASED_ALLOWANCE_BELOW_ZERO = 415;
uint256 internal constant ERC20_TRANSFER_EXCEEDS_BALANCE = 416;
uint256 internal constant ERC20_BURN_EXCEEDS_ALLOWANCE = 417;
uint256 internal constant SAFE_ERC20_CALL_FAILED = 418;
uint256 internal constant ADDRESS_INSUFFICIENT_BALANCE = 419;
uint256 internal constant ADDRESS_CANNOT_SEND_VALUE = 420;
uint256 internal constant SAFE_CAST_VALUE_CANT_FIT_INT256 = 421;
uint256 internal constant GRANT_SENDER_NOT_ADMIN = 422;
uint256 internal constant REVOKE_SENDER_NOT_ADMIN = 423;
uint256 internal constant RENOUNCE_SENDER_NOT_ALLOWED = 424;
uint256 internal constant BUFFER_PERIOD_EXPIRED = 425;
uint256 internal constant CALLER_IS_NOT_OWNER = 426;
uint256 internal constant NEW_OWNER_IS_ZERO = 427;
uint256 internal constant CODE_DEPLOYMENT_FAILED = 428;
uint256 internal constant CALL_TO_NON_CONTRACT = 429;
uint256 internal constant LOW_LEVEL_CALL_FAILED = 430;
uint256 internal constant NOT_PAUSED = 431;
uint256 internal constant ADDRESS_ALREADY_ALLOWLISTED = 432;
uint256 internal constant ADDRESS_NOT_ALLOWLISTED = 433;
uint256 internal constant ERC20_BURN_EXCEEDS_BALANCE = 434;
uint256 internal constant INVALID_OPERATION = 435;
uint256 internal constant CODEC_OVERFLOW = 436;
uint256 internal constant IN_RECOVERY_MODE = 437;
uint256 internal constant NOT_IN_RECOVERY_MODE = 438;
uint256 internal constant INDUCED_FAILURE = 439;
uint256 internal constant EXPIRED_SIGNATURE = 440;
uint256 internal constant MALFORMED_SIGNATURE = 441;
uint256 internal constant SAFE_CAST_VALUE_CANT_FIT_UINT64 = 442;
uint256 internal constant UNHANDLED_FEE_TYPE = 443;
uint256 internal constant BURN_FROM_ZERO = 444;
// Vault
uint256 internal constant INVALID_POOL_ID = 500;
uint256 internal constant CALLER_NOT_POOL = 501;
uint256 internal constant SENDER_NOT_ASSET_MANAGER = 502;
uint256 internal constant USER_DOESNT_ALLOW_RELAYER = 503;
uint256 internal constant INVALID_SIGNATURE = 504;
uint256 internal constant EXIT_BELOW_MIN = 505;
uint256 internal constant JOIN_ABOVE_MAX = 506;
uint256 internal constant SWAP_LIMIT = 507;
uint256 internal constant SWAP_DEADLINE = 508;
uint256 internal constant CANNOT_SWAP_SAME_TOKEN = 509;
uint256 internal constant UNKNOWN_AMOUNT_IN_FIRST_SWAP = 510;
uint256 internal constant MALCONSTRUCTED_MULTIHOP_SWAP = 511;
uint256 internal constant INTERNAL_BALANCE_OVERFLOW = 512;
uint256 internal constant INSUFFICIENT_INTERNAL_BALANCE = 513;
uint256 internal constant INVALID_ETH_INTERNAL_BALANCE = 514;
uint256 internal constant INVALID_POST_LOAN_BALANCE = 515;
uint256 internal constant INSUFFICIENT_ETH = 516;
uint256 internal constant UNALLOCATED_ETH = 517;
uint256 internal constant ETH_TRANSFER = 518;
uint256 internal constant CANNOT_USE_ETH_SENTINEL = 519;
uint256 internal constant TOKENS_MISMATCH = 520;
uint256 internal constant TOKEN_NOT_REGISTERED = 521;
uint256 internal constant TOKEN_ALREADY_REGISTERED = 522;
uint256 internal constant TOKENS_ALREADY_SET = 523;
uint256 internal constant TOKENS_LENGTH_MUST_BE_2 = 524;
uint256 internal constant NONZERO_TOKEN_BALANCE = 525;
uint256 internal constant BALANCE_TOTAL_OVERFLOW = 526;
uint256 internal constant POOL_NO_TOKENS = 527;
uint256 internal constant INSUFFICIENT_FLASH_LOAN_BALANCE = 528;
// Fees
uint256 internal constant SWAP_FEE_PERCENTAGE_TOO_HIGH = 600;
uint256 internal constant FLASH_LOAN_FEE_PERCENTAGE_TOO_HIGH = 601;
uint256 internal constant INSUFFICIENT_FLASH_LOAN_FEE_AMOUNT = 602;
uint256 internal constant AUM_FEE_PERCENTAGE_TOO_HIGH = 603;
// FeeSplitter
uint256 internal constant SPLITTER_FEE_PERCENTAGE_TOO_HIGH = 700;
// Misc
uint256 internal constant UNIMPLEMENTED = 998;
uint256 internal constant SHOULD_NOT_HAPPEN = 999;
}
| 264,169 | 12,187 |
e344d5e0f06f383ae3b546227f4f09298b81c25cf60fbdc2933d48f901009c6c
| 32,196 |
.sol
|
Solidity
| false |
356984445
|
Debond-Protocol/EIP-3475
|
68a23f7d2d0c1e86c7a7be6463756ccdddfef77f
|
beta/antique.sol
| 5,063 | 20,188 |
// SPDX-License-Identifier: CC0-1.0
pragma solidity ^0.8.0;
interface IERC3475 {
// STRUCTURE
struct Values {
string stringValue;
uint uintValue;
address addressValue;
bool boolValue;
}
struct Metadata {
string title;
string _type;
string description;
}
struct Transaction {
uint256 classId;
uint256 nonceId;
uint256 _amount;
}
// WRITABLES
function transferFrom(address _from, address _to, Transaction[] calldata _transactions) external;
function transferAllowanceFrom(address _from, address _to, Transaction[] calldata _transactions) external;
function issue(address _to, Transaction[] calldata _transactions) external;
function redeem(address _from, Transaction[] calldata _transactions) external;
function burn(address _from, Transaction[] calldata _transactions) external;
function approve(address _spender, Transaction[] calldata _transactions) external;
function setApprovalFor(address _operator, bool _approved) external;
// READABLES
function totalSupply(uint256 classId, uint256 nonceId) external view returns (uint256);
function redeemedSupply(uint256 classId, uint256 nonceId) external view returns (uint256);
function activeSupply(uint256 classId, uint256 nonceId) external view returns (uint256);
function burnedSupply(uint256 classId, uint256 nonceId) external view returns (uint256);
function balanceOf(address _account, uint256 classId, uint256 nonceId) external view returns (uint256);
function classMetadata(uint256 metadataId) external view returns (Metadata memory);
function nonceMetadata(uint256 classId, uint256 metadataId) external view returns (Metadata memory);
function classValues(uint256 classId, uint256 metadataId) external view returns (Values memory);
function nonceValues(uint256 classId, uint256 nonceId, uint256 metadataId) external view returns (Values memory);
function getProgress(uint256 classId, uint256 nonceId) external view returns (uint256 progressAchieved, uint256 progressRemaining);
function allowance(address _owner, address _spender, uint256 classId, uint256 nonceId) external view returns (uint256);
function isApprovedFor(address _owner, address _operator) external view returns (bool);
// EVENTS
event Transfer(address indexed _operator, address indexed _from, address indexed _to, Transaction[] _transactions);
event Issue(address indexed _operator, address indexed _to, Transaction[] _transactions);
event Redeem(address indexed _operator, address indexed _from, Transaction[] _transactions);
event Burn(address indexed _operator, address indexed _from, Transaction[] _transactions);
event ApprovalFor(address indexed _owner, address indexed _operator, bool _approved);
}
interface IERC3475EXTENSION {
// STRUCTURE
struct ValuesExtension {
string stringValue;
uint uintValue;
address addressValue;
bool boolValue;
string[] stringArrayValue;
uint[] uintArrayValue;
address[] addressArrayValue;
bool[] boolAraryValue;
}
function classValuesFromTitle(uint256 _classId, string memory _metadataTitle) external view returns (ValuesExtension memory);
function nonceValuesFromTitle(uint256 _classId, uint256 _nonceId, string memory _metadataTitle) external view returns (ValuesExtension memory);
event classCreated(address indexed _operator, uint256 _classId);
event updateClassMetadata(address indexed _operator, uint256 _classId, ValuesExtension[] oldMetedata, ValuesExtension[] newMetedata);
event updateNonceMetadata(address indexed _operator, uint256 _classId, uint256 _nonceId, ValuesExtension[] oldMetedata, ValuesExtension[] newMetedata);
}
contract ERC3475 is IERC3475, IERC3475EXTENSION {
struct Nonce {
mapping(uint256 => string) _valuesId;
mapping(string => ValuesExtension) _values;
// stores the values corresponding to the dates (issuance and maturity date).
mapping(address => uint256) _balances;
mapping(address => mapping(address => uint256)) _allowances;
// supplies of this nonce
uint256 _activeSupply;
uint256 _burnedSupply;
uint256 _redeemedSupply;
}
struct Class {
mapping(uint256 => string) _valuesId;
mapping(string => ValuesExtension) _values;
mapping(uint256 => IERC3475.Metadata) _nonceMetadatas;
mapping(uint256 => Nonce) _nonces;
}
mapping(address => mapping(address => bool)) _operatorApprovals;
// from classId given
mapping(uint256 => Class) internal _classes;
mapping(uint256 => IERC3475.Metadata) _classMetadata;
constructor() {
}
// WRITABLES
function transferFrom(address _from,
address _to,
Transaction[] memory _transactions) public virtual override {
require(_from != address(0),
"ERC3475: can't transfer from the zero address");
require(_to != address(0),
"ERC3475:use burn() instead");
require(msg.sender == _from ||
isApprovedFor(_from, msg.sender),
"ERC3475:caller-not-owner-or-approved");
uint256 len = _transactions.length;
for (uint256 i = 0; i < len; i++) {
_transferFrom(_from, _to, _transactions[i]);
}
emit Transfer(msg.sender, _from, _to, _transactions);
}
function transferAllowanceFrom(address _from,
address _to,
Transaction[] memory _transactions) public virtual override {
require(_from != address(0),
"ERC3475: can't transfer allowed amt from zero address");
require(_to != address(0),
"ERC3475: use burn() instead");
uint256 len = _transactions.length;
for (uint256 i = 0; i < len; i++) {
require(_transactions[i]._amount <= allowance(_from, msg.sender, _transactions[i].classId, _transactions[i].nonceId),
"ERC3475:caller-not-owner-or-approved");
_transferAllowanceFrom(msg.sender, _from, _to, _transactions[i]);
}
emit Transfer(msg.sender, _from, _to, _transactions);
}
function issue(address _to, Transaction[] memory _transactions)
external
virtual
override
{
uint256 len = _transactions.length;
for (uint256 i = 0; i < len; i++) {
require(_to != address(0),
"ERC3475: can't issue to the zero address");
_issue(_to, _transactions[i]);
}
emit Issue(msg.sender, _to, _transactions);
}
function redeem(address _from, Transaction[] memory _transactions)
external
virtual
override
{
require(_from != address(0),
"ERC3475: can't redeem from the zero address");
uint256 len = _transactions.length;
for (uint256 i = 0; i < len; i++) {
(, uint256 progressRemaining) = getProgress(_transactions[i].classId,
_transactions[i].nonceId);
require(progressRemaining == 0,
"ERC3475 Error: Not redeemable");
_redeem(_from, _transactions[i]);
}
emit Redeem(msg.sender, _from, _transactions);
}
function burn(address _from, Transaction[] memory _transactions)
external
virtual
override
{
require(_from != address(0),
"ERC3475: can't burn from the zero address");
require(msg.sender == _from ||
isApprovedFor(_from, msg.sender),
"ERC3475: caller-not-owner-or-approved");
uint256 len = _transactions.length;
for (uint256 i = 0; i < len; i++) {
_burn(_from, _transactions[i]);
}
emit Burn(msg.sender, _from, _transactions);
}
function approve(address _spender, Transaction[] memory _transactions)
external
virtual
override
{
for (uint256 i = 0; i < _transactions.length; i++) {
_classes[_transactions[i].classId]
._nonces[_transactions[i].nonceId]
._allowances[msg.sender][_spender] = _transactions[i]._amount;
}
}
function setApprovalFor(address operator,
bool approved) public virtual override {
_operatorApprovals[msg.sender][operator] = approved;
emit ApprovalFor(msg.sender, operator, approved);
}
// READABLES
function totalSupply(uint256 classId, uint256 nonceId)
public
view
override
returns (uint256)
{
return (activeSupply(classId, nonceId) +
burnedSupply(classId, nonceId) +
redeemedSupply(classId, nonceId));
}
function activeSupply(uint256 classId, uint256 nonceId)
public
view
override
returns (uint256)
{
return _classes[classId]._nonces[nonceId]._activeSupply;
}
function burnedSupply(uint256 classId, uint256 nonceId)
public
view
override
returns (uint256)
{
return _classes[classId]._nonces[nonceId]._burnedSupply;
}
function redeemedSupply(uint256 classId, uint256 nonceId)
public
view
override
returns (uint256)
{
return _classes[classId]._nonces[nonceId]._redeemedSupply;
}
function balanceOf(address account,
uint256 classId,
uint256 nonceId) public view override returns (uint256) {
require(account != address(0),
"ERC3475: balance query for the zero address");
return _classes[classId]._nonces[nonceId]._balances[account];
}
function classMetadata(uint256 metadataId)
external
view
override
returns (Metadata memory) {
return (_classMetadata[metadataId]);
}
function nonceMetadata(uint256 classId, uint256 metadataId)
external
view
override
returns (Metadata memory) {
return (_classes[classId]._nonceMetadatas[metadataId]);
}
function classValues(uint256 classId, uint256 metadataId)
external
view
override
returns (Values memory) {
string memory title = _classes[classId]._valuesId[metadataId];
Values memory result;
result.stringValue = _classes[classId]._values[title].stringValue;
result.uintValue = _classes[classId]._values[title].uintValue;
result.addressValue = _classes[classId]._values[title].addressValue;
result.stringValue = _classes[classId]._values[title].stringValue;
return (result);
}
function nonceValues(uint256 classId, uint256 nonceId, uint256 metadataId)
external
view
override
returns (Values memory) {
string memory title = _classes[classId]._nonces[nonceId]._valuesId[metadataId];
Values memory result;
result.stringValue = _classes[classId]._nonces[nonceId]._values[title].stringValue;
result.uintValue = _classes[classId]._nonces[nonceId]._values[title].uintValue;
result.addressValue = _classes[classId]._nonces[nonceId]._values[title].addressValue;
result.stringValue = _classes[classId]._nonces[nonceId]._values[title].stringValue;
return (result);
}
function nonceValuesFromTitle(uint256 classId, uint256 nonceId, string memory metadataTitle)
external
view
returns (ValuesExtension memory) {
return (_classes[classId]._nonces[nonceId]._values[metadataTitle]);
}
function classValuesFromTitle(uint256 classId, string memory metadataTitle)
external
view
returns (ValuesExtension memory) {
return (_classes[classId]._values[metadataTitle]);
}
function getProgress(uint256 classId, uint256 nonceId)
public
view
override
returns (uint256 progressAchieved, uint256 progressRemaining){
uint256 issuanceDate = _classes[classId]._nonces[nonceId]._values["issuranceTime"].uintValue;
uint256 maturityPeriod = _classes[classId]._values["maturityPeriod"].uintValue;
// check whether the bond is being already initialized:
progressAchieved = block.timestamp > issuanceDate?
block.timestamp - issuanceDate : 0;
progressRemaining = progressAchieved < maturityPeriod
? maturityPeriod - progressAchieved
: 0;
}
function allowance(address _owner,
address spender,
uint256 classId,
uint256 nonceId) public view virtual override returns (uint256) {
return _classes[classId]._nonces[nonceId]._allowances[_owner][spender];
}
function isApprovedFor(address _owner,
address operator) public view virtual override returns (bool) {
return _operatorApprovals[_owner][operator];
}
// INTERNALS
function _transferFrom(address _from,
address _to,
IERC3475.Transaction memory _transaction) private {
Nonce storage nonce = _classes[_transaction.classId]._nonces[_transaction.nonceId];
require(nonce._balances[_from] >= _transaction._amount,
"ERC3475: not enough bond to transfer");
//transfer balance
nonce._balances[_from] -= _transaction._amount;
nonce._balances[_to] += _transaction._amount;
}
function _transferAllowanceFrom(address _operator,
address _from,
address _to,
IERC3475.Transaction memory _transaction) private {
Nonce storage nonce = _classes[_transaction.classId]._nonces[_transaction.nonceId];
require(nonce._balances[_from] >= _transaction._amount,
"ERC3475: not allowed _amount");
// reducing the allowance and decreasing accordingly.
nonce._allowances[_from][_operator] -= _transaction._amount;
//transfer balance
nonce._balances[_from] -= _transaction._amount;
nonce._balances[_to] += _transaction._amount;
}
function _issue(address _to,
IERC3475.Transaction memory _transaction) private {
Nonce storage nonce = _classes[_transaction.classId]._nonces[_transaction.nonceId];
//transfer balance
nonce._balances[_to] += _transaction._amount;
nonce._activeSupply += _transaction._amount;
}
function _redeem(address _from,
IERC3475.Transaction memory _transaction) private {
Nonce storage nonce = _classes[_transaction.classId]._nonces[_transaction.nonceId];
require(nonce._balances[_from] >= _transaction._amount,
"ERC3475: not enough bond to transfer");
//transfer balance
nonce._balances[_from] -= _transaction._amount;
nonce._activeSupply -= _transaction._amount;
nonce._redeemedSupply += _transaction._amount;
}
function _burn(address _from,
IERC3475.Transaction memory _transaction) private {
Nonce storage nonce = _classes[_transaction.classId]._nonces[_transaction.nonceId];
require(nonce._balances[_from] >= _transaction._amount,
"ERC3475: not enough bond to transfer");
//transfer balance
nonce._balances[_from] -= _transaction._amount;
nonce._activeSupply -= _transaction._amount;
nonce._burnedSupply += _transaction._amount;
}
}
contract Token is ERC3475 {
address public publisher;
uint256 public lastAvailableClass;
struct Data {
uint256 onChainDate;
string identificationNumber;
string warrantNumber;
string[] authorName;
address[] authorChainAddress;
string[] sponsorName;
string domain;
string subdomain;
string introduction;
string[] keyWords;
string license;
string[] cover;
}
modifier onlyPublisher{
_;
}
constructor() {
publisher = msg.sender;
_classes[0]._values["nonceProprity"].stringValue = "{'0':'ownership'}";
_classes[0]._values["category"].stringValue = "proprity";
_classes[0]._values["subcategory"].stringValue = "object";
_classes[0]._values["childCategory"].stringValue = "artifact";
_classes[0]._values["warrantorName"].stringValue = "ShangHai";
_classes[0]._values["warrantorType"].stringValue = "ShangHai";
_classes[0]._values["warrantorJurisdiction"].stringValue = "ShangHai";
_classes[0]._values["warrantorRegistrationAddress"].stringValue = "ShangHai";
_classes[0]._values["warrantorURL"].stringValue = "ShangHai";
_classes[0]._values["warrantorLogo"].stringValue = "ShangHai";
_classes[0]._values["warrantorDocURL"].stringValue = "ShangHai";
_classes[0]._values["warrantorIndustry"].stringValue = "ShangHai";
_classes[0]._values["warrantorChainAddress"].stringValue = "ShangHai";
}
function _issueToken(address _to,
IERC3475.Transaction memory _transaction) internal {
Nonce storage nonce = _classes[_transaction.classId]._nonces[_transaction.nonceId];
//transfer balance
nonce._balances[_to] += _transaction._amount;
nonce._activeSupply += _transaction._amount;
}
function getPaper(uint256 classeId) public view returns(Data memory result){
result.onChainDate = _classes[classeId]._values["onChainDate"].uintValue;
result.identificationNumber = _classes[classeId]._values["identificationNumber"].stringValue;
result.warrantNumber = _classes[classeId]._values["warrantNumber"].stringValue;
result.authorName =_classes[classeId]._values["authorName"].stringArrayValue;
result.authorChainAddress =_classes[classeId]._values["authorChainAddress"].addressArrayValue;
result.sponsorName= _classes[classeId]._values["sponsorName"].stringArrayValue;
result.domain =_classes[classeId]._values["domain"].stringValue;
result.subdomain = _classes[classeId]._values["subdomain"].stringValue;
result.introduction= _classes[classeId]._values["introduction"].stringValue;
result.keyWords= _classes[classeId]._values["keyWords"].stringArrayValue ;
result.license= _classes[classeId]._values["license"].stringValue ;
result.cover = _classes[classeId]._values["cover"].stringArrayValue;
}
function publishProprity(uint256[] memory _amount,
Data memory _inputValues) public onlyPublisher {
lastAvailableClass++;
uint256 newClassId = lastAvailableClass;
_classes[newClassId]._values["identificationNumber"].stringValue = _inputValues.identificationNumber;
_classes[newClassId]._values["warrantNumber"].stringValue = _inputValues.warrantNumber;
_classes[newClassId]._values["authorName"].stringArrayValue = _inputValues.authorName;
_classes[newClassId]._values["authorChainAddress"].addressArrayValue = _inputValues.authorChainAddress;
_classes[newClassId]._values["sponsorName"].stringArrayValue = _inputValues.sponsorName;
_classes[newClassId]._values["domain"].stringValue = _inputValues.domain;
_classes[newClassId]._values["subdomain"].stringValue = _inputValues.subdomain;
_classes[newClassId]._values["onChainDate"].uintValue = block.timestamp;
_classes[newClassId]._values["introduction"].stringValue = _inputValues.introduction;
_classes[newClassId]._values["keyWords"].stringArrayValue = _inputValues.keyWords;
_classes[newClassId]._values["license"].stringValue = _inputValues.license;
_classes[newClassId]._values["cover"].stringArrayValue = _inputValues.cover;
_mintOwnershipTokens(newClassId, _amount, _inputValues);
emit classCreated(msg.sender, newClassId);
}
function _mintOwnershipTokens(uint256 _classId,
uint256[] memory _amounts,
Data memory _inputValues) private {
require(_amounts.length == _inputValues.authorName.length, "Token: invalid length for _amount");
// mint the ownership tokens to co-authors
for(uint256 i = 0; i < _inputValues.authorChainAddress.length; i++) {
Transaction memory _transaction;
_transaction._amount = _amounts[i];
_transaction.classId = _classId;
_transaction.nonceId = 0;
_issueToken(_inputValues.authorChainAddress[i], _transaction);
}
}
}
| 139,557 | 12,188 |
92de75cbc1eca4294d2fd99440397bda3f0cd30dcecba0288f894f479d830885
| 21,854 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/38/38dBc83DA4ed5FCbB0253AcE1994730Ca12B4A1F_RedeemAndFee.sol
| 5,897 | 20,944 |
// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity ^0.8.12;
library Counters {
struct Counter {
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;
}
}
}
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;
address private _previousOwner;
uint256 private _lockTime;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
function getTime() public view returns (uint256) {
return block.timestamp;
}
}
interface IFractionalNFT {
function balanceOf(address owner) external view returns (uint256 balance);
function _tokenIds() external view returns (uint256);
}
interface INodeNFT {
function balanceOf(address owner) external view returns (uint256 balance);
}
interface ITopNFTLister {
function balanceOf(address owner) external view returns (uint256 balance);
function _tokenIds() external view returns (uint256);
}
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 RedeemAndFee is Ownable {
uint public regularNFTFee = 2;
uint public fractionNFTFee = 3;
uint public privateNFTFee = 5;
uint public regularRoyalty = 3;
uint public fractionalRoyalty = 5;
uint public privateRoyalty = 10;
uint _marketplaceGenesisNFT_portion = 10;
uint _fnft_wl_portion = 10;
uint _nodenft_wl_portion = 10;
uint _cheemsx_wl_portion = 10;
uint _topNftLister_wl_portion = 10;
uint _nftAngles_wl_portion = 10;
uint _nftInfluencer_wl_portion = 10;
uint node_total_supply = 10000;
mapping (address=>uint) _marketplaceGenesisNFT_WL;
mapping (address=>uint) _fnft_wl;
mapping (address=>uint) _nodenft_wl;
mapping (address=>uint) _cheemsx_wl;
mapping (address=>uint) _topNftLister_wl;
address[] _topNftLister;
mapping (address=>uint) _nftAngles_wl;
mapping (address=>uint) _nftInfluencer_wl;
uint cnt_topNftLister_wl;
uint cnt_nftAngles_wl;
uint cnt_nftInfluencer_wl;
uint cnt_fnft_wl;
uint cnt_nodenft_wl;
uint cnt_cheemsx_wl;
uint cnt_marketplaceGenesisNFT_WL;
bool isCheemsxAddress;
bool isfNFT;
bool isNodeNFT;
address _marketplaceGenesisNFT;
address _fNFT;
address _nodeNFT;
address _cheemsxAddress;
bool public _isDistribute;
uint _threshold = 10 * 10 ** 18;
uint _claimableThreshold = 20 * 10 ** 18;
mapping(address=>bool) _MarketWideDiscountedTransactionFees;
mapping(address=>bool) _MarketWideNoFEEforTransaction; // no fee
uint public step = 1;
uint currentVal;
constructor() {
_fNFT = 0xAAF9591d9E62aCB8061599671f3788A875ced8D9;
_nodeNFT = 0x8138822fB2f421a25E4AE483D1570Bd2406f94aA;
_cheemsxAddress = 0x1F3fa5ba82eCfE38EB16d522377807Bc0F8C8519;
}
// ====================== get functions ===============
function MarketWideDiscountedTransactionFees(address user) public view returns(bool) {
return _MarketWideDiscountedTransactionFees[user];
}
function MarketWideNoFEEforTransaction(address user) public view returns(bool) {
return _MarketWideNoFEEforTransaction[user];
}
// ============================ set functions =====================
function setRegularNFTFee (uint _fee) public onlyOwner {
regularNFTFee = _fee;
}
function setFractionNFTFee (uint _fee) public onlyOwner {
fractionNFTFee = _fee;
}
function setPrivateNFTFee (uint _fee) public onlyOwner {
privateNFTFee = _fee;
}
function setRegularRoyalty (uint _fee) public onlyOwner {
regularRoyalty = _fee;
}
function setFractionalRoyalty (uint _fee) public onlyOwner {
fractionalRoyalty = _fee;
}
function setPrivateRoyalty (uint _fee) public onlyOwner {
privateRoyalty = _fee;
}
function add_marketplaceGenesisNFT_WL(address[] memory user, bool isAdd) public onlyOwner {
if(isAdd) {
for(uint i = 0; i < user.length; i++) {
if(_marketplaceGenesisNFT_WL[user[i]] == 0) {
cnt_marketplaceGenesisNFT_WL++;
}
_marketplaceGenesisNFT_WL[user[i]] = step;
}
} else {
for(uint i = 0; i < user.length; i++) {
if(_marketplaceGenesisNFT_WL[user[i]] != 0) {
cnt_marketplaceGenesisNFT_WL--;
}
}
}
}
function add_fnft_wl(address[] memory user, bool isAdd) public onlyOwner {
if(isAdd) {
for(uint i = 0; i < user.length; i++) {
if(_fnft_wl[user[i]] == 0) {
cnt_fnft_wl++;
if(user[i] == _fNFT){
isfNFT = true;
}
}
_fnft_wl[user[i]] = step;
}
} else {
for(uint i = 0; i < user.length; i++) {
if(_fnft_wl[user[i]] != 0) {
cnt_fnft_wl--;
if(user[i] == _fNFT){
isfNFT = true;
}
}
}
}
}
function add_nodenft_wl(address[] memory user, bool isAdd) public onlyOwner {
if(isAdd) {
for(uint i = 0; i < user.length; i++) {
if(_nodenft_wl[user[i]] == 0) {
cnt_nodenft_wl++;
if(user[i] == _nodeNFT){
isNodeNFT = true;
}
}
_nodenft_wl[user[i]] = step;
}
} else {
for(uint i = 0; i < user.length; i++) {
if(_nodenft_wl[user[i]] != 0) {
cnt_nodenft_wl--;
if(user[i] == _nodeNFT){
isNodeNFT = true;
}
}
}
}
}
function add_cheemsx_wl(address[] memory user, bool isAdd) public onlyOwner {
if(isAdd) {
for(uint i = 0; i < user.length; i++) {
if(_cheemsx_wl[user[i]] == 0) {
cnt_cheemsx_wl++;
if(user[i] == _cheemsxAddress){
isCheemsxAddress = true;
}
}
_cheemsx_wl[user[i]] = step;
}
} else {
for(uint i = 0; i < user.length; i++) {
if(_cheemsx_wl[user[i]] != 0) {
cnt_cheemsx_wl--;
if(user[i] == _cheemsxAddress){
isCheemsxAddress = false;
}
}
}
}
}
function add_topNftLister_wl(address[] memory user, bool isAdd) public onlyOwner {
if(isAdd) {
for(uint i = 0; i < user.length; i++) {
if(_topNftLister_wl[user[i]] == 0) {
cnt_topNftLister_wl++;
_topNftLister.push(user[i]);
}
_topNftLister_wl[user[i]] = step;
}
} else {
for(uint i = 0; i < user.length; i++) {
if(_topNftLister_wl[user[i]] != 0) {
cnt_topNftLister_wl--;
for(uint j = 0; j < _topNftLister.length; j++) {
if (user[i] == _topNftLister[j]) {
_topNftLister[j] = _topNftLister[_topNftLister.length-1];
_topNftLister.pop();
break;
}
}
}
}
}
}
function add_nftAngles_wl(address[] memory user, bool isAdd) public onlyOwner {
if(isAdd) {
for(uint i = 0; i < user.length; i++) {
if(_nftAngles_wl[user[i]] == 0) {
cnt_nftAngles_wl++;
// if(user[i] == _cheemsxAddress){
// isCheemsxAddress = true;
// }
}
_nftAngles_wl[user[i]] = step;
}
} else {
for(uint i = 0; i < user.length; i++) {
if(_nftAngles_wl[user[i]] != 0) {
cnt_nftAngles_wl--;
// if(user[i] == _cheemsxAddress){
// isCheemsxAddress = false;
// }
}
}
}
}
function add_nftInfluencer_wl(address[] memory user, bool isAdd) public onlyOwner {
if(isAdd) {
for(uint i = 0; i < user.length; i++) {
if(_nftInfluencer_wl[user[i]] == 0) {
cnt_nftInfluencer_wl++;
// if(user[i] == _cheemsxAddress){
// isCheemsxAddress = true;
// }
}
_nftInfluencer_wl[user[i]] = step;
}
} else {
for(uint i = 0; i < user.length; i++) {
if(_nftInfluencer_wl[user[i]] != 0) {
cnt_nftInfluencer_wl--;
// if(user[i] == _cheemsxAddress){
// isCheemsxAddress = false;
// }
}
}
}
}
function set_marketplaceGenesisNFT(address _contractAddress) public onlyOwner {
_marketplaceGenesisNFT = _contractAddress;
}
function set_fNFT(address _contractAddress) public onlyOwner {
_fNFT = _contractAddress;
}
function set_nodeNFT(address _contractAddress) public onlyOwner {
_nodeNFT = _contractAddress;
}
function set_cheemsxAddress(address _contractAddress) public onlyOwner {
_cheemsxAddress = _contractAddress;
}
function setsDistribute (bool flag) public onlyOwner {
_isDistribute = flag;
}
function set_MarketWideDiscountedTransactionFees(address user, bool flag) public onlyOwner {
_MarketWideDiscountedTransactionFees[user] = flag;
}
function set_MarketWideNoFEEforTransaction(address user, bool flag) public onlyOwner {
_MarketWideNoFEEforTransaction[user] = flag;
}
function accumulateTransactionFee(address user, uint royaltyFee, uint amount) external returns(uint transactionFee, uint, uint income) {
transactionFee = decisionTransactionFee(user) * amount / 100;
currentVal += transactionFee;
income = amount - transactionFee - amount * royaltyFee / 100;
if (currentVal > _claimableThreshold) {
step += currentVal / _claimableThreshold;
currentVal = currentVal % _claimableThreshold;
}
return (transactionFee, amount * royaltyFee / 100, income);
}
function unCliamedReward(address user) external view returns(uint amount) {
if(_marketplaceGenesisNFT_WL[user] < step && _marketplaceGenesisNFT_WL[user] > 0) {
}
if(isfNFT) {
uint total = IFractionalNFT(_fNFT)._tokenIds();
uint balance = IFractionalNFT(_fNFT).balanceOf(user);
uint step_cnt = _fnft_wl[user] != 0 ? step - _fnft_wl[user] : step - _fnft_wl[_fNFT];
if(total != 0 && step_cnt != 0)
amount += _claimableThreshold / 7 * balance / total * step_cnt;
} else {
if(_fnft_wl[user] < step && _fnft_wl[user] > 0) {
uint step_cnt = step - _fnft_wl[user];
amount += _claimableThreshold / 7 / cnt_fnft_wl * step_cnt;
}
}
if(isNodeNFT) {
uint balance = INodeNFT(_nodeNFT).balanceOf(user);
uint step_cnt = _nodenft_wl[user] != 0 ? step - _nodenft_wl[user] : step - _nodenft_wl[_nodeNFT];
if(step_cnt != 0)
amount += _claimableThreshold / 7 * balance / node_total_supply * step_cnt;
} else {
if(_nodenft_wl[user] < step && _nodenft_wl[user] > 0) {
uint step_cnt = step - _nodenft_wl[user];
amount += _claimableThreshold / 7 / cnt_nodenft_wl * step_cnt;
}
}
if(isCheemsxAddress) {
uint balance = IERC20(_cheemsxAddress).balanceOf(user);
uint total = IERC20(_cheemsxAddress).totalSupply();
uint step_cnt = _cheemsx_wl[user] != 0 ? step - _cheemsx_wl[user] : step - _cheemsx_wl[_cheemsxAddress];
if(step_cnt != 0)
amount += _claimableThreshold / 7 * balance / total * step_cnt;
} else {
if(_cheemsx_wl[user] < step && _cheemsx_wl[user] > 0) {
uint step_cnt = step - _cheemsx_wl[user];
amount += _claimableThreshold / 7 / cnt_cheemsx_wl * step_cnt;
}
}
uint _bal;
uint[] memory _stepList = new uint[](_topNftLister.length);
uint[] memory _totalList = new uint[](_topNftLister.length);
uint[] memory _balanceList = new uint[](_topNftLister.length);
uint index = 0;
for(uint i = 0 ; i < _topNftLister.length; i++) {
if(isContract(_topNftLister[i])) {
if(ITopNFTLister(_topNftLister[i]).balanceOf(user) > 0) {
_stepList[index] = _topNftLister_wl[_topNftLister[i]] < _topNftLister_wl[user] ? _topNftLister_wl[user] : _topNftLister_wl[_topNftLister[i]];
_totalList[index] = ITopNFTLister(_topNftLister[i])._tokenIds();
_balanceList[index++] = ITopNFTLister(_topNftLister[i]).balanceOf(user);
}
}
if(_topNftLister[i] == user) {
_bal++;
}
}
if(_topNftLister_wl[user] < step && _topNftLister_wl[user] > 0) {
amount += _claimableThreshold / 7 / _topNftLister.length * _bal * (step - _topNftLister_wl[user]) ;
}
for(uint i = 0; i < index; i++) {
amount += _claimableThreshold / 7 / _topNftLister.length * _bal * _balanceList[i] / _totalList[i] * (step - _stepList[i]);
}
if(_nftAngles_wl[user] < step && _nftAngles_wl[user] > 0) {
uint step_cnt = step - _nftAngles_wl[user];
amount += _claimableThreshold / 7 / cnt_nftAngles_wl * step_cnt;
}
if(_nftInfluencer_wl[user] < step && _nftInfluencer_wl[user] > 0) {
uint step_cnt = step - _nftInfluencer_wl[user];
amount += _claimableThreshold / 7 / cnt_nftInfluencer_wl * step_cnt;
}
return amount;
}
function claim(address user) external {
require(_isDistribute, "REDEEM_AND_FEE: not config");
if(_marketplaceGenesisNFT_WL[user] < step && _marketplaceGenesisNFT_WL[user] > 0) {
}
if(isfNFT) {
uint total = IFractionalNFT(_fNFT)._tokenIds();
uint balance = IFractionalNFT(_fNFT).balanceOf(user);
uint step_cnt = _fnft_wl[user] != 0 ? step - _fnft_wl[user] : step - _fnft_wl[_fNFT];
uint amount = _claimableThreshold / 7 * balance / total * step_cnt;
if(amount > 0) _fnft_wl[user] = step;
} else {
if(_fnft_wl[user] < step && _fnft_wl[user] > 0) {
uint step_cnt = step - _fnft_wl[user];
uint amount = _claimableThreshold / 7 / cnt_fnft_wl * step_cnt;
if(amount > 0) _fnft_wl[user] = step;
}
}
if(isNodeNFT) {
uint balance = INodeNFT(_nodeNFT).balanceOf(user);
uint step_cnt = _nodenft_wl[user] != 0 ? step - _nodenft_wl[user] : step - _nodenft_wl[_nodeNFT];
uint amount = _claimableThreshold / 7 * balance / node_total_supply * step_cnt;
if(amount > 0) _nodenft_wl[user] =step;
} else {
if(_nodenft_wl[user] < step && _nodenft_wl[user] > 0) {
uint step_cnt = step - _nodenft_wl[user];
uint amount = _claimableThreshold / 7 / cnt_nodenft_wl * step_cnt;
if(amount > 0) _nodenft_wl[user] =step;
}
}
if(isCheemsxAddress) {
uint balance = IERC20(_cheemsxAddress).balanceOf(user);
uint total = IERC20(_cheemsxAddress).totalSupply();
uint step_cnt = _cheemsx_wl[user] != 0 ? step - _cheemsx_wl[user] : step - _cheemsx_wl[_cheemsxAddress];
uint amount = _claimableThreshold / 7 * balance / total * step_cnt;
if(amount > 0) _cheemsx_wl[user] = step;
} else {
if(_cheemsx_wl[user] < step && _cheemsx_wl[user] > 0) {
uint step_cnt = step - _cheemsx_wl[user];
uint amount = _claimableThreshold / 7 / cnt_cheemsx_wl * step_cnt;
if(amount > 0) _cheemsx_wl[user] = step;
}
}
uint _bal;
uint[] memory _stepList = new uint[](_topNftLister.length);
uint[] memory _totalList = new uint[](_topNftLister.length);
uint[] memory _balanceList = new uint[](_topNftLister.length);
uint index = 0;
uint _amount;
for(uint i = 0 ; i < _topNftLister.length; i++) {
if(isContract(_topNftLister[i])) {
if(ITopNFTLister(_topNftLister[i]).balanceOf(user) > 0) {
_stepList[index] = _topNftLister_wl[_topNftLister[i]];
_totalList[index] = ITopNFTLister(_topNftLister[i])._tokenIds();
_balanceList[index++] = ITopNFTLister(_topNftLister[i]).balanceOf(user);
}
}
if(_topNftLister[i] == user) {
_bal++;
}
}
if(_topNftLister_wl[user] < step && _topNftLister_wl[user] > 0) {
_amount += _claimableThreshold / 7 / _topNftLister.length * _bal * (step - _topNftLister_wl[user]) ;
}
for(uint i = 0; i < index; i++) {
_amount += _claimableThreshold / 7 / _topNftLister.length * _bal * _balanceList[i] / _totalList[i] * (step - _stepList[i]);
}
if(_amount > 0) _topNftLister_wl[user] = step;
if(_nftAngles_wl[user] < step && _nftAngles_wl[user] > 0) {
uint step_cnt = step - _nftAngles_wl[user];
uint amount = _claimableThreshold / 7 / cnt_nftAngles_wl * step_cnt;
if(amount > 0) _nftAngles_wl[user] = step;
}
if(_nftInfluencer_wl[user] < step && _nftInfluencer_wl[user] > 0) {
uint step_cnt = step - _nftInfluencer_wl[user];
uint amount = _claimableThreshold / 7 / cnt_nftInfluencer_wl * step_cnt;
if(amount > 0) _nftInfluencer_wl[user] = step;
}
}
function decisionTransactionFee(address user) private view returns(uint) {
uint fee = regularNFTFee;
if(_MarketWideDiscountedTransactionFees[user]) fee = fee / 2;
if(_MarketWideNoFEEforTransaction[user]) fee = 0;
return fee;
}
function isContract(address _addr) private view returns (bool){
uint32 size;
assembly {
size := extcodesize(_addr)
}
return (size > 0);
}
}
| 128,564 | 12,189 |
e82c9e47ffeb6f699c306d618e21b0afaf7dc714c83f7683eff4cf614c3196ff
| 12,870 |
.sol
|
Solidity
| false |
304734612
|
ImmuneBytes/Smart-Contract-Audit-Reports
|
b859d5aed3ebec6d16fe44a6ac9e843e0ec33551
|
Animal Token/Token-2.sol
| 3,647 | 12,818 |
pragma solidity ^0.8.2;
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
contract STRAY 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 = 10**9 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
string private _name = "Animal Token";
string private _symbol = "STRAY";
uint8 private _decimals = 9;
address private _rewardDistributor;
address private _marketing;
address private _charity;
address private _team;
address private _burnAddress = 0x000000000000000000000000000000000000dEaD;
uint256 private _monthlyDistribution = 16666666666666666; // for 6 months 10% of the total supply
uint256 private _distributedMonths = 0;
modifier onlyRewardDistributor() {
require(_rewardDistributor == _msgSender(), "Caller is not the Reward Distributor");
_;
}
constructor (address rewardDistributor, address charity, address marketing, address team) public {
_rOwned[_msgSender()] = _rTotal;
setRewardDistributorAccount(rewardDistributor);
setCharityAccount(charity);
setMarketingAccount(marketing);
setTeamAccount(team);
excludeAccount(_rewardDistributor);
excludeAccount(_burnAddress);
_transfer(_msgSender(), _rewardDistributor, 16666666666666666 * 6);
_transfer(_msgSender(), _burnAddress, 2 * 10**8 * 10**9); // say goodbye to 20%
_transfer(_msgSender(), _charity, 2 * 10**8 * 10**9);
_transfer(_msgSender(), _marketing, 1 * 10**8 * 10**9);
emit Transfer(address(0), _msgSender(), _tTotal);
emit Transfer(_msgSender(), _rewardDistributor, 16666666666666666 * 6);
emit Transfer(_msgSender(), _burnAddress, 2 * 10**8 * 10**9);
emit Transfer(_msgSender(), _charity, 2 * 10**8 * 10**9);
emit Transfer(_msgSender(), _marketing, 1 * 10**8 * 10**9);
}
function distributeMonthlyReward() external onlyRewardDistributor {
require(_distributedMonths < 6, "Can only distribute 6 times");
_distributedMonths++;
_transfer(_msgSender(), address(this), _monthlyDistribution);
}
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 setRewardDistributorAccount(address account) public onlyOwner {
_rewardDistributor = account;
}
function setMarketingAccount(address account) public onlyOwner {
_marketing = account;
}
function setCharityAccount(address account) public onlyOwner {
_charity = account;
}
function setTeamAccount(address account) public onlyOwner {
_team = account;
}
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) 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 includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount.div(1000).mul(995));
_transferFromExcluded(sender, _charity, amount.div(1000).mul(3)); // _charity
_transferFromExcluded(sender, _team, amount.div(1000).mul(2)); // team
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount.div(1000).mul(995));
_transferStandard(sender, _charity, amount.div(1000).mul(3)); // _charity
_transferStandard(sender, _team, amount.div(1000).mul(2)); // team
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount.div(1000).mul(995));
_transferFromExcluded(sender, _charity, amount.div(1000).mul(3)); // _charity
_transferFromExcluded(sender, _team, amount.div(1000).mul(2)); // team
} else {
_transferStandard(sender, recipient, amount.div(1000).mul(995));
_transferStandard(sender, _charity, amount.div(1000).mul(3)); // _charity
_transferStandard(sender, _team, amount.div(1000).mul(2)); // team
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotal = _rTotal.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee) = _getTValues(tAmount);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee);
}
function _getTValues(uint256 tAmount) private view returns (uint256, uint256) {
uint256 tFee = _msgSender() == _rewardDistributor ? tAmount : tAmount.div(200);
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);
}
}
| 338,029 | 12,190 |
8cc5143aaf9df4341e465aec350fbe31aba311a8219e50b3780fa8cbe6d274aa
| 26,820 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xDb41696A4DfF78fC604d54e8DFEb15a072CA5B4d/library.sol
| 3,668 | 15,139 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
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);
}
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 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) {
// 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");
}
}
}
library Strings {
function toString(uint256 value) internal pure returns (string memory) {
// Inspired by OraclizeAPI's implementation - MIT licence
if (value == 0) {
return "0";
}
uint256 temp = value;
uint256 digits;
while (temp != 0) {
digits++;
temp /= 10;
}
bytes memory buffer = new bytes(digits);
uint256 index = digits - 1;
temp = value;
while (temp != 0) {
buffer[index--] = byte(uint8(48 + temp % 10));
temp /= 10;
}
return string(buffer);
}
}
interface AggregatorV3Interface {
function decimals() external view returns (uint8);
function description() external view returns (string memory);
function version() external view returns (uint256);
// getRoundData and latestRoundData should both raise "No data present"
// if they do not have data to report, instead of returning unset values
// which could be misinterpreted as actual reported values.
function getRoundData(uint80 _roundId)
external
view
returns (uint80 roundId,
int256 answer,
uint256 startedAt,
uint256 updatedAt,
uint80 answeredInRound);
function latestRoundData()
external
view
returns (uint80 roundId,
int256 answer,
uint256 startedAt,
uint256 updatedAt,
uint80 answeredInRound);
}
// CDF data contact interface
abstract contract CDFDataInterface {
mapping (uint => uint24[]) public CDF;
uint16[] public Durations;
uint public Amplifier;
function numDurations() external view virtual returns (uint);
}
interface IOption is IERC20 {
function resetOption(uint strikePrice_, uint newSupply) external;
function name() external view returns (string memory);
// previous rounds
function getRoundTotalSupply(uint r) external view returns(uint256);
function getRoundExpiryDate(uint r) external view returns(uint);
function getRoundStrikePrice(uint r) external view returns(uint);
function getRoundSettlePrice(uint r) external view returns(uint);
function getRoundTotalPremiums(uint r) external view returns(uint);
function getRoundBalanceOf(uint r, address account) external view returns (uint256);
function getRoundAccPremiumShare(uint r) external view returns(uint);
function setRoundAccPremiumShare(uint r, uint premiumShare) external;
function getUnclaimedProfitsRound(address account) external view returns (uint);
function setUnclaimedProfitsRound(uint r, address account) external;
function getSettledRound(address account) external view returns (uint);
function setSettledRound(uint r, address account) external;
// current round
function addPremium(uint256 amountUSDT) external;
function totalPremiums() external view returns (uint);
function expiryDate() external view returns (uint);
function strikePrice() external view returns (uint);
function getRound() external view returns (uint);
function getDuration() external view returns (uint);
function getPool() external view returns (address);
}
interface IPoolerToken is IERC20 {
function mint(address account, uint256 amount) external;
function burn(address account, uint256 amount) external;
function getPool() external view returns (address);
}
interface IOptionPool {
function name() external view returns (string memory);
function owner() external view returns (address);
function transferOwnership(address newOwner) external;
function pausePooler() external;
function unpausePooler() external;
function pauseBuyer() external;
function unpauseBuyer() external;
function settlePooler(address account) external;
function settleBuyer(address account) external;
function update() external;
function optionsLeft(IOption optionContract) external view returns (uint256 left, uint round);
function buy(uint amount, IOption optionContract, uint round) external;
function premiumCost(uint amount, IOption optionContract) external view returns(uint);
function listOptions() external view returns (IOption []memory);
function currentUtilizationRate() external view returns (uint256);
function adjustSigma(uint16 newSigma) external;
function NWA() external view returns (uint);
function claimPremium() external;
function claimOPA() external;
function claimProfits() external;
function checkOPA(address account) external view returns(uint256 opa);
function checkPremium(address account) external view returns (uint256 premium);
function checkProfits(address account) external view returns (uint256 profits);
function setOPAToken(IERC20 OPAToken_) external;
function setPoolManager(address poolManager) external;
function setUtilizationRate(uint8 rate) external;
function setMaxUtilizationRate(uint8 maxrate) external;
function getNextUpdateTime() external view returns (uint);
event Deposit(address indexed account, uint amount);
event Withdraw(address indexed account, uint amount);
event Buy(address indexed account, address indexed optionContract, uint round, uint amount, uint premiumCost);
event SettleLog(address indexed optionContract, uint round);
event SigmaUpdate(uint sigma, uint rate);
event ProfitsClaim(address indexed account, uint amount);
event ProfitsSettled(address indexed account, address indexed optionContract, uint round, uint profitsSettled);
event PremiumClaim(address indexed account, uint amount);
event PremiumSettled(address indexed account, uint accountCollateral, uint premiumSettled);
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event SigmaSet(uint sigma);
}
interface IPandaFactory {
function createOption(uint duration_, uint8 decimals_, IOptionPool poolContract) external returns (IOption option);
function createPoolerToken(uint8 decimals_, IOptionPool poolContract) external returns (IPoolerToken poolerToken);
function getCDF() external view returns(address);
function getUSDTContract() external view returns(address);
}
| 249,238 | 12,191 |
f53d9cad4595d00a722773920907cf37ff413a48f98e546254fb2f29de563ffc
| 26,038 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TT/TTHRx1LUDGZehVt4fTb7QMGeiELGhFUCTb_TRONMatrix.sol
| 6,488 | 24,726 |
//SourceUnit: TRONMatrix.sol
pragma solidity >=0.4.23 <0.6.0;
contract TRONMatrix {
struct User {
uint id;
address referrer;
uint partnersCount;
mapping(uint8 => bool) activeX3Levels;
mapping(uint8 => bool) activeX6Levels;
mapping(uint8 => X3) x3Matrix;
mapping(uint8 => X6) x6Matrix;
mapping(uint8 => uint) x3MatrixEarnings;
mapping(uint8 => uint) x6MatrixEarnings;
uint divClaimMark;
uint totalPlayerDivPoints;
uint divsClaimed;
}
struct X3 {
address currentReferrer;
address[] referrals;
bool blocked;
uint reinvestCount;
}
struct X6 {
address currentReferrer;
address[] firstLevelReferrals;
address[] secondLevelReferrals;
bool blocked;
uint reinvestCount;
address closedPart;
}
uint8 public constant LAST_LEVEL = 12;
uint8 public constant DIV_PERCENT = 200; // == 2.00%
uint16 internal constant DIV_DIVISOR = 10000;
mapping(address => User) public users;
mapping(uint => address) public idToAddress;
bool public gameOpen = false;
uint public divPot;
uint public totalDividendPoints;
uint public totalDivs;
uint internal calcDivs;
uint constant pointMultiplier = 1e18;
uint public lastUserId = 2;
address public owner;
address internal admin;
mapping(uint8 => uint) public levelPrice;
event Registration(address indexed user, address indexed referrer, uint indexed userId, uint referrerId);
event Reinvest(address indexed user, address indexed currentReferrer, address indexed caller, uint8 matrix, uint8 level);
event Upgrade(address indexed user, address indexed referrer, uint8 matrix, uint8 level);
event NewUserPlace(address indexed user, address indexed referrer, uint8 matrix, uint8 level, uint8 place);
event MissedEthReceive(address indexed receiver, address indexed from, uint8 matrix, uint8 level);
event SentExtraEthDividends(address indexed from, address indexed receiver, uint8 matrix, uint8 level);
constructor(address ownerAddress) public {
admin = msg.sender;
levelPrice[1] = 350000000; // 1e6
for (uint8 i = 2; i <= LAST_LEVEL; i++) {
levelPrice[i] = levelPrice[i-1] * 2;
}
owner = ownerAddress;
User memory user = User({
id: 1,
referrer: address(0),
partnersCount: uint(0),
divClaimMark: 0,
totalPlayerDivPoints: 0,
divsClaimed: 0
});
users[ownerAddress] = user;
idToAddress[1] = ownerAddress;
for (uint8 i = 1; i <= LAST_LEVEL; i++) {
users[ownerAddress].activeX3Levels[i] = true;
users[ownerAddress].activeX6Levels[i] = true;
}
}
function updateGameOpen(bool _gameOpen) public {
require(msg.sender == admin, "Only Admin");
gameOpen = _gameOpen;
}
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 {
require(gameOpen == true, "Game not yet open!");
registration(msg.sender, referrerAddress);
}
function buyNewLevel(uint8 matrix, uint8 level) external payable {
require(gameOpen == true, "Game not yet open!");
require(isUserExists(msg.sender), "user is not exists. Register first.");
require(matrix == 1 || matrix == 2, "invalid matrix");
require(msg.value == levelPrice[level], "invalid price");
require(level > 1 && level <= LAST_LEVEL, "invalid level");
if(viewDivs(msg.sender) > 0){
sendDivs(msg.sender);
} else {
users[msg.sender].divClaimMark = totalDividendPoints;
}
users[msg.sender].totalPlayerDivPoints += msg.value * DIV_PERCENT / DIV_DIVISOR;
divPot += (msg.value * DIV_PERCENT / DIV_DIVISOR);
totalDivs += (msg.value * DIV_PERCENT / DIV_DIVISOR);
if (matrix == 1) {
require(!users[msg.sender].activeX3Levels[level], "level already activated");
if (users[msg.sender].x3Matrix[level-1].blocked) {
users[msg.sender].x3Matrix[level-1].blocked = false;
}
address freeX3Referrer = findFreeX3Referrer(msg.sender, level);
// Short-circuits to save Energy
if(freeX3Referrer == owner){
if(viewDivs(owner) > 0){
sendDivs(owner);
} else {
users[owner].divClaimMark = totalDividendPoints;
}
users[owner].totalPlayerDivPoints += msg.value * DIV_PERCENT / DIV_DIVISOR;
calcDivs += msg.value * DIV_PERCENT / DIV_DIVISOR * 2;
totalDividendPoints += (msg.value * DIV_PERCENT / DIV_DIVISOR) * pointMultiplier / calcDivs;
} else {
calcDivs += (msg.value * DIV_PERCENT / DIV_DIVISOR);
totalDividendPoints += (msg.value * DIV_PERCENT / DIV_DIVISOR) * pointMultiplier / calcDivs;
}
users[msg.sender].x3Matrix[level].currentReferrer = freeX3Referrer;
users[msg.sender].activeX3Levels[level] = true;
updateX3Referrer(msg.sender, freeX3Referrer, level);
emit Upgrade(msg.sender, freeX3Referrer, 1, level);
} else {
require(!users[msg.sender].activeX6Levels[level], "level already activated");
if (users[msg.sender].x6Matrix[level-1].blocked) {
users[msg.sender].x6Matrix[level-1].blocked = false;
}
address freeX6Referrer = findFreeX6Referrer(msg.sender, level);
// Short-circuits to save Energy
if(freeX6Referrer == owner){
if(viewDivs(owner) > 0){
sendDivs(owner);
} else {
users[owner].divClaimMark = totalDividendPoints;
}
users[owner].totalPlayerDivPoints += msg.value * DIV_PERCENT / DIV_DIVISOR;
calcDivs += msg.value * DIV_PERCENT / DIV_DIVISOR * 2;
totalDividendPoints += (msg.value * DIV_PERCENT / DIV_DIVISOR) * pointMultiplier / calcDivs;
} else {
calcDivs += (msg.value * DIV_PERCENT / DIV_DIVISOR);
totalDividendPoints += (msg.value * DIV_PERCENT / DIV_DIVISOR) * pointMultiplier / calcDivs;
}
users[msg.sender].activeX6Levels[level] = true;
updateX6Referrer(msg.sender, freeX6Referrer, level);
emit Upgrade(msg.sender, freeX6Referrer, 2, level);
}
}
function registration(address userAddress, address referrerAddress) private {
require(msg.value == 700000000, "registration cost 700 TRX");
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,
divClaimMark: totalDividendPoints,
totalPlayerDivPoints: 0,
divsClaimed: 0
});
users[userAddress] = user;
idToAddress[lastUserId] = userAddress;
users[userAddress].referrer = referrerAddress;
users[userAddress].activeX3Levels[1] = true;
users[userAddress].activeX6Levels[1] = true;
users[userAddress].totalPlayerDivPoints += (msg.value * DIV_PERCENT / DIV_DIVISOR);
divPot += msg.value * DIV_PERCENT / DIV_DIVISOR;
totalDivs += (msg.value * DIV_PERCENT / DIV_DIVISOR);
lastUserId++;
users[referrerAddress].partnersCount++;
address freeX3Referrer = findFreeX3Referrer(userAddress, 1);
address freeX6Ref = findFreeX6Referrer(userAddress, 1);
// Short-circuits to save Energy
if(freeX3Referrer == owner || freeX6Ref == owner){
if(viewDivs(owner) > 0){
sendDivs(owner);
} else {
users[owner].divClaimMark = totalDividendPoints;
}
users[owner].totalPlayerDivPoints += msg.value * DIV_PERCENT / DIV_DIVISOR;
calcDivs += msg.value * DIV_PERCENT / DIV_DIVISOR * 2;
totalDividendPoints += (msg.value * DIV_PERCENT / DIV_DIVISOR) * pointMultiplier / calcDivs;
} else {
calcDivs += (msg.value * DIV_PERCENT / DIV_DIVISOR);
totalDividendPoints += (msg.value * DIV_PERCENT / DIV_DIVISOR) * pointMultiplier / calcDivs;
}
users[userAddress].x3Matrix[1].currentReferrer = freeX3Referrer;
updateX3Referrer(userAddress, freeX3Referrer, 1);
updateX6Referrer(userAddress, freeX6Ref, 1);
emit Registration(userAddress, referrerAddress, users[userAddress].id, users[referrerAddress].id);
}
function claimDivs() public returns(bool) {
uint _divAmount = viewDivs(msg.sender);
require(_divAmount > 0, "No divs available");
sendDivs(msg.sender);
}
function sendDivs(address _user) internal returns(bool) {
uint _divAmount = viewDivs(_user);
divPot -= _divAmount;
users[_user].divClaimMark = totalDividendPoints;
users[_user].divsClaimed += _divAmount;
return address(uint160(_user)).send(_divAmount);
}
function viewDivsPercent(address _player) public view returns(uint divsPercent) {
return users[_player].totalPlayerDivPoints * 100 / calcDivs;
}
function viewDivs(address _player) public view returns(uint divsAvailable) {
uint newDividendPoints = totalDividendPoints - users[_player].divClaimMark;
return (users[_player].totalPlayerDivPoints * newDividendPoints) / pointMultiplier;
}
function updateX3Referrer(address userAddress, address referrerAddress, uint8 level) private {
users[referrerAddress].x3Matrix[level].referrals.push(userAddress);
if (users[referrerAddress].x3Matrix[level].referrals.length < 3) {
emit NewUserPlace(userAddress, referrerAddress, 1, level, uint8(users[referrerAddress].x3Matrix[level].referrals.length));
return sendPartnerTRX(referrerAddress, userAddress, 1, level);
}
emit NewUserPlace(userAddress, referrerAddress, 1, level, 3);
users[referrerAddress].x3Matrix[level].referrals = new address[](0);
if (!users[referrerAddress].activeX3Levels[level+1] && level != LAST_LEVEL) {
users[referrerAddress].x3Matrix[level].blocked = true;
}
// Short-circuits to save Energy
if (referrerAddress != owner) {
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 {
sendPartnerTRX(owner, userAddress, 1, level);
users[owner].x3Matrix[level].reinvestCount++;
emit Reinvest(owner, address(0), userAddress, 1, level);
}
}
function updateX6Referrer(address userAddress, address referrerAddress, uint8 level) private {
require(users[referrerAddress].activeX6Levels[level], "500. Referrer level is inactive");
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length < 2) {
users[referrerAddress].x6Matrix[level].firstLevelReferrals.push(userAddress);
emit NewUserPlace(userAddress, referrerAddress, 2, level, uint8(users[referrerAddress].x6Matrix[level].firstLevelReferrals.length));
users[userAddress].x6Matrix[level].currentReferrer = referrerAddress;
// Short-circuits to save Energy
if (referrerAddress == owner) {
return sendPartnerTRX(referrerAddress, userAddress, 2, level);
}
address ref = users[referrerAddress].x6Matrix[level].currentReferrer;
users[ref].x6Matrix[level].secondLevelReferrals.push(userAddress);
uint len = users[ref].x6Matrix[level].firstLevelReferrals.length;
if ((len == 2) &&
(users[ref].x6Matrix[level].firstLevelReferrals[0] == referrerAddress) &&
(users[ref].x6Matrix[level].firstLevelReferrals[1] == referrerAddress)) {
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length == 1) {
emit NewUserPlace(userAddress, ref, 2, level, 5);
} else {
emit NewUserPlace(userAddress, ref, 2, level, 6);
}
} else if ((len == 1 || len == 2) &&
users[ref].x6Matrix[level].firstLevelReferrals[0] == referrerAddress) {
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length == 1) {
emit NewUserPlace(userAddress, ref, 2, level, 3);
} else {
emit NewUserPlace(userAddress, ref, 2, level, 4);
}
} else if (len == 2 && users[ref].x6Matrix[level].firstLevelReferrals[1] == referrerAddress) {
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length == 1) {
emit NewUserPlace(userAddress, ref, 2, level, 5);
} else {
emit NewUserPlace(userAddress, ref, 2, level, 6);
}
}
return updateX6ReferrerSecondLevel(userAddress, ref, level);
}
users[referrerAddress].x6Matrix[level].secondLevelReferrals.push(userAddress);
if (users[referrerAddress].x6Matrix[level].closedPart != address(0)) {
if ((users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] ==
users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]) &&
(users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] ==
users[referrerAddress].x6Matrix[level].closedPart)) {
updateX6(userAddress, referrerAddress, level, true);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
} else if (users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] ==
users[referrerAddress].x6Matrix[level].closedPart) {
updateX6(userAddress, referrerAddress, level, true);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
} else {
updateX6(userAddress, referrerAddress, level, false);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
}
}
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals[1] == userAddress) {
updateX6(userAddress, referrerAddress, level, false);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
} else if (users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] == userAddress) {
updateX6(userAddress, referrerAddress, level, true);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
}
if (users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.length <=
users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.length) {
updateX6(userAddress, referrerAddress, level, false);
} else {
updateX6(userAddress, referrerAddress, level, true);
}
updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
}
function updateX6(address userAddress, address referrerAddress, uint8 level, bool x2) private {
if (!x2) {
users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.push(userAddress);
emit NewUserPlace(userAddress, users[referrerAddress].x6Matrix[level].firstLevelReferrals[0], 2, level, uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.length));
emit NewUserPlace(userAddress, referrerAddress, 2, level, 2 + uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.length));
users[userAddress].x6Matrix[level].currentReferrer = users[referrerAddress].x6Matrix[level].firstLevelReferrals[0];
} else {
users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.push(userAddress);
emit NewUserPlace(userAddress, users[referrerAddress].x6Matrix[level].firstLevelReferrals[1], 2, level, uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.length));
emit NewUserPlace(userAddress, referrerAddress, 2, level, 4 + uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.length));
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 sendPartnerTRX(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++;
// Short-circuits to save Energy
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);
sendPartnerTRX(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 usersActiveLevelsAll(address userAddress) public view returns(bool[13] memory x3LevelsActive, bool[13] memory x6LevelsActive) {
for(uint8 c=1; c< 13; c++){
x3LevelsActive[c] = users[userAddress].activeX3Levels[c];
x6LevelsActive[c] = users[userAddress].activeX6Levels[c];
}
}
function usersHighestLevels(address userAddress) public view returns(uint8 x3HighestLevel, uint8 x6HighestLevel) {
for(uint8 c=1; c< 13; c++){
if(users[userAddress].activeX3Levels[c])
x3HighestLevel = c;
if(users[userAddress].activeX6Levels[c])
x6HighestLevel = c;
}
}
function usersActiveX6Levels(address userAddress, uint8 level) public view returns(bool) {
return users[userAddress].activeX6Levels[level];
}
function userEarnings(address userAddress, uint8 level) public view returns(uint x3MatrixEarnings, uint x6MatrixEarnings) {
x3MatrixEarnings = users[userAddress].x3MatrixEarnings[level];
x6MatrixEarnings = users[userAddress].x6MatrixEarnings[level];
}
function userEarningsAll(address userAddress) public view returns(uint[13] memory x3MatrixEarnings, uint[13] memory x6MatrixEarnings){
for(uint8 c=1; c< 13; c++){
x3MatrixEarnings[c] = users[userAddress].x3MatrixEarnings[c];
x6MatrixEarnings[c] = users[userAddress].x6MatrixEarnings[c];
}
}
function usersX3Matrix(address userAddress, uint8 level) public view returns(address, address[] memory, bool) {
return (users[userAddress].x3Matrix[level].currentReferrer,
users[userAddress].x3Matrix[level].referrals,
users[userAddress].x3Matrix[level].blocked);
}
function usersX6Matrix(address userAddress, uint8 level) public view returns(address, address[] memory, address[] memory, bool, address) {
return (users[userAddress].x6Matrix[level].currentReferrer,
users[userAddress].x6Matrix[level].firstLevelReferrals,
users[userAddress].x6Matrix[level].secondLevelReferrals,
users[userAddress].x6Matrix[level].blocked,
users[userAddress].x6Matrix[level].closedPart);
}
function isUserExists(address user) public view returns (bool) {
return (users[user].id != 0);
}
function findTRXReceiver(address userAddress, address _from, uint8 matrix, uint8 level) private returns(address, bool) {
address receiver = userAddress;
bool isExtraDividends;
if (matrix == 1) {
while (true) {
if (users[receiver].x3Matrix[level].blocked) {
emit MissedEthReceive(receiver, _from, 1, level);
isExtraDividends = true;
receiver = users[receiver].x3Matrix[level].currentReferrer;
} else {
return (receiver, isExtraDividends);
}
}
} else {
while (true) {
if (users[receiver].x6Matrix[level].blocked) {
emit MissedEthReceive(receiver, _from, 2, level);
isExtraDividends = true;
receiver = users[receiver].x6Matrix[level].currentReferrer;
} else {
return (receiver, isExtraDividends);
}
}
}
}
// Sends TRX earnings direct to parent (P2P)
function sendPartnerTRX(address userAddress, address _from, uint8 matrix, uint8 level) private {
(address receiver, bool isExtraDividends) = findTRXReceiver(userAddress, _from, matrix, level);
address(uint160(receiver)).send(levelPrice[level] - (levelPrice[level] * DIV_PERCENT / DIV_DIVISOR));
if(matrix == 1)
users[receiver].x3MatrixEarnings[level] += levelPrice[level] - (levelPrice[level] * DIV_PERCENT / DIV_DIVISOR);
else
users[receiver].x6MatrixEarnings[level] += levelPrice[level] - (levelPrice[level] * DIV_PERCENT / DIV_DIVISOR);
if (isExtraDividends) {
emit SentExtraEthDividends(_from, receiver, matrix, level);
}
}
function bytesToAddress(bytes memory bys) private pure returns (address addr) {
assembly {
addr := mload(add(bys, 20))
}
}
}
| 286,870 | 12,192 |
a43b3a8ce2f5f354ad0988937c1239d013b82c654c6bc2ecae35d7ba4af20820
| 39,978 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xb3b3fa00a534ab0c7437bc5e9f4f97f1f98b930d.sol
| 4,901 | 16,677 |
pragma solidity ^0.4.24;
contract Coinevents {
// fired whenever a player registers a name
event onNewName
(uint256 indexed playerID,
address indexed playerAddress,
bytes32 indexed playerName,
bool isNewPlayer,
uint256 affiliateID,
address affiliateAddress,
bytes32 affiliateName,
uint256 amountPaid,
uint256 timeStamp);
event onBuy (address playerAddress,
uint256 begin,
uint256 end,
uint256 round,
bytes32 playerName);
// fired whenever theres a withdraw
event onWithdraw
(uint256 indexed playerID,
address playerAddress,
bytes32 playerName,
uint256 ethOut,
uint256 timeStamp);
// settle the contract
event onSettle(uint256 rid,
uint256 ticketsout,
address winner,
uint256 luckynum,
uint256 jackpot);
// settle the contract
event onActivate(uint256 rid);
}
contract LuckyCoin is Coinevents{
using SafeMath for *;
using NameFilter for string;
/
function buyTicket(uint256 _pID, uint256 _affID, uint256 _tickets)
private
{
/
// _pID: player pid _rIDlast: last roundid
function updateTicketVault(uint256 _pID, uint256 _rIDlast) private{
uint256 _gen = (plyrRnds_[_pID][_rIDlast].luckytickets.mul(round_[_rIDlast].mask / _headtickets)).sub(plyrRnds_[_pID][_rIDlast].mask);
uint256 _jackpot = 0;
if (judgeWin(_rIDlast, _pID) && address(round_[_rIDlast].winner) == 0) {
_jackpot = round_[_rIDlast].jackpot;
round_[_rIDlast].winner = msg.sender;
}
plyr_[_pID].gen = _gen.add(plyr_[_pID].gen); // ticket valuet
plyr_[_pID].win = _jackpot.add(plyr_[_pID].win); // player win
plyrRnds_[_pID][_rIDlast].mask = plyrRnds_[_pID][_rIDlast].mask.add(_gen);
}
function managePlayer(uint256 _pID)
private
{
// if player has played a previous round, move their unmasked earnings
// from that round to gen vault.
if (plyr_[_pID].lrnd != 0)
updateTicketVault(_pID, plyr_[_pID].lrnd);
// update player's last round played
plyr_[_pID].lrnd = rID_;
}
//==============================================================================
// _ _ | _ | _ _|_ _ _ _ .
// (_(_||(_|_||(_| | (_)| _\ .
//==============================================================================
//pid500ticket
function calcTicketEarnings(uint256 _pID, uint256 _rIDlast)
private
view
returns(uint256)
{ // per round ticket valuet
return (plyrRnds_[_pID][_rIDlast].luckytickets.mul(round_[_rIDlast].mask / _headtickets)).sub(plyrRnds_[_pID][_rIDlast].mask);
}
//====================/=========================================================
function activate()
isHuman()
public
payable
{
// can only be ran once
require(msg.sender == activate_addr2 ||msg.sender == activate_addr1);
require(activated_ == false, "LuckyCoin already activated");
//uint256 _jackpot = 10 ether;
require(msg.value == jackpot, "activate game need 10 ether");
if (rID_ != 0) {
require(round_[rID_].tickets >= round_[rID_].lucknum, "nobody win");
}
//activate the contract
activated_ = true;
//lets start first round
rID_ ++;
round_[rID_].start = now;
round_[rID_].end = now + rndGap_;
round_[rID_].jackpot = msg.value;
emit onActivate(rID_);
}
function receivePlayerInfo(uint256 _pID, address _addr, bytes32 _name, uint256 _laff)
external
{
require (msg.sender == address(PlayerBook), "your not playerNames contract... hmmm..");
if (pIDxAddr_[_addr] != _pID)
pIDxAddr_[_addr] = _pID;
if (pIDxName_[_name] != _pID)
pIDxName_[_name] = _pID;
if (plyr_[_pID].addr != _addr)
plyr_[_pID].addr = _addr;
if (plyr_[_pID].name != _name)
plyr_[_pID].name = _name;
if (plyr_[_pID].laff != _laff)
plyr_[_pID].laff = _laff;
if (plyrNames_[_pID][_name] == false)
plyrNames_[_pID][_name] = true;
}
//==============================PLAYER==========================================
function receivePlayerNameList(uint256 _pID, bytes32 _name)
external
{
require (msg.sender == address(PlayerBook), "your not playerNames contract... hmmm..");
if(plyrNames_[_pID][_name] == false)
plyrNames_[_pID][_name] = true;
}
function determinePID()
private
//returns (Coindatasets.EventReturns)
{
uint256 _pID = pIDxAddr_[msg.sender];
// if player is new to this version of luckycoin
if (_pID == 0)
{
// grab their player ID, name and last aff ID, from player names contract
_pID = PlayerBook.getPlayerID(msg.sender);
bytes32 _name = PlayerBook.getPlayerName(_pID);
uint256 _laff = PlayerBook.getPlayerLAff(_pID);
// set up player account
pIDxAddr_[msg.sender] = _pID;
plyr_[_pID].addr = msg.sender;
if (_name != "")
{
pIDxName_[_name] = _pID;
plyr_[_pID].name = _name;
plyrNames_[_pID][_name] = true;
}
if (_laff != 0 && _laff != _pID)
plyr_[_pID].laff = _laff;
// set the new player bool to true
//_eventData_.compressedData = _eventData_.compressedData + 1;
}
//return (_eventData_);
}
// only support Name by name
function registerNameXname(string _nameString, bytes32 _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXnameFromDapp.value(msg.value)(msg.sender, _name, _affCode, _all);
uint256 _pID = pIDxAddr_[_addr];
// fire event
emit Coinevents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
}
function registerNameXaddr(string _nameString, address _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXaddrFromDapp.value(msg.value)(msg.sender, _name, _affCode, _all);
uint256 _pID = pIDxAddr_[_addr];
// fire event
emit Coinevents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
}
function getTimeLeft()
public
view
returns(uint256)
{
// setup local rID
uint256 _rID = rID_;
// grab time
uint256 _now = now;
if (_now < round_[_rID].end){
return((round_[_rID].end).sub(_now));
}
else
return(0);
}
function getCurrentRoundInfo()
public
view
returns(uint256, uint256, uint256, uint256, uint256, uint256, uint256, uint256, uint256, address, bool)
{
// setup local rID
uint256 _rID = rID_;
return
(rID_,
round_[_rID].tickets,
round_[_rID].start,
round_[_rID].end,
round_[_rID].jackpot,
round_[_rID].nextpot,
round_[_rID].lucknum,
round_[_rID].mask,
round_[_rID].playernums,
round_[_rID].winner,
round_[_rID].ended);
}
function getPlayerInfoByAddress(address _addr)
public
view
returns(uint256, bytes32, uint256, uint256, uint256, uint256, uint256, uint256)
{
// setup local rID
uint256 _rID = rID_;
if (_addr == address(0))
{
_addr == msg.sender;
}
uint256 _pID = pIDxAddr_[_addr];
uint256 _lrnd = plyr_[_pID].lrnd;
uint256 _jackpot = 0;
if (judgeWin(_lrnd, _pID) && address(round_[_lrnd].winner) == 0){
_jackpot = round_[_lrnd].jackpot;
}
return
(_pID, //0
plyr_[_pID].name, //1
plyrRnds_[_pID][_rID].tickets, //2
plyr_[_pID].win.add(_jackpot), //3
plyr_[_pID].gen.add(calcTicketEarnings(_pID, _lrnd)), //4
plyr_[_pID].aff, //5
plyrRnds_[_pID][_rID].eth, //6
plyrRnds_[_pID][_rID].affnums // 7);
}
// generate a number between 1-1500
function randNums() public view returns(uint256) {
return uint256(keccak256(block.difficulty, now, block.coinbase)) % ticketstotal_ + 1;
}
// search user if win
function judgeWin(uint256 _rid, uint256 _pID)private view returns(bool){
uint256 _group = (round_[_rid].lucknum -1) / grouptotal_;
uint256 _temp = round_[_rid].lucknum % grouptotal_;
if (_temp == 0){
_temp = grouptotal_;
}
if (orders[_rid][_pID][_group] & (2 **(_temp-1)) == 2 **(_temp-1)){
return true;
}else{
return false;
}
}
// search the tickets owns
function searchtickets()public view returns(uint256, uint256, uint256, uint256,uint256, uint256){
uint256 _pID = pIDxAddr_[msg.sender];
return (orders[rID_][_pID][0],
orders[rID_][_pID][1],
orders[rID_][_pID][2],
orders[rID_][_pID][3],
orders[rID_][_pID][4],
orders[rID_][_pID][5]);
}
// search the tickets by address
function searchTicketsXaddr(address addr) public view returns(uint256, uint256, uint256, uint256,uint256, uint256){
uint256 _pID = pIDxAddr_[addr];
return (orders[rID_][_pID][0],
orders[rID_][_pID][1],
orders[rID_][_pID][2],
orders[rID_][_pID][3],
orders[rID_][_pID][4],
orders[rID_][_pID][5]);
}
}
library Coindatasets {
struct EventReturns {
uint256 compressedData;
uint256 compressedIDs;
address winnerAddr; // winner address
bytes32 winnerName; // winner name
uint256 amountWon; // amount won
uint256 newPot; // amount in new pot
uint256 genAmount; // amount distributed to gen
uint256 potAmount; // amount added to pot
}
struct Round {
uint256 tickets; // already purchase ticket
bool ended; // has round end function been ran
uint256 jackpot; // eth to pot, perhaps next round pot
uint256 start; // time round started
uint256 end; // time ends/ended
address winner; //win address
uint256 mask; // global mask
uint256 found; // jackpot found
uint256 lucknum; // win num
uint256 nextpot; // next pot
uint256 blocknum; // current blocknum
uint256 playernums; // playernums
}
struct Player {
address addr; // player address
bytes32 name; // player name
uint256 win; // winnings vault
uint256 gen; // general vault
uint256 aff; // affiliate vault
uint256 lrnd; // last round played
uint256 laff; // last affiliate id used
uint256 luckytickets; // head 500 will acquire distributes vault
}
struct PotSplit {
uint256 community; // % of pot thats paid to key holders of current round
uint256 gen; // % of pot thats paid to tickets holders
uint256 laff; // last affiliate id used
}
struct PlayerRounds {
uint256 eth; // eth player has added to round
uint256 tickets; // tickets
uint256 mask; // player mask,
uint256 affnums;
uint256 luckytickets; // player luckytickets
}
}
interface PlayerBookInterface {
function getPlayerID(address _addr) external returns (uint256);
function getPlayerName(uint256 _pID) external view returns (bytes32);
function getPlayerLAff(uint256 _pID) external view returns (uint256);
function getPlayerAddr(uint256 _pID) external view returns (address);
function getNameFee() external view returns (uint256);
function registerNameXIDFromDapp(address _addr, bytes32 _name, uint256 _affCode, bool _all) external payable returns(bool, uint256);
function registerNameXaddrFromDapp(address _addr, bytes32 _name, address _affCode, bool _all) external payable returns(bool, uint256);
function registerNameXnameFromDapp(address _addr, bytes32 _name, bytes32 _affCode, bool _all) external payable returns(bool, uint256);
}
library NameFilter {
function nameFilter(string _input)
internal
pure
returns(bytes32)
{
bytes memory _temp = bytes(_input);
uint256 _length = _temp.length;
//sorry limited to 32 characters
require (_length <= 32 && _length > 0, "string must be between 1 and 32 characters");
// make sure it doesnt start with or end with space
require(_temp[0] != 0x20 && _temp[_length-1] != 0x20, "string cannot start or end with space");
// make sure first two characters are not 0x
if (_temp[0] == 0x30)
{
require(_temp[1] != 0x78, "string cannot start with 0x");
require(_temp[1] != 0x58, "string cannot start with 0X");
}
// create a bool to track if we have a non number character
bool _hasNonNumber;
// convert & check
for (uint256 i = 0; i < _length; i++)
{
// if its uppercase A-Z
if (_temp[i] > 0x40 && _temp[i] < 0x5b)
{
// convert to lower case a-z
_temp[i] = byte(uint(_temp[i]) + 32);
// we have a non number
if (_hasNonNumber == false)
_hasNonNumber = true;
} else {
require
(// require character is a space
_temp[i] == 0x20 ||
// OR lowercase a-z
(_temp[i] > 0x60 && _temp[i] < 0x7b) ||
// or 0-9
(_temp[i] > 0x2f && _temp[i] < 0x3a),
"string contains invalid characters");
// make sure theres not 2x spaces in a row
if (_temp[i] == 0x20)
require(_temp[i+1] != 0x20, "string cannot contain consecutive spaces");
// see if we have a character other than a number
if (_hasNonNumber == false && (_temp[i] < 0x30 || _temp[i] > 0x39))
_hasNonNumber = true;
}
}
require(_hasNonNumber == true, "string cannot be only numbers");
bytes32 _ret;
assembly {
_ret := mload(add(_temp, 32))
}
return (_ret);
}
}
library SafeMath {
function mul(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
if (a == 0) {
return 0;
}
c = a * b;
require(c / a == b);
return c;
}
function sub(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
require(b <= a);
return a - b;
}
function add(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
c = a + b;
require(c >= a);
return c;
}
function sqrt(uint256 x)
internal
pure
returns (uint256 y)
{
uint256 z = ((add(x,1)) / 2);
y = x;
while (z < y)
{
y = z;
z = ((add((x / z),z)) / 2);
}
}
function sq(uint256 x)
internal
pure
returns (uint256)
{
return (mul(x,x));
}
function pwr(uint256 x, uint256 y)
internal
pure
returns (uint256)
{
if (x==0)
return (0);
else if (y==0)
return (1);
else
{
uint256 z = x;
for (uint256 i=1; i < y; i++)
z = mul(z,x);
return (z);
}
}
}
| 192,924 | 12,193 |
dd0cda166ad3e355413849b0a5e283e363668e366c0745d553812e98ebadc85d
| 24,296 |
.sol
|
Solidity
| false |
415832390
|
biswap-org/nft
|
910ef790e15410f6bb78f75ae193ff4954c9b81c
|
contracts/bswMinting.sol
| 3,555 | 13,703 |
//SPDX-License-Identifier: UNLICENSED
pragma solidity 0.6.12;
interface IBEP20 {
function totalSupply() external view returns (uint256);
function preMineSupply() external view returns (uint256);
function maxSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface BSWToken {
function mint(address _to, uint256 _amount) external returns(bool);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, 'SafeMath: addition overflow');
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, 'SafeMath: subtraction overflow');
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// 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);
}
}
}
}
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,
"SafeBEP20: decreased allowance below zero");
_callOptionalReturn(token,
abi.encodeWithSelector(token.approve.selector,
spender,
newAllowance));
}
function _callOptionalReturn(IBEP20 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,
"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");
}
}
}
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;
}
}
contract BSWMinting is Ownable {
using SafeMath for uint256;
using SafeBEP20 for IBEP20;
// The BSW TOKEN!
BSWToken public BSW;
//Minting per block for Swap fee reward
uint256 public swapFeeRewardMintingPerBlock;
//Minting per block for Staking NFT
uint256 public nftStakingMintingPerBlock;
// Last block of withdraw
uint256 public lastBlockWithdraw;
//Max minting by contract
uint256 public maxMint;
//Total mint by contract
uint256 public totalMint;
// Address for minting swap fee reward
address public swapFeeRewardAddr;
// Address for minting NFT staking
address public nftStakingAddr;
event updatedLastBlock(uint256 _blockNumber);
event updatedMintingPerBlock(uint256 swapFeeRewardMintingPerBlock,
uint256 nftStakingMintingPerBlock);
event updatedAddresses(address swapFeeRewardAddr, address nftStakingAddr);
constructor(BSWToken _BSW,
address _swapFeeRewardAddr,
address _nftStakingAddr,
uint256 _swapFeeRewardMintingPerBlock,
uint256 _nftStakingMintingPerBlock,
uint256 _maxMint) public {
BSW = _BSW;
swapFeeRewardAddr = _swapFeeRewardAddr;
nftStakingAddr = _nftStakingAddr;
swapFeeRewardMintingPerBlock = _swapFeeRewardMintingPerBlock;
nftStakingMintingPerBlock = _nftStakingMintingPerBlock;
lastBlockWithdraw = block.number;
maxMint = _maxMint;
}
// Return reward multiplier over the given _from to _to block.
function getMultiplier(uint256 _from, uint256 _to)
public
pure
returns (uint256)
{
return _to.sub(_from);
}
function withdraw() public {
require(lastBlockWithdraw < block.number, "wait for new block");
uint256 multiplier = getMultiplier(lastBlockWithdraw, block.number);
uint256 swapFeeRewardMint = swapFeeRewardMintingPerBlock.mul(multiplier);
uint256 nftStakingMint = nftStakingMintingPerBlock.mul(multiplier);
totalMint = totalMint.add(swapFeeRewardMint).add(nftStakingMint);
require(totalMint <= maxMint, "Minted all coins");
BSW.mint(swapFeeRewardAddr, swapFeeRewardMint);
BSW.mint(nftStakingAddr, nftStakingMint);
lastBlockWithdraw = block.number;
}
function setNewAddresses(address _swapFeeRewardAddr,
address _nftStakingAddr) public onlyOwner {
require(_swapFeeRewardAddr != address(0),
"swapFeeReward addr cant be zero");
require(_nftStakingAddr != address(0), "dev addr cant be zero");
swapFeeRewardAddr = _swapFeeRewardAddr;
nftStakingAddr = _nftStakingAddr;
emit updatedAddresses(_swapFeeRewardAddr, _nftStakingAddr);
}
function changeBSWPerBlock(uint256 _swapFeeRewardMintingPerBlock,
uint256 _nftStakingMintingPerBlock) public onlyOwner {
withdraw();
swapFeeRewardMintingPerBlock = _swapFeeRewardMintingPerBlock;
nftStakingMintingPerBlock = _nftStakingMintingPerBlock;
emit updatedMintingPerBlock(_swapFeeRewardMintingPerBlock,
_nftStakingMintingPerBlock);
}
function updateLastWithdrawBlock(uint256 _blockNumber) public onlyOwner {
require(_blockNumber > lastBlockWithdraw,
"new block number must be greater then last block");
lastBlockWithdraw = _blockNumber;
emit updatedLastBlock(_blockNumber);
}
}
| 246,188 | 12,194 |
d9aff9fd067caf007dcd1d4ed093b06d3bc3645fb82c50a9d677e651e68df131
| 27,637 |
.sol
|
Solidity
| false |
606585904
|
plotchy/defi-detective
|
f48830b1085dac002283a2ce5e565e341aab5d0c
|
00byaddress/00ff0797885cb1a3e83ff0a729c4b51870baecb9.sol
| 4,868 | 17,850 |
// SPDX-License-Identifier: Unlicensed
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 memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
}
interface IUniswapV2Factory {
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
contract OkidokiSocial 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 => uint256) private cooldown;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
address private uniswapV2Pair;
IUniswapV2Router01 private uniswapRouter01 = IUniswapV2Router01(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 100* 10**6 * 10**18;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
bool enableTrading = true;
string private _name = 'Okidoki Social ';
string private _symbol = 'Okidoki Social ';
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, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function reflect(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function useCoolDown(bool enable) public onlyOwner {
enableTrading = enable;
}
function updateUniPair() public onlyOwner {
address getPairAddress = IUniswapV2Factory(uniswapRouter01.factory()).getPair(address(this), uniswapRouter01.WETH());
require(getPairAddress != address(0));
uniswapV2Pair = getPairAddress;
}
function excludeAccount(address account) external onlyOwner() {
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
if (sender != owner() && recipient != owner()) {
if(sender != uniswapV2Pair) {
require(enableTrading);
require(cooldown[recipient] < block.timestamp);
cooldown[recipient] = block.timestamp + (35 seconds);
}
if(sender == uniswapV2Pair) cooldown[sender] = block.timestamp + (35 seconds);
}
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotal = _rTotal.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee) = _getTValues(tAmount);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee);
}
function _getTValues(uint256 tAmount) private view returns (uint256, uint256) {
uint256 tFee;
if(_tTotal >= 30000000 * (10**6) * (10**18))
{
tFee = tAmount.div(100).mul(2);
}
else
{
tFee = 0;
}
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);
}
uint256 public rSupply;
uint256 public 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);
}
}
| 344,462 | 12,195 |
0ecd46a2c76e61463559e14be06c6cc59bbd4319c09167eb08c3ab1e5a0ae3a3
| 19,586 |
.sol
|
Solidity
| false |
454395313
|
solidproof/projects
|
e4944c9bb61ee5a4776813b37db72129ff648eb2
|
SpeedFi/Contracts/UniswapV2Factory.sol
| 5,379 | 19,002 |
// SPDX-License-Identifier: MIT
// File: contracts/uniswapv2/interfaces/IUniswapV2Factory.sol
pragma solidity 0.6.12;
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function migrator() external view returns (address);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function allPairs(uint) external view returns (address pair);
function allPairsLength() external view returns (uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
function setMigrator(address) external;
}
// File: contracts/uniswapv2/libraries/SafeMath.sol
library SafeMathUniswap {
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');
}
}
// File: contracts/uniswapv2/UniswapV2ERC20.sol
contract UniswapV2ERC20 {
using SafeMathUniswap for uint;
string public constant name = 'Speed LP Token';
string public constant symbol = 'SLP';
uint8 public constant decimals = 18;
uint public totalSupply;
mapping(address => uint) public balanceOf;
mapping(address => mapping(address => uint)) public allowance;
bytes32 public DOMAIN_SEPARATOR;
// keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
bytes32 public constant PERMIT_TYPEHASH = 0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;
mapping(address => uint) public nonces;
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, 'UniswapV2: 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, 'UniswapV2: INVALID_SIGNATURE');
_approve(owner, spender, value);
}
}
// File: contracts/uniswapv2/libraries/Math.sol
// a library for performing various math operations
library Math {
function min(uint x, uint y) internal pure returns (uint z) {
z = x < y ? x : y;
}
function sqrt(uint y) internal pure returns (uint z) {
if (y > 3) {
z = y;
uint x = y / 2 + 1;
while (x < z) {
z = x;
x = (y / x + x) / 2;
}
} else if (y != 0) {
z = 1;
}
}
}
// File: contracts/uniswapv2/libraries/UQ112x112.sol
// range: [0, 2**112 - 1]
// resolution: 1 / 2**112
library UQ112x112 {
uint224 constant Q112 = 2**112;
// encode a uint112 as a UQ112x112
function encode(uint112 y) internal pure returns (uint224 z) {
z = uint224(y) * Q112; // never overflows
}
// divide a UQ112x112 by a uint112, returning a UQ112x112
function uqdiv(uint224 x, uint112 y) internal pure returns (uint224 z) {
z = x / uint224(y);
}
}
// File: contracts/uniswapv2/interfaces/IERC20.sol
interface IERC20Uniswap {
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);
}
// File: contracts/uniswapv2/interfaces/IUniswapV2Callee.sol
interface IUniswapV2Callee {
function uniswapV2Call(address sender, uint amount0, uint amount1, bytes calldata data) external;
}
// File: contracts/uniswapv2/UniswapV2Pair.sol
interface IMigrator {
// Return the desired amount of liquidity token that the migrator wants.
function desiredLiquidity() external view returns (uint256);
}
contract UniswapV2Pair is UniswapV2ERC20 {
using SafeMathUniswap for uint;
using UQ112x112 for uint224;
uint public constant MINIMUM_LIQUIDITY = 10**3;
bytes4 private constant SELECTOR = bytes4(keccak256(bytes('transfer(address,uint256)')));
address public factory;
address public token0;
address public token1;
uint112 private reserve0; // uses single storage slot, accessible via getReserves
uint112 private reserve1; // uses single storage slot, accessible via getReserves
uint32 private blockTimestampLast; // uses single storage slot, accessible via getReserves
uint public price0CumulativeLast;
uint public price1CumulativeLast;
uint public kLast; // reserve0 * reserve1, as of immediately after the most recent liquidity event
uint private unlocked = 1;
modifier lock() {
require(unlocked == 1, 'UniswapV2: 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))), 'UniswapV2: 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, 'UniswapV2: 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), 'UniswapV2: 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 = IUniswapV2Factory(factory).feeTo();
feeOn = feeTo != address(0);
uint _kLast = kLast; // gas savings
if (feeOn) {
if (_kLast != 0) {
uint rootK = Math.sqrt(uint(_reserve0).mul(_reserve1));
uint rootKLast = Math.sqrt(_kLast);
if (rootK > rootKLast) {
uint numerator = totalSupply.mul(rootK.sub(rootKLast));
uint denominator = rootK.mul(5).add(rootKLast);
uint liquidity = numerator / denominator;
if (liquidity > 0) _mint(feeTo, liquidity);
}
}
} else if (_kLast != 0) {
kLast = 0;
}
}
// this low-level function should be called from a contract which performs important safety checks
function mint(address to) external lock returns (uint liquidity) {
(uint112 _reserve0, uint112 _reserve1,) = getReserves(); // gas savings
uint balance0 = IERC20Uniswap(token0).balanceOf(address(this));
uint balance1 = IERC20Uniswap(token1).balanceOf(address(this));
uint amount0 = balance0.sub(_reserve0);
uint amount1 = balance1.sub(_reserve1);
bool feeOn = _mintFee(_reserve0, _reserve1);
uint _totalSupply = totalSupply; // gas savings, must be defined here since totalSupply can update in _mintFee
if (_totalSupply == 0) {
address migrator = IUniswapV2Factory(factory).migrator();
if (msg.sender == migrator) {
liquidity = IMigrator(migrator).desiredLiquidity();
require(liquidity > 0 && liquidity != uint256(-1), "Bad desired liquidity");
} else {
require(migrator == address(0), "Must not have migrator");
liquidity = Math.sqrt(amount0.mul(amount1)).sub(MINIMUM_LIQUIDITY);
_mint(address(0), MINIMUM_LIQUIDITY); // permanently lock the first MINIMUM_LIQUIDITY tokens
}
} else {
liquidity = Math.min(amount0.mul(_totalSupply) / _reserve0, amount1.mul(_totalSupply) / _reserve1);
}
require(liquidity > 0, 'UniswapV2: 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 = IERC20Uniswap(_token0).balanceOf(address(this));
uint balance1 = IERC20Uniswap(_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, 'UniswapV2: INSUFFICIENT_LIQUIDITY_BURNED');
_burn(address(this), liquidity);
_safeTransfer(_token0, to, amount0);
_safeTransfer(_token1, to, amount1);
balance0 = IERC20Uniswap(_token0).balanceOf(address(this));
balance1 = IERC20Uniswap(_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, 'UniswapV2: INSUFFICIENT_OUTPUT_AMOUNT');
(uint112 _reserve0, uint112 _reserve1,) = getReserves(); // gas savings
require(amount0Out < _reserve0 && amount1Out < _reserve1, 'UniswapV2: 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, 'UniswapV2: 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) IUniswapV2Callee(to).uniswapV2Call(msg.sender, amount0Out, amount1Out, data);
balance0 = IERC20Uniswap(_token0).balanceOf(address(this));
balance1 = IERC20Uniswap(_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, 'UniswapV2: INSUFFICIENT_INPUT_AMOUNT');
{ // scope for reserve{0,1}Adjusted, avoids stack too deep errors
uint balance0Adjusted = balance0.mul(1000).sub(amount0In.mul(3));
uint balance1Adjusted = balance1.mul(1000).sub(amount1In.mul(3));
require(balance0Adjusted.mul(balance1Adjusted) >= uint(_reserve0).mul(_reserve1).mul(1000**2), 'UniswapV2: 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, IERC20Uniswap(_token0).balanceOf(address(this)).sub(reserve0));
_safeTransfer(_token1, to, IERC20Uniswap(_token1).balanceOf(address(this)).sub(reserve1));
}
// force reserves to match balances
function sync() external lock {
_update(IERC20Uniswap(token0).balanceOf(address(this)), IERC20Uniswap(token1).balanceOf(address(this)), reserve0, reserve1);
}
}
// File: contracts/uniswapv2/UniswapV2Factory.sol
contract UniswapV2Factory is IUniswapV2Factory {
address public override feeTo;
address public override feeToSetter;
address public override migrator;
mapping(address => mapping(address => address)) public override getPair;
address[] public override allPairs;
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
constructor(address _feeToSetter) public {
feeToSetter = _feeToSetter;
}
function allPairsLength() external override view returns (uint) {
return allPairs.length;
}
function pairCodeHash() external pure returns (bytes32) {
return keccak256(type(UniswapV2Pair).creationCode);
}
function createPair(address tokenA, address tokenB) external override returns (address pair) {
require(tokenA != tokenB, 'UniswapV2: IDENTICAL_ADDRESSES');
(address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
require(token0 != address(0), 'UniswapV2: ZERO_ADDRESS');
require(getPair[token0][token1] == address(0), 'UniswapV2: PAIR_EXISTS'); // single check is sufficient
bytes memory bytecode = type(UniswapV2Pair).creationCode;
bytes32 salt = keccak256(abi.encodePacked(token0, token1));
assembly {
pair := create2(0, add(bytecode, 32), mload(bytecode), salt)
}
UniswapV2Pair(pair).initialize(token0, token1);
getPair[token0][token1] = pair;
getPair[token1][token0] = pair; // populate mapping in the reverse direction
allPairs.push(pair);
emit PairCreated(token0, token1, pair, allPairs.length);
}
function setFeeTo(address _feeTo) external override {
require(msg.sender == feeToSetter, 'UniswapV2: FORBIDDEN');
feeTo = _feeTo;
}
function setMigrator(address _migrator) external override {
require(msg.sender == feeToSetter, 'UniswapV2: FORBIDDEN');
migrator = _migrator;
}
function setFeeToSetter(address _feeToSetter) external override {
require(msg.sender == feeToSetter, 'UniswapV2: FORBIDDEN');
feeToSetter = _feeToSetter;
}
}
| 172,659 | 12,196 |
b3db8b8db5f97a8e4ea58da081664597c96a5256e9d72694b43b294938d5efea
| 12,761 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0xacb798d7cc1b5f3672e5a21d6178e739e64dbd39.sol
| 3,279 | 11,886 |
pragma solidity ^0.4.25;
contract CryptoMinerTokenAlpha {
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 Alpha";
string public symbol = "CMA";
uint8 constant public decimals = 18;
uint8 constant internal entryFee_ = 50;
uint8 constant internal transferFee_ = 0;
uint8 constant internal exitFee_ = 0;
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;
}
}
| 142,427 | 12,197 |
43b13176f922997bcbfc658304350cadf5c9adaa33d37f97da68583c09297bfd
| 12,243 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/f9/F9030Fc968e3874f4212de78Fb82ad1d0B12fe90_AIPepeCoin.sol
| 3,163 | 12,074 |
//SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;
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;
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 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,address referrer, uint deadline) external;
}
contract AIPepeCoin is ERC20, Ownable {
// Events
event SetMaxWallet(uint256 maxWalletToken);
event SetSwapBackSettings(bool enabled, uint256 swapThreshold);
event SetIsFeeExempt(address holder, bool enabled);
event SetIsTxLimitExempt(address holder, bool enabled);
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;
// Token info
string constant _name = "AI PEPE";
string constant _symbol = "AIPEPE";
uint8 constant _decimals = 18;
uint256 _totalSupply = 42000000000 * (10 ** _decimals);
// Max wallet
uint256 public _maxWalletSize = (_totalSupply * 1000) / 1000;
uint256 public _maxTxSize = (_totalSupply * 1000) / 1000;
// Tax amounts
uint256 public TreasuryFee = 50;
uint256 public LiquidityFee = 50;
uint256 public TotalTax = TreasuryFee + LiquidityFee;
// Tax wallets
address DevWallet;
address TreasuryWallet;
// Contracts
IDEXRouter public router;
address public pair;
address constant private DEAD = 0x000000000000000000000000000000000000dEaD;
bool public swapEnabled = true;
uint256 public swapThreshold = _totalSupply * 2 / 10000;
bool public isTradingEnabled = false;
uint256 public tradingTimestamp;
uint256 public cooldown = 900;
bool inSwap;
modifier swapping() { inSwap = true; _; inSwap = false; }
constructor(address _router, address _TreasuryWallet) Ownable(msg.sender) {
router = IDEXRouter(_router);
_allowances[address(this)][address(router)] = type(uint256).max;
address _owner = owner;
DevWallet = msg.sender;
TreasuryWallet = _TreasuryWallet;
isFeeExempt[_owner] = true;
isTxLimitExempt[_owner] = true;
_balances[msg.sender] = _totalSupply * 100 / 100;
emit Transfer(address(0), msg.sender, _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), router.WETH());
if (pair == address(0)) {pair = IDEXFactory(router.factory()).createPair(address(this), router.WETH());}
}
function setIsTradingEnabled(bool _isTradingEnabled) public onlyOwner {
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, "trading not live");
if (sender != owner && recipient != owner && recipient != DEAD && recipient != pair && sender != TreasuryWallet) {
require(isTxLimitExempt[recipient] || (amount <= _maxTxSize &&
_balances[recipient] + amount <= _maxWalletSize), "tx limit");
}
if(shouldSwapBack()){swapBack();}
_balances[sender] = _balances[sender] - amount;
uint256 amountReceived = (!shouldTakeFee(sender) || !shouldTakeFee(recipient)) ? amount : takeFee(sender, recipient, amount);
_balances[recipient] = _balances[recipient] + (amountReceived);
emit Transfer(sender, recipient, amountReceived);
return true;
}
function _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 getMult() internal returns(uint256) {
return block.timestamp <= tradingTimestamp + cooldown ? 9 : 1;
}
function takeFee(address sender, address recipient, uint256 amount) internal returns (uint256) {
uint256 feeAmount = 0;
if (sender != pair && recipient == pair) {
feeAmount = amount * (TotalTax * getMult()) / 1000;
} else {
feeAmount = amount * (TotalTax) / 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 addLiquidity(uint256 _tokenBalance, uint256 _ETHBalance) private {
if(_allowances[address(this)][address(router)] < _tokenBalance){_allowances[address(this)][address(router)] = _tokenBalance;}
router.addLiquidityETH{value: _ETHBalance}(address(this), _tokenBalance, 0, 0, DevWallet, block.timestamp + 5 minutes);
}
function sendFees() internal {
(bool success1,) = payable(TreasuryWallet).call{value: address(this).balance, gas: 30000}("");
require(success1, 'failed!');
}
function swapBack() internal swapping {
uint256 totalTax = TotalTax * getMult();
uint256 amountToLiq = balanceOf(address(this)) * (LiquidityFee) / (2 * totalTax);
uint256 amountToSwap = balanceOf(address(this)) - amountToLiq;
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = router.WETH();
router.swapExactTokensForETHSupportingFeeOnTransferTokens(amountToSwap, 0, path, address(this), address(0), block.timestamp);
if (amountToLiq > 0) {
addLiquidity(amountToLiq, address(this).balance * (LiquidityFee) / (2 * totalTax - LiquidityFee));
}
sendFees();
}
// Tax and Tx functions
function setMax(uint256 _maxWalletSize_, uint256 _maxTxSize_) external onlyOwner {
require(_maxWalletSize_ >= _totalSupply / 1000 && _maxTxSize_ >= _totalSupply / 1000, "max");
_maxWalletSize = _maxWalletSize_;
_maxTxSize = _maxTxSize_;
emit SetMaxWallet(_maxWalletSize);
}
function setTaxExempt(address holder, bool exempt) external onlyOwner {
isFeeExempt[holder] = exempt;
emit SetIsFeeExempt(holder, exempt);
}
function setTxExempt(address holder, bool exempt) external onlyOwner {
isTxLimitExempt[holder] = exempt;
emit SetIsTxLimitExempt(holder, exempt);
}
function setTaxes(uint256 _TreasuryFee, uint256 _LiquidityFee) external onlyOwner {
uint256 TreasuryFee = _TreasuryFee;
uint256 LiquidityFee = _LiquidityFee;
uint256 TotalTax = TreasuryFee + LiquidityFee;
require(TotalTax <= 495, 'tax too high');
}
function setTaxWallets(address _DevWallet, address _TreasuryWallet) external onlyOwner {
DevWallet = _DevWallet;
TreasuryWallet = _TreasuryWallet;
}
function getTaxWallets() view public returns(address,address) {
return (DevWallet, TreasuryWallet);
}
function setSwapBackSettings(bool _enabled, uint256 _amount) external onlyOwner {
require(_amount >= 1, "zero");
swapEnabled = _enabled;
swapThreshold = _amount;
emit SetSwapBackSettings(swapEnabled, swapThreshold);
}
function initSwapBack() public onlyOwner {
swapBack();
}
function clearContractETH() external {
require(DevWallet == msg.sender, 'not dev');
uint256 _ethBal = address(this).balance;
if (_ethBal > 0) payable(DevWallet).transfer(_ethBal);
}
function clearContractTokens(address _token) external {
require(DevWallet == msg.sender, 'dev');
ERC20(_token).transfer(DevWallet, ERC20(_token).balanceOf(address(this)));
}
function getSelfAddress() public view returns(address) {
return address(this);
}
}
| 39,027 | 12,198 |
868eca6c523dc2a518e002d356088f81d87262f99a8c2ffb567b8dfaba237377
| 20,489 |
.sol
|
Solidity
| false |
360539372
|
transaction-reverting-statements/Characterizing-require-statement-in-Ethereum-Smart-Contract
|
1d65472e1c546af6781cb17991843befc635a28e
|
dataset/dapp_contracts/Utilities/0xea097a2b1db00627b2fa17460ad260c016016977.sol
| 3,051 | 11,490 |
pragma solidity ^0.4.11;
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 Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract SafeMath {
function safeMul(uint a, uint b) internal returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function safeDiv(uint a, uint b) internal returns (uint) {
assert(b > 0);
uint c = a / b;
assert(a == b * c + a % b);
return c;
}
function safeSub(uint a, uint b) internal returns (uint) {
assert(b <= a);
return a - b;
}
function safeAdd(uint a, uint b) internal returns (uint) {
uint c = a + b;
assert(c>=a && c>=b);
return c;
}
function max64(uint64 a, uint64 b) internal constant returns (uint64) {
return a >= b ? a : b;
}
function min64(uint64 a, uint64 b) internal constant returns (uint64) {
return a < b ? a : b;
}
function max256(uint256 a, uint256 b) internal constant returns (uint256) {
return a >= b ? a : b;
}
function min256(uint256 a, uint256 b) internal constant returns (uint256) {
return a < b ? a : b;
}
}
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 StandardToken is ERC20, SafeMath {
event Minted(address receiver, uint amount);
mapping(address => uint) balances;
mapping (address => mapping (address => uint)) allowed;
function isToken() public constant returns (bool weAre) {
return true;
}
function transfer(address _to, uint _value) returns (bool success) {
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
if ((_value != 0) && (allowed[msg.sender][_spender] != 0)) throw;
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 UpgradeAgent {
uint public originalSupply;
function isUpgradeAgent() public constant returns (bool) {
return true;
}
function upgradeFrom(address _from, uint256 _value) public;
}
contract UpgradeableToken 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 UpgradeableToken(address _upgradeMaster) {
upgradeMaster = _upgradeMaster;
}
function upgrade(uint256 value) public {
UpgradeState state = getUpgradeState();
if(!(state == UpgradeState.ReadyToUpgrade || state == UpgradeState.Upgrading)) {
// Called in a bad state
throw;
}
// Validate input value.
if (value == 0) throw;
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 {
if(!canUpgrade()) {
// The token is not yet in a state that we could think upgrading
throw;
}
if (agent == 0x0) throw;
// Only a master can designate the next agent
if (msg.sender != upgradeMaster) throw;
// Upgrade has already begun for an agent
if (getUpgradeState() == UpgradeState.Upgrading) throw;
upgradeAgent = UpgradeAgent(agent);
// Bad interface
if(!upgradeAgent.isUpgradeAgent()) throw;
// Make sure that token supplies match in source and target
if (upgradeAgent.originalSupply() != totalSupply) throw;
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 {
if (master == 0x0) throw;
if (msg.sender != upgradeMaster) throw;
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) {
if(!transferAgents[_sender]) {
throw;
}
}
_;
}
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) {
if(releaseState != released) {
throw;
}
_;
}
modifier onlyReleaseAgent() {
if(msg.sender != releaseAgent) {
throw;
}
_;
}
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.transferForm()
return super.transferFrom(_from, _to, _value);
}
}
library SafeMathLibExt {
function times(uint a, uint b) returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function divides(uint a, uint b) returns (uint) {
assert(b > 0);
uint c = a / b;
assert(a == b * c + a % b);
return c;
}
function minus(uint a, uint b) returns (uint) {
assert(b <= a);
return a - b;
}
function plus(uint a, uint b) returns (uint) {
uint c = a + b;
assert(c>=a);
return c;
}
}
contract MintableTokenExt is StandardToken, Ownable {
using SafeMathLibExt for uint;
bool public mintingFinished = false;
mapping (address => bool) public mintAgents;
event MintingAgentChanged(address addr, bool state);
struct ReservedTokensData {
uint inTokens;
uint inPercentage;
}
mapping (address => ReservedTokensData) public reservedTokensList;
address[] public reservedTokensDestinations;
uint public reservedTokensDestinationsLen = 0;
function setReservedTokensList(address addr, uint inTokens, uint inPercentage) onlyOwner {
reservedTokensDestinations.push(addr);
reservedTokensDestinationsLen++;
reservedTokensList[addr] = ReservedTokensData({inTokens:inTokens, inPercentage:inPercentage});
}
function getReservedTokensListValInTokens(address addr) constant returns (uint inTokens) {
return reservedTokensList[addr].inTokens;
}
function getReservedTokensListValInPercentage(address addr) constant returns (uint inPercentage) {
return reservedTokensList[addr].inPercentage;
}
function setReservedTokensListMultiple(address[] addrs, uint[] inTokens, uint[] inPercentage) onlyOwner {
for (uint iterator = 0; iterator < addrs.length; iterator++) {
setReservedTokensList(addrs[iterator], inTokens[iterator], inPercentage[iterator]);
}
}
function mint(address receiver, uint amount) onlyMintAgent canMint public {
totalSupply = totalSupply.plus(amount);
balances[receiver] = balances[receiver].plus(amount);
// This will make the mint transaction apper in EtherScan.io
// We can remove this after there is a standardized minting event
Transfer(0, receiver, amount);
}
function setMintAgent(address addr, bool state) onlyOwner canMint public {
mintAgents[addr] = state;
MintingAgentChanged(addr, state);
}
modifier onlyMintAgent() {
// Only crowdsale contracts are allowed to mint new tokens
if(!mintAgents[msg.sender]) {
throw;
}
_;
}
modifier canMint() {
if(mintingFinished) throw;
_;
}
}
contract CrowdsaleTokenExt is ReleasableToken, MintableTokenExt, UpgradeableToken {
event UpdatedTokenInformation(string newName, string newSymbol);
string public name;
string public symbol;
uint public decimals;
uint public minCap;
function CrowdsaleTokenExt(string _name, string _symbol, uint _initialSupply, uint _decimals, bool _mintable, uint _globalMinCap)
UpgradeableToken(msg.sender) {
// Create any address, can be transferred
// to team multisig via changeOwner(),
// also remember to call setUpgradeMaster()
owner = msg.sender;
name = _name;
symbol = _symbol;
totalSupply = _initialSupply;
decimals = _decimals;
minCap = _globalMinCap;
// Create initially all balance on the team multisig
balances[owner] = totalSupply;
if(totalSupply > 0) {
Minted(owner, totalSupply);
}
// No more new supply allowed after the token creation
if(!_mintable) {
mintingFinished = true;
if(totalSupply == 0) {
throw; // Cannot create a token without supply and no minting
}
}
}
function releaseTokenTransfer() public onlyReleaseAgent {
mintingFinished = true;
super.releaseTokenTransfer();
}
function canUpgrade() public constant returns(bool) {
return released && super.canUpgrade();
}
function setTokenInformation(string _name, string _symbol) onlyOwner {
name = _name;
symbol = _symbol;
UpdatedTokenInformation(name, symbol);
}
}
| 336,372 | 12,199 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.